1、抽象类

1.1 什么是抽象类

Java中抽象类是指被abstract修饰的类，何为抽象，抽象指的是从众多的事物中抽取出共同的、本质性的特征,而舍弃其非本质的特征的过程，所以抽象类主要用来定义类的一些共同的属性和行为。

1.2 抽象类特性

• 不能被实例化，不能直接使用new关键字来创建对象，有构造器但不能被调用；
• 可以包含抽象和非抽象的方法，抽象方法只是方法的定义，没有方法体，必须在子类中被重写；
• 抽象类可以包含静态方法和静态变量。这些静态成员属于抽象类本身，而不是其任何实例，并且只能通过抽象类类名和其子类类名调用，不能通过对象调用；
• 子类必须实现抽象类中所有的抽象方法。

1.3 作用

由于抽像类的特性，抽象类是作为基类被子类继承使用的，主要用于定义类共有的成员变量和成员方法，实现代码重用的效果。

1.4 正确使用抽象类

1.4.1 抽象使用考量因素

• 抽象类主要是用来被继承的；
• 抽象类的构造器不能通过new调用；
• 抽象类内部可以有抽象方法。

1.4.2 使用抽象类

通过abstract关键字修饰一个类，那么这个类就为抽象类。

1）继承的使用

抽象类主要用来被继承，可以抽取类的共同属性和行为，使用上同普通类的继承，这里不再过多赘述。

2）构造器的使用

抽象类的构造器不能通过new调用，但是可以在子类的构造器中，通过super进行调用，所以抽象类构造器一般用于对抽象类成员变量进行初始化。

示例代码如下:

public abstract class Animal {
    /**
     * 动物名称
     */
    private String name;
    /**
     * 动物年龄
     */
    private int age;

    /**
     * 抽象类构造器初始化成员
     * @param name
     * @param age
     */
    public Animal(String name,int age){
       this.name = name;
       this.age = age;
    }

    /**
     * 打印动物信息
     */
    protected final void printAnimalInfo(){
        System.out.println("名字："+this.name);
        System.out.println("年纪："+this.age);
    }
}
class Cat extends Animal{
    public Cat(String name, int age){
        //子类通过super调用父类构造器
        super(name,age);
    }
}
class Dog extends Animal{
    public Dog(String name, int age){
        //子类通过super调用父类构造器
        super(name,age);
    }
}
class Runner{
    public static void main(String[] args) {
        Animal cat = new Cat("小喵",2);
        Animal dog = new Dog("小汪",3);
        cat.printAnimalInfo();
        System.out.println("=====================");
        dog.printAnimalInfo();
    }
}

3）抽象方法和普通方法的使用

抽象方法和普通方法区别在于，抽象方法没有方法体，只有方法的定义，所以在方法的使用上应考虑如下情况；

• 当方法有具体实现时，应定义普通方法，如果方法逻辑是通用的，在子类不需要重写，可以用final来修饰方法；
• 当子类都有某个行为，但是行为逻辑却各不相同，那么基类应该把那个方法定义为抽象方法

示例代码如下:

/**
 * 打印机抽象类
 */
@Data
public abstract class Printer {
    /**
     * 型号
     */
    private String specs;
    /**
     * 初始化
     * @param specs
     */
    public Printer(String specs) {
        this.specs = specs;
    }
    /**
     * 打印文档,不同打印机打出文档不一样，实现细节不同，所以需要子类实现具体细节
     */
    protected abstract void printDocument();
    /**
     * 显示打印机信息，通用的，子类不需要重写，所以用final修饰
     */
    protected final void showInfo(){
        System.out.println("打印机型号："+this.specs);
    }
}

/**
 * 黑白打印机
 */
class WhiteBlackPrinter extends Printer{

    public WhiteBlackPrinter(String specs) {
        super(specs);
    }

    @Override
    protected void printDocument() {
        System.out.println("黑白打印机："+super.getSpecs()+",打出黑白文档");
    }
}
/**
 * 彩色打印机
 */
class ColorfulPrinter extends Printer{
    public ColorfulPrinter(String specs) {
        super(specs);
    }
    @Override
    protected void printDocument() {
        System.out.println("彩色打印机："+super.getSpecs()+",打出彩色文档");
    }
}

class Main{
    public static void main(String[] args) {
        Printer wb = new WhiteBlackPrinter("wb-678k23");
        wb.printDocument();
        System.out.println("====================");
        Printer color = new ColorfulPrinter("color-378k43");
        color.printDocument();
    }
}

1.4.3 抽象类中的静态方法

抽象类的静态方法，要有具体实现。

2、接口

2.1 接口的概念

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等。

• 电脑的USB口上，可以插：U盘、鼠标、键盘...所有符合USB协议的设备
• 电源插座插孔上，可以插：电脑、电视机、电饭煲...所有符合规范的设备

通过上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

2.2 接口特性

• 接口的命名规则与类相同。如果修饰符是public，则该接口在整个项目中可见；如果省略修饰符，则该接口只在当前包可见。
• 接口中可以定义常量，不能定义变量。接口中的属性都会自动用public static final 修饰，即接口中的属性都是全局静态常量。
• 接口中方法自动用public abstract修饰，接口中所有方法都是抽象方法。
• 接口不能实例化，接口中不能有构造方法。
• 接口直接可以通过extends实现继承关系，一个接口可以继承多个接口，但是接口不能继承类。
• 接口的实现类必须实现接口的全部方法，否则必须定义为抽象类。

2.3 接口的作用

接口体现了约定和实现相分离的原则

• 降低代码间的耦合性
• 易于程序的扩展，提高了程序的可扩性性
• 提高了程序的可维护性

2.4 接口使用

接口内部可以定义成员和成员方法，成员变量必须被public和static修饰，成员方法默认为public 和abstract，需要在实现类中，作具体的实现。

示例代码图下:

public interface A {
    /**
     * 属性必须被static修饰,必须被初始化
     */
    public static String name = "ggy";

    public void amethod();
}
interface B{
    public void bmethod();
}

/**
 * 类可以实现多个接口
 */
class C implements A,B{

    @Override
    public void amethod() {
        System.out.println("A");
    }
    @Override
    public void bmethod() {
        System.out.println("B");
    }
}

class Main{
    public static void main(String[] args) {
        A a = new C();
        B b = new C();
        //方法的调用
        a.amethod();
        b.bmethod();
        //这里通过实现类的对象、实现类名称、接口名称都能访问接口A的属性name
        System.out.println(A.name);
        System.out.println(a.name);
        System.out.println(C.name);
    }
}