day07_继承(下)

抽象类:

示例:

/*
抽象引入:
当多个类中出现相同功能,但是功能主体不同,
这是可以进行向上抽取.这时,只抽取功能定义,而
不抽取功能主体.

抽象类的特点:
1.抽象方法一定在抽象类中.

2.抽象方法和抽象类都必须abstract关键字修饰.

3.抽象类不可用new创建对象,因为调用抽象方法没意义

4.抽象类中的方法要被使用,必须由子类复写其所有的抽象方法后,
  建立子类对象调用.
  
  如果子类只复写了部分方法(依然有抽象方法),该子类还是一个抽象类

-->理解!
抽象类与一般类:

抽象类和一般类没有太大不同.
 该如何描述事物,就如何描述事物,只不过,该事物出现了一些看不懂的东西.
 这些不确定的部分,也是该事物的功能,需要明确出来,但是无法定义主体.
通过抽象方法来表示.

抽象类比一般类多了个抽象函数.就是在类中可以定义抽象方法.

*/

abstract class Student//abstract修饰类为了说明这个类是抽象类
{                     //里面有抽象方法,你创建对象
	                  //调用抽象方法没有意义!
  abstract void study();
  //abstract void study2();

}
class BaseStudent extends Student//如果加上 上面的abstract void study2();
                                 //BaseStudent为抽象类
{
  void study()
  {
   System.out.println("base study");
  }
}
class AdvStudent extends Student
{
	void study()
	{
	 System.out.println("adv study");
	
	}
}
class AbstractDemo
{
	public static void main(String[] args) 
	{
		new BaseStudent().study();
	}
}
/*
 抽象类中可以不定义抽象方法,这样做仅仅是不让该类创建对象.
*/

模板方法:

示例:

/*
 获取一段程序的运行时间.
  结束时间-起始时间
 利用System.currentTimeMillis();
*/
abstract class Run
{
 private long startTime;
 private long endTime;
 public final void getTime()//为了禁止子类复写(根据需要)
  { 
       startTime=System.currentTimeMillis();
       codeRun();//只创建了子类对象,调用getTime(),省略了this.codeRun()
       endTime=System.currentTimeMillis();
	   System.out.println("\t"+(endTime-startTime));
  }
  public abstract void codeRun();//这部分的内容是不确定
                                 //不一定抽象,根据需要
}
class CodeRun extends Run
{
 public void codeRun()
  {
    for(int i=1;i<1000;++i)
      System.out.print(i);
  }
}
class  TemplateDemo
{
	public static void main(String[] args) 
	{
         new CodeRun().getTime();

	}
}
/*
 什么是模板方法?
   在定义功能时,功能的一部分是确定的(getTime()),但是有一部分是不确定的(codeRun()),而确定的部分在使用不确定的部分.
   那么这时就将不确定的部分暴露出去.由该类的子类去完成.
 提高了拓展性和复用性.
*/

接口(interface):

示例:

/*
接口:初期理解,可以认为是一个特殊的抽象类
  当抽象类中的方法都是抽象的,那么该类可以通过接口形式来表示.
interface用于定义接口.

接口定义时,格式特点:
 1. 接口中常见定义:常量,抽象方法.
 2. 接口中的成员都有固定修饰符.
     常量:public static final
     方法:public abstract
  接口中的成员都是public的.

接口:因为有抽象方法,因此不可以创建对象.
 需要子类实现,子类对接口中的抽象方法
 全都覆盖后,子类才能实例化.

接口可以被类 多实现,也是对多继承 不支持 的 转换形式.
  多实现不会出现多继承的问题(当多个父类中定义了
  相同功能,但功能内容不同,子类对象不能确定运行哪一个)

  因为多实现中的功能没有方法主体,由子类任意定义
  示例:
  interface A
  {
   public abstract void show();
  }
  interface B
  {
   public abstract void show();
  }
  class C implements A,B
  {
   public abstract void show()//同时复写了接口A,B中的功能
   {
     ...
   }
  }

*/
interface Inter//编译也是生成class(java可执行)文件
{
	public static final int NUM=3;//public static final即使不写 因为interface内有固定修饰符 
	public abstract void show();//public abstract同理
}

interface InterA
{
   public abstract void show();
}

class Demo
{
   public void function()
   {
   
   }
}

class Test implements Inter,InterA//为什么写implements(实现)?
{                                //接口中的功能全都为abstract,子类要复写之后才能使用
                                 //因此用implements来更确切描述
    public void show()
	{
	
	}
}


abstract class Test2  extends Demo implements Inter,InterA //继承一个类同时还能实现多个接口(不能先实现后继承)
{


}
//接口与接口之间是继承关系
//这是因为接口中的功能都是abstract
//接口之间存在多继承
//因为接口中的功能没有方法体({ }),不会冲突.

//例如:
interface A
{
  public abstract void methodA();
}
interface B
{
  public abstract void methodB();
}
interface C extends A,B
{
  public abstract void methodC();
}
class D implements C
{
  public void methodA(){}
  public void methodB(){}
  public void methodC(){}
}



class InterfaceDemo  
{
	public static void main(String[] args) 
	{
		
	}
}


/*
 接口是程序功能扩展
 例如:足球运动员踢足球,足球运动员(其它类型的运动员则不具有)还学java.
       那么这个学习功能定义在接口中.
abstract class Sporter
{
 abstract void play();

}
interface Study
{
  
  public abstract void study();

}
class FootballPlayer extends Sporter implements Study
{
  public void study()
  {
   
  }
  void play()
  {
  
  }
}
更好点例子:http://lengjianxxxx.blog.163.com/blog/static/81188402007410114157164/

*/