抽象类和接口

抽象类和接口

抽象类

• 属性(0或多个)+方法(0或多个)

• 一个完整(健康)的类：所有的方法都有实现(方法体)

• 类可以没有方法，但是有方法就肯定要有实现，这才是一个完整的类

• 一个完整的类才可以被实例化，被new出来

• 如果一个类暂时有方法未实现，需要被定义为抽象类(若方法只有方法名字，形参列表，没有方法体，那所在的类就被定义为抽象类)

例：

public abstract class Shape{
    int area；//定义一个面积变量
        public abstract void calArea();//定义了一个计算面积的方法，却没有实现
}

• 抽象类关键字abstract声明

• 抽象类的组成

  • (optional)成员变量，个数不限

  • (optional)具体方法，方法有实现，个数不限

  • (optional)抽象方法，加abstract关键字，个数不限

（类A被定义为抽象的：abstract class A {} 因此A a = new A();是不成立的）

• 抽象类也是类。一个类继承于抽象类，那就不能继承其他(抽象)类

• 子类可以继承于抽象类，但是一定要实现父类们所有的abstract的方法。如果不能完全实现，那么子类也必须被定义为抽象类

• 只有实现父类们的所有的抽象方法，才能变成完整类

接上面的Shape类：

public class Rectangle extends Shape{
    int width;//宽
    int length;//长
    public Rectangle(int width,int length){
        this.width = width;
        this.length = length;
    }
     public void calArea(){
        System.out.println("The Area is :" + this.width * this.length);
     }//实现父类的calArea方法

    public static void main(String[] args) {
        Rectangle rect = new Rectangle(10,5);
        rect.calArea();
    }
}

接口

• 如果类的所有方法都没有实现，那么这个类就算是接口interface

例：

public interface Animal{
	public void eat();
	public void move();
}

• 类只可以继承(extend)一个类，但是可以实现(implements)多个接口，继承和实现是可以同时的

• 接口不算类，或者说是一种特殊的类

• (接口中的所有方法都是空的；一个类的方法，只会在当前类或者父类中定义，肯定不会在所实现的父类接口中定义)

• 接口可以继承多个接口，没有实现的方法将会叠加

• 类实现接口，就必须实现所有未实现的方法。如果没有全部实现，那么只能成为一个抽象类

• 接口里面可以定义变量，但是一般是常量

接口：

public class Cat implements Animal{
    public void eat(){
        System.out.println("cat：I can eat");
    }
    public void move(){
        System.out.println("cat:I can move");
    }
}

public interface  ClimbTree {
    public void climb();
}

public interface  CatFamily extends Animal,ClimbTree{
    //public void eat();
    //public void move();
    //public void climb();
    //接口可以同时继承多个接口，并将没有实现的方法叠加
}

抽象类：

public abstract class LandAnimal implements Animal {
    @Override
    public abstract void eat();

    @Override
    public void move() {
        System.out.println("");
    }
}

抽象类实现了Animal中的move方法，无法实现eat方法，在父类中定义为抽象方法；

类：

public class Rabbit extends LandAnimal implements ClimbTree{
    //继承了抽象类LandAnimal和实现ClimbTree接口；extends和implements顺序不能变
    public void climb(){
        System.out.println("rabbit:I can climb");
    }
    public void eat(){
        System.out.println("rabbit:I can eat");
    }//实现了LandAnimal中未实现的eat方法
}

public class Tiger implements CatFamily{
    //Tiger类实现CatFamily里面的所有接口
    public void eat(){
		...
    }
    public void move(){
		...
    }
    public void climb(){
		...
    }
}

总结

• 抽象类和接口的相同点：两者都不能被实例化，不能进行new操作

• 抽象类和接口类的不同点：

• 抽象类abstract，接口interface

• 抽象类可以有部分方法实现，但是接口所有的方法都不能有实现

• 一个类只能继承(extends)一个(抽象)类，实现(implements)多个接口

• 接口可以继承(extends)多个接口

• 抽象类有构造函数，接口里面没有构造函数

• 抽象类可以有main，也能运行，接口没有main

• 抽象类方法可以有private/protected，接口方法都是public