【黑马程序员】java中--------------抽象类(abstract)接口（interface）

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

一、抽象类

1、定义：当多个子类中出现相同功能，但是功能主体不同，这时可以进行向上抽取，这是只 抽取功能定义而不抽取功能主体。

这个类被abstract修饰，定义成员方法，但是没有方法体。没有花括号；

如何使用：定义类时，该如何描述事物就如何描述，只不过该事物出现了一些不确定的部分，这些部分也是该事物的功能，

   需要明确定义，但是无法定义主体，此时就通过抽象类的方式类表示。

2、抽象类的特点：

a. 抽象方法一定在抽象类中

b. 抽象方法和抽象累都必须被abstract修饰

c. 抽象类不可以创建对象，不可以new，因为调用抽象方法没有意义。

d. 抽象类中的方法要被使用，必须由子类复写所有的抽象方法，后，建立子类对象类调用方法

e. 如果子类只覆盖部分抽象方法，那么该子类还是一个抽象类

f. 如果父类是抽象类，子类是抽象类子类可以选择是否重写。

g.父类是普通类，子类是抽象类。这种情况也可以。

h. 抽象类中可以没有抽象方法。

j.普通类中可以有抽象方法。

k.抽象类有构造方法，给子类实例化用的

总结 ：抽象类中定义的方法都是共性的功能，只定义功能定义，不定义功能主体（抽象方法）。

   抽象类中可以有非抽象方法。

练习代码：

//定义一个抽象类
abstract class Person
{
          private String name ;
          private int age;
          public Person(String name ,int age)
          {
                this.name = name;
                this.age = age;
          }
           public String getName()
           {
                 return name;
           }
           public void setName(String name)
           {
                 this.name = name;
           }
           public int getAge()
           {
                 return age;
           }
           public void setAge(int age)
           {
                 this.age = age;
           }
    //定义了一个描述人这类事物的方法，而且是一个抽象方法，没有方法体
        public abstract void show();
}

3、抽象类与一般类的区别：

1、抽象类不一般类多了抽象方法。

2、抽象类不可以创建对象。

特殊：抽象类可以不定义抽象方法，这样做仅仅是不让改类创建对象。

4、 abstract关键字不能和哪些关键共存？

1.     final:被final修饰的类不能有子类。而被abstract修饰的类一定要被子类继承，并被子类去实现抽象方法，否则这个抽象类的存在没有意义。

2.     private:抽象类中的抽象方法不能用private来修饰，这样就不能被子类所知，就不能被子类复写。

3.     static:如果static用来修饰抽象方法的话，就会随着类的加载而加载，直接用类名就可以调用的话，就没有意义了，因为抽象方法没有方法体。

/*继承例子：  员工类与经理类

*/
//抽象类
abstract class Emplouyee{
	private String name;
	private String id;
	private double pay;
	Emplouyee(String name,String id,double pay){
		this.name=name;
		this.id=id;
		this.pay=pay;
	}
	public abstract void work();
	   
	   public String getName()  
       {  
             return name;  
       }  
       public void setName(String name)  
       {  
             this.name = name;  
       }  
       public String getId()  
       {  
             return id;  
       }  
       public void setId(String id)  
       {  
             this.id =id;  
       }  
       public double getPay()  
       {  
             return pay;  
       }  
       public void setPay(double pay)  
       {  
             this.pay = pay;  
       }  
}
//经理类extends抽象类
class Manager extends Emplouyee{
	private double bonus;
	Manager(String name,String id,double pay,double bonus){
		super(name,id,pay);
		this.bonus=bonus;
	}

	//复写抽象方法，
	public void work(){
		System.out.println("经理开始工作：");
	}
	public double getBonus(){
		return this.bonus;
	}
	public void setBonus(double bonus){
		this.bonus=bonus;
	}
	
}
//普通员工类extends抽象类。
class Pro extends Emplouyee{
	Pro(String name,String id,double pay){
		super(name,id,pay);
	}
	//复写抽象方法，
	public void work(){
		System.out.println("普通员工开始工作：");
	}
	
}
class JiChengDemo{
	public static void main(String[] args){
		Manager m=new Manager("张经理","Q120045", 5800.0,1500.0);
		m.work();
		System.out.println(m.getName()+" "+m.getId()+" "+m.getPay()+" "+m.getBonus());
		 Pro p=new Pro("李四","p00123",2060.0);
		p.work();
		System.out.println(p.getName()+" "+p.getId()+" "+p.getPay());
	}
}

