java基础--抽象类，接口

抽象类

抽象类：如果一个类含有抽象方法，则这个类为抽象类，用关键字abstract声明，并且一定要写，不可省略。
抽象方法：只有声明而没有实现的方法为抽象方法，用abstract声明，不可省略。

public abstract class Animal {
   String color;
   double weight;
   public Animal(String color, double weight) {
    super();
    this.color = color;
    this.weight = weight;
   } 
    public abstract void cry();
    public void display(){
        System.out.println("颜色是："+color+"体重是："+weight);
    }
    
}

此处cry()为抽象方法， Animal为抽象类。

抽象类的使用规则：

1. 抽象类与抽象方法必须都用abstract关键字声明，不可省略。
2. 抽象方法只有方法的声明而没有方法的实现。
3. 抽象方法必须为public或protected，不能为private，否则不能被子类继承，实现不了该方法。
4. 抽象类不能实例化，它的子类必须重写抽象类中的全部抽象方法。
5. 抽象类中可以定义抽象方法也可以定义普通方法，但普通类中只能定义普通方法。
6. 抽象类不能用final修饰，因为被final修饰的类不能被继承。
7. 允许在抽象类中定义构造方法，也可以在子类中用super调用父类的构造方法。
8. 抽象类使用的时候一定要有子类，子类用extends关键字来继承，一个类不能同时继承多个抽象类。

下面给出一个例子

//抽象类Animal
public abstract class Animal {
   String color;
   double weight;
   public Animal(String color, double weight) {
    super();
    this.color = color;
    this.weight = weight;
   } 
    public abstract void cry();
    public void display(){
        System.out.println("颜色是："+color+"体重是："+weight);
    }    
}

//子类Cat
public class Cat extends Animal{
    public Cat(String color, double weight) {
        super(color, weight);
    }
    public void cry(){
        System.out.println("喵喵喵");
    }
}

//子类Dog
public class Dog extends Animal {
    public Dog(String color, double weight) {
        super(color, weight);
    }
    @Override
    public void cry() {
        System.out.println("汪汪汪");
    }
}

//实现类Test
public class Test {
    public static void main(String[] args) {
        Cat cat=new Cat("red",90);
        cat.cry();
        cat.display();
        Dog dog=new Dog("green",100);
        dog.cry();
        dog.display();
    }
}

接口

接口：如果一个类中完全由静态常量（用static,final修饰）和抽象方法组成，则该类可以设计为一个接口。

接口三部曲：

• 定义接口
• 实现接口
• 使用接口

//定义接口
public interface Human {
     //静态常量
     public static final String TYPE="haha";
     //抽象方法
     public abstract void run();
     public abstract void say();
}

由于接口就是定义常量和抽象方法的，所以可以简写：

//定义接口
public interface Human {
     //静态常量
     String TYPE="haha";
     //抽象方法
     void run();
     void say();
}

接口与抽象类一样不能会直接实例化，需要通过实现类来实现（implements）接口中的抽象方法，实现类中也可以定义自己的属性和方法。

//实现Human接口
public class Person implements Human {
    double height;
    double weight;
    public Person(double height, double weight) {
        super();
        this.height = height;
        this.weight = weight;
    }
    //实现接口的抽象方法
    public void run() {
        System.out.println("我跑了两万米");
    }
    public void say() {
        System.out.println("Hello World!");
    }
    //定义自己的抽象方法
    public void display(){
        System.out.println("我的身高是:"+height+"我的体重是："+weight);
    }
}

另外定义一个类来使用该接口

//使用接口
public class Test2 {
    public static void main(String[] args) {
        Person person1=new Person(155.0,95);
        person1.display();
        person1.run();
        person1.say();
        Person person2=new Person(160.0,99);
        person2.display();
        person2.run();
        person2.say();
    }
}

运行结果：

我的身高是:155.0我的体重是：95.0
我跑了两万米
Hello World!
我的身高是:160.0我的体重是：99.0
我跑了两万米
Hello World!

接口的使用规则：

1. 接口与抽象类一样不能会直接实例化，需要通过实现类来实现（implements）接口中的抽象方法，实现类中也可以定义自己的属性和方法。
2. 实现类可以同时使用多个接口，接口用逗号隔开public class A implement B,C,D{}
3. 实现类同时共享多个接口中的常量，且必须实现接口中的多个方法。
4. 若实现类中仍然有未实现的抽象方法，则它仍然为抽象类。
   5.接口是一种约定，一种能力：接口中规定了实现类必须实现的所有方法，且要求实现类必须有能力提供每个方法的具体实现。
5. 一个类可以只能继承一个父类，但是可以实现多个接口。
6. 一个接口可以同时继承多个接口，实现接口的多继承，但不能继承抽象类。