Java——抽象类和接口

1.抽象类

抽象类：如果一个类里面有抽象方法，那么这个类一定是抽象类

抽象方法：将共性的行为（方法）抽取到父类之后，由于每一个子类执行的内容不一样，所以，在父类中不能确定具体的方法体，那么这个方法就是抽象方法

---

抽象类和抽象方法的定义格式：

1.抽象方法的定义格式：

public abstract 返回值类型 方法名（参数列表）;

2.抽象类的定义格式：

public abstract class 类名{}

---

抽象类和抽象方法的注意事项：

1.抽象类不能实例化

2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

3.抽象类中可以有构造方法

4.抽象类的子类要么重写抽象类中所有抽象方法，要么是抽象类

---

简单练习使用抽象类

abstract class Person{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public abstract void action();

}

class Student extends Person{

    public Student(String name, int age) {
        super(name, age);
    }
    @Override
    public void action() {
        System.out.println("学习");
    }
}

class Teacher extends Person{

    public Teacher(String name, int age) {
        super(name, age);
    }

    @Override
    public void action() {
        System.out.println("教书");
    }
}

class Parents extends Person{

    public Parents(String name, int age) {
        super(name, age);
    }

    @Override
    public void action() {
        System.out.println("赚钱");
    }
}

public class T1 {
    public static void main(String[] args) {
        Student student=new Student("小明",16);
        Teacher teacher=new Teacher("王老师",35);
        Parents parents=new Parents("王刚",46);
        show(student);
        show(teacher);
        show(parents);
    }
    public static void show(Person p){
        System.out.println(p.getName()+"   "+p.getAge());
        p.eat();
        p.action();
    }
}

2.接口

接口是一种规则，是对行为的抽象

当一群子类拥有同一个父类是，这群子类的一部分又拥有其他子类没有的特性时，这时候这个特性就用接口来定义

举例：老师和学生拥有在学校工作的特性，而家长没有，这时候在学校工作这个特性就用接口来定义

接口的定义和使用：

1.接口用关键字interface来定义

格式：

public interface 接口名{}

2.接口不能实例化

3.接口与类之间是实现关系，通过implements关键字表示

格式：

public clas 类名 implements 接口名{}

4.接口的子类（实现类）

要么重写接口中的所有抽象方法

要么是抽象类

注意1：接口和类的实现关系，可以是单实现，也可以是多实现

格式：

public class 类名 implements 接口名1，接口名2{}

注意2：实现类还可以在继承一个类的同时实现多个接口

格式：

public class 类名 extends 父类名 implements 接口名1，接口名2{}

---

接口中成员变量的特点

1.成员变量：只能是常量，默认修饰符：public static final

2.构造方法：没有

3.成员方法：JDK7以前：接口只能定义抽象方法

---

接口和类之间的关系

1.类和类之间的关系：继承关系，只能单继承，不能多继承，但可以多层继承

2.类和接口的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

3.接口和接口的关系：继承关系，可以单继承，也可以多继承

细节：如果实现类实现了“辈分”最小的接口，那么就需要重写所有的抽象方法

---

JDK8以后接口中新增的方法

一.允许在接口中定义默认方法，需要使用关键字default修饰

接口中默认方法的定义格式：

public default 返回值类型 方法名（参数列表）{}

注意事项：

1.默认方法不是抽象方法，所以不能被强制重写。但是如果被重写，重写的时候要去掉default关键字

2.public可以省略，default不能省略

3.如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对方法进行重写

---

二.允许在接口中定义静态方法，需要使用static修饰

接口中静态方法的定义格式：

public static 返回值 方法名（参数列表）{}

注意事项：

1.静态方法只能通过接口名调用，不能通过实现类名或者对象调用

2.public可以省略，static不能省略

---

JDK9新增的方法

接口中私有方法的定义格式：

格式一：给默认方法服务的

private 返回值类型 方法名（参数列表）{}

格式二：给静态方法服务的

private static 返回值类型 方法名（参数列表）{}

 

---

适配器设计模式

作用：解决接口与接口实现类之间的矛盾

接口：Inter

public interface Inter {
    abstract void method01();
    abstract void merhod02();
    abstract void method03();
    abstract void merhod04();
    abstract void method05();
    abstract void merhod06();
    abstract void method07();
    abstract void merhod08();
}

适配器：InterAdapter

public abstract class InterAdapter implements Inter{
    @Override
    public void method01() {

    }

    @Override
    public void merhod02() {

    }

    @Override
    public void method03() {

    }

    @Override
    public void merhod04() {

    }

    @Override
    public void method05() {

    }

    @Override
    public void merhod06() {

    }

    @Override
    public void method07() {

    }

    @Override
    public void merhod08() {

    }
}

类：Interemanple

public class Interemanple extends InterAdapter{
    @Override
    public void method05() {
        System.out.println("method05");
    }
}

测试类：T2

public class T2 {
    public static void main(String[] args) {
Interemanple interemanple=new Interemanple();
interemanple.method05();
    }
}

 解释：当我的接口中有8个抽象方法时，用一个类来接收接口，接口里面的所有抽象方法都需要重写，然而我只需要使用其中一个抽象方法，不想全部重写，我们就定义一个适配器类，用来接收接口，所有抽象方法空实现，然后再用一个类去继承适配器，重写我们需要的方法就行，因为这个适配器我们不想让他实例化对象，所以将适配器类定义为抽象类