打印结果：

经理开始工作：
张经理 Q120045 5800.0 1500.0
普通员工开始工作：
李四 p00123 2060.0

5、模板方法设计模式：

定义：在定义功能时，功能的一部分是不确定的，但是有一部分是确定的。

确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，

有该类的子类去完成复写

练习代码：

/*模板方法设计模式*/

abstract class GetTime{
	public final void getTime(){
		long start=System.currentTimeMillis();
		runCode();
		long end=System.currentTimeMillis();
		System.out.println("毫秒值："+(end-start));
	}
	public abstract void runCode();
}
class SubTime extends GetTime{
	public void runCode(){
		for(int x=0;x<4000;x++){
			System.out.print(x);
		}
	}
}
class GetTimeDemo{
	public static void main(String[] args){
		SubTime st=new SubTime();
		st.getTime();
	}
}

二、接口

1、初期理解，可以理解为一个特殊的抽象类

当抽象类中的方法读书抽象的，那么该类可以通过接口的形式来表现。

2、接口的定义格式特点：

1、接口中常见定义：常量，抽象方法

2、接口中的成员都有固定的修饰符：

常量：public static final

方法：public  abstract

记住：接口中的成员都是public的

3、接口的特点；

1、接口是不可以创建对象 的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法

  全部覆盖后，子类才可以创建对象，否则子类还是一个抽象类

2、接口与接口之间是继承关系，可以多继承，但是其中的方法一定是一模一样的，否则在调用方法时不明确

例子：

interface A 
 {  
	public abstract int show();  
 }  
  
 interface B
 {   
	public abstract boolean show();  
}  
 
interface C extends A,B  
{  
    public abstract void show();  
}

3、类与接口之间是实现关系（implements），

4、接口可以被多实现，java支持多实现

5、接口提供程序的拓展性，降低耦合性

三、抽象类和接口的比较

1.     抽象类(abstract class):一般仅用于被子类继承

当多个类中出现相同的功能，但是功能主体不一样，这时候可以进行向上抽取，只抽取功能定义，而不抽取功能主体，并将这些功能定义封装进一个类，，并且这么功能使用abstract声明修饰，并且没有方法体(没有花括号)，那么这类就成了一个抽象类，抽象类的定义使用abstract。

比如说Person这个类，有一个描述人这样的方法，但是Student类继承了Person这类，Worker类也继承了这个Person类，因为学生和工人都是人，具备一些共性，可是他们用来描述自身的功能，里面的内容肯定不一样，这样一来，冲Person类中继承的这个功能就不具备通用性，那么就可以将这个功能再想上抽取，索性将它定义为抽象方法，没有了具体的内容，直接让子类去实现复写，为这个描述人这个方法添加自己的内容，这就叫做抽象方法，叫做抽象类。

2.     接口(interface):用来建立类与类之间关联的标准

3.     区别与联系

抽象类是一种被子类继承(extends)的关系，
而接口和类是一种实现(implements)关系，
接口和接口是继承(extends)关系。
注:

a.子类只能继承一个抽象类。
b.一个类却可以实现多个接口。
c.接口可以继承多个接口。

定义特点不同:

a.     抽象类可以定义变量、非抽象方法以及抽象方法（必须有一个抽象方法）

变量:可用private、public、final、static修饰

抽象方法:能用abstract(必须有)、public、static修饰

b.     接口可以定义常量、抽象方法

常量:只能用public static final（都是存在的，如果没有会默认加上），赋值后，不可再次赋值
方法:只能 public abstract修饰

权限不同:

a.抽象类可以有私有变量或方法，子类继承抽象父类必须复写全部的抽象方法
b.接口是公开(public)的，里面不能有私有变量或方法，因为接口是对外暴露的，是提供给外界使用的.
实现接口必须重写接口中的全部抽象方法

成员不同:

a.抽象类中可以有自己的成员，也可以有非抽象的成员方法。
b.接口中只能有静态的不能被修改的成员变量（即常量），而且所有成员方法皆为抽象的。

--------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------