Java抽象类和接口

抽象类
当父类中的某一方法没有实际工作，可以把它设置成一个抽象方法，包含抽象方法的类称为抽象类

abstract class Shape {
    abstract public void draw();
}

• 在draw方法前加上abstract关键字，代表这是个抽象方法，并且抽象方法没有方法体，不能执行具体代码。
• 包含abstract方法的类必须也加上abstract关键字表示这是个抽象类
• 抽象类不能直接实例化
• 抽象方法不能是private
• 抽象类中可以包括其他的非抽象方法和属性，也可以被子类继承重写，或直接调用

抽象类存在得最大意义就是为了被继承
抽象类本身不能被实例化，必须创建该类的子类，并重写相关的抽象方法，然后实例化子类的对象，使用重写的方法。

使用抽象类的好处在于，当实际工作不需要父类完成时，如果不小心用成父类了，编译器就会在父类实例化的时候提示错误，便于我们发现错误。

接口
接口可以看做是抽象类升级版，抽象类中可以包括非抽象的方法和字段，但是接口中包括的都是抽象方法，字段只能是静态常量。
使用接口时，建议在类名前加大写的 i 。
代码实例：

// 使用interface定义IShape 接口
interface IShape {
    void draw();
}
//继承接口的子类
class Cycle implements IShape {
    @Override
    public void draw() {
        System.out.println("○");
    }
}
//另一个子类
class Rect implements IShape {
    @Override
    public void draw() {
        System.out.println("□");
    }
}
//另一子类
class Flower implements IShape{
    @Override
    public void draw() {
        System.out.println("❀");
    }
}
//
public class Poly {
    //draw方法
    public static void draw(IShape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        IShape shape = new Flower();
        draw(shape);
    }
}

注意事项：

• 使用interface定义一个接口
• 接口中的方法一定是抽象方法，因此可以省略abstract关键字
• 接口的方法一定是public，所以可以省略public关键字
• Flower使用implements继承接口，此时表达的含义不是扩展，而是实现
• 在调用时，也可以创建一个接口的引用，对应一个子类的实例
• 接口和抽象类一样不能单独被实例化

接口内的字段都必须是静态常量因此：

interface IShape {
	public static final int num = 1;
	void draw();
}

因此接口内字段的public、static、final都可以被省略
即

int num = 1;

提示：
创建接口的时候一般以大写字母 I 开头
接口的命名一般使用“形容词”词性的单词
接口中的方法和字段不要加修饰符，保持代码的简洁
接口内的方法在子类中重写时，同样要注意重写的方法必须被public所修饰

多个接口
Java只能继承一个父类，但是却能实现多个接口，所以也能达到类似继承多个父类的效果
首先定义 People
（下面的举例不好，下次有空换个更合适的）

class Person {
    protected String name;
    public Person(String name) {
        this.name = name;
    }
}

写一组接口，表示心情状态

interface IHappy {
    void happy();
}

interface ISad {
    void sad();
}

interface ILonely{
    void lonely();
}

写几个子类（按 ctrl + i 可以快速重写接口内的方法）

//小朋友
class Kid extends Person implements IHappy{
    public Kid (String name) {
        super(name);
    }

    @Override
    public void happy() {
        System.out.println(this.name+"现在非常开心");
    }

}
//成年人
class Adult extends Person implements ISad {

    public Adult (String name) {
        super(name);
    }

    @Override
    public void sad() {
        System.out.println(this.name+"现在有一点难过");
    }
}
//青年
class Teenager extends Person implements IHappy,ISad {
    public Teenager (String name) {
        super(name);
    }
    @Override
    public void happy() {
        System.out.println(this.name+"有时开心"+" ");
    }
    @Override
    public void sad () {
        System.out.println(this.name+"有时难过"+" ");
    }
}
//外星人
class Alien extends Person implements IHappy,ISad,ILonely {
    public Alien (String name) {
        super(name);
    }
    @Override
    public void happy() {
        System.out.println(this.name+"有时开心"+" ");
    }
    @Override
    public void sad () {
        System.out.println(this.name+"有时难过"+" ");
    }
    @Override
    public void lonely() {
        System.out.println(this.name+"有时孤独"+" ");
    }
}

现在来调用一些类

public class Mili {
	//在happy 方法内部，不用关心是谁(类型),只要是会happy的就行
    public static void happy(IHappy person) {
        person.happy();
    }
    public static void main(String[] args) {
        Alien alien = new Alien("保罗");
        happy(alien);
        Kid boy = new Kid("小李");
        happy(boy);
    }
}

输出：
保罗有时开心
小李现在非常开心

这段代码是Java面向对象编程中最常见的用法：一个类继承一个父类，同时实现了多种接口
继承表达的含义是 该类是一个什么 ，而接口表达的是 类拥有什么特性 。
（剩下的下次总结）