JAVA核心技术I---JAVA基础知识（抽象类和接口）

一：抽象类

（一）定义

类：属性(0或多个)+方法(0或多个)
一个完整(健康)的类：所有的方法都有实现(方法体)
类可以没有方法，但是有方法就肯定要有实现，这才是一个完整的类
一个完整的类才可以被实例化，被new出来
如果一个类暂时有方法未实现，需要被定义为抽象类

（二）实现

抽象类关键字abstract声明
抽象类的组成
–(optional)成员变量，个数不限
–(optional)具体方法，方法有实现，个数不限
–(optional)抽象方法，加abstract关键字，个数不限

1.抽象类

public abstract class Animal {
    int number;
    public abstract void move();
    public abstract void run();
    
    public void say() {　　//这是区别于接口的地方，在抽象类中可以实现一些方法
        System.out.println("I am an animal");
    }
}

2.子类继承抽象类，必须全部实现抽象类中的抽象方法，不然还只能是个抽象类

public class LandAnimal extends Animal{
    public void move() {
        System.out.println("LandAnimal can move");
    }
    
    public void run() {
        System.out.println("LandAnimal can run");
    }
}

（三）总结

抽象类也是类。一个类继承于抽象类，就不能继承于其他的(抽象)类.
子类可以继承于抽象类，但是一定要实现父类们所有abstract的方法。如果不能完全实现，那么子类也必须被定义为抽象类。
只有实现父类(们)的所有抽象方法，才变成完整类。

二：接口

同抽象类相似，不同的是所有的方法都不能实现

（一）定义

如果类的所有方法都没有实现，那么这个类就算是接口interface。
接口不算类，或者说是“特殊”的类。
类只可以继承(extends)一个类，但是可以实现(implements)多个接口，继承和实现可以同时

接口可以继承(多个)接口，没有实现的方法将会叠加
类实现接口，就必须实现所有未实现的方法。如果没有全部实现，那么只能成为一个抽象类。
接口里可以定义变量，但是一般是常量

（二）接口实现

1.接口

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

public interface Food {
    public void makefood();
}

2.抽象类：继承于接口，却未全部实现方法

public abstract class LandAnimal implements Animal, Food{    　　//继承多个接口
    public void move() {
        System.out.println("LandAnimal can move");
    }
    
    public void makefood() {
        System.out.println("LandAnimal can be made for food");
    }
}

3.子类：实现所以的方法

public class RabbitAnimal extends LandAnimal{
    public void run() {
        System.out.println("RabbitAnimal can run");
    }
}

4.调用

public class AnimalTest {
    public static void main(String[] args) {
        LandAnimal la=new RabbitAnimal();
        la.move();
        la.run();
        la.makefood();
    }
}

LandAnimal can move
RabbitAnimal can run
LandAnimal can be made for food

三：抽象类和接口

抽象类和接口相同点：两者都不能被实例化，不能new操作
抽象类和接口不同点
–抽象类abstract, 接口interfac
–抽象类可以有部分方法实现，接口所有方法不能有实现
–一个类只能继承(extends)一个(抽象)类，实现(implements)多个接口
–接口可以继承(extends)多个接口
–抽象类有构造函数，接口没有构造函数
–抽象类可以有main，也能运行，接口没有main函数
–抽象类方法可以有private/protected, 接口方法都是public

1.接口

public interface Food {
    public void makefood();
}

interface Food

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

interface Anima

2.抽象类

public abstract class RiverAnimal implements Animal{
    public void move() {
        System.out.println("LandAnimal can move");
    }
}

abstract class RiverAnimal implements Animal

3.子类

public class fish extends RiverAnimal implements Food{
    public void makefood() {
        System.out.println("RiverAnimal can be made for food");
    }
    
    public void run() {
        System.out.println("fishAnimal can run");
    }
}

4.实现

public class AnimalTest {
    public static void main(String[] args) {
        fish ra=new fish();
        ra.move();
        ra.run();
        ra.makefood();
    }
}

RiverAnimal can move
fishAnimal can run
RiverAnimal can be made for food