Java中抽象类和抽象方法，接口，适配器设计模式，内部类

抽象类和抽象方法

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

抽象类：如果一个类中存在抽象方法，那么该类必须声明为抽象类

抽象类的定义格式

抽象类的定义格式：

public abstract class 类名()；

抽象方法的定义格式

抽象方法的定义格式：

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

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

1.抽象类不能实例化

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

3.可以有构造方法

4.抽象类的子类：

要么重写抽象类的方法

要么是抽象类

子类继承抽象类之后，如何重写抽象方法

父类

package com.cjj.a02abstractDemo02;
​
public abstract class Animal {
    private int age;
    private String name;
​
    public Animal() {
    }
​
    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
    public abstract void eat();
    public void drink(){
        System.out.println("喝水");
    }
}

//子类
package com.cjj.a02abstractDemo02;
​
public class Frog extends Animal{
    public Frog() {
    }
​
    public Frog(int age, String name) {
        super(age, name);
    }
​
    @Override
    public void eat() {
        System.out.println("吃虫子");
    }
​

抽象类和抽象方法的意义

抽象类的作用

抽取共性时，无法确定方法体，就把方法定义为抽象的

强制让子类按照某种格式重写

抽象方法所在的类，必须是抽象类

继承抽象类有哪些要注意

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

要么是抽象类

接口

接口的定义和使用

接口用关键字interface来定义

public interface 接口名（）{}

接口不能实例化

接口和类之间是实现关系，提供implements关键字表示

public class  类名 implements 接口名{}

接口的子类（实现类）

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

要么是抽象类

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

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

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

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

接口中成员的特点

成员变量：只能是常量

默认修饰符：public static final

构造方法：没有

成员方法：

JDK7以前：接口中只能定义抽象方法

JDK8的新特性：接口中可以定义有方法体的方法

1.允许在接口中定义默认方法，需要使用关键字default修饰：作用解决接口升级问题

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

public default 返回值类型 方法名(参数列表){}
//例如
public default void show(){}

接口中默认方法的注意事项：1.默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字

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

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

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

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

//格式
public static 返回值类型 方法名(参数列表){}
//范例
public static void show(){}

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

2.public可以省略，static不能

JDK9的新特性：接口中可以定义私有方法

//格式1
private 返回值类型 方法名(参数列表){}
//范例1
private void show(){}

//格式2
private static 返回值类型 方法名(参数列表){}
//范例2
private static void method(){}

package com.cjj.a3interfaceDemo03;
​
public interface InterA {
    public default void show1(){
        System.out.println("show1方法");
        show3();//可以调用
        
    }
    public static void show2(){
        System.out.println("show2方法");
        show4();//可以调用
    }
    private  void show3(){
        System.out.println("show3方法");//普通的私有方法，给默认方法服务的
    }
    private static void show4(){
        System.out.println("show4方法");//静态的私有方法，给静态方法服务的
    }
}

接口和类之间的关系

类和类的关系：继承关系，只能单继承，不能多继承，但是可以多层继承

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

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

总结

1.接口代表规则，是行为的抽象。想要让哪一个类拥有一个行为，就让这个类实现对象的接口就可以了

2.当一个方法的参数是接口时，可以传递接口所有实现类的对象，这种方法称之为接口多态

适配器设计模式

1.设计模式是一套被反复使用，多数人知晓的，经过分类编目的，代码设计经验的总结。

实用设计模式是为了可重复代码，让代码更容易被他人理解，保证代码的可靠性，程序的重要性

简单理解：设计模式就是各种套路

2.适配器设计模式：解决接口与接口实现类之间的矛盾问题

3.总结：当一个接口中抽象方法过多，但是我只要使用一部分的时候，就可以适配器设计模式

书写步骤：

编写中间类XXXAdapter，实现对应的接口，对接口中的抽象方法进行实现，让真正的实现类继 承中间类，并重写需要的方法，为了避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰

内部类

类的五大成员：属性，方法，构造方法，代码块，内部类

在一个类的里面，在定义一个类

内部类表示的事物是外部类的一部分

内部类单独出现没有意义

内部类的访问特点：

1.内部类可以直接访问外部类成员，包括私有

2.外部类要访问内部类的成员必须要创建对象

成员内部类

写在成员位置的，属于外部类成员

成员内部类的代码如何书写

public class Car{//外部类
    String carName;
    int carAge;
    string carColor;
    class Engine{//成员内部类
        String engineName;
        int engineAge;
    }
}

如何创建成员内部类的对象

方法1：在外部类中编写方法，对外提供内部类的对象

方法2：直接创建格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；

Outer.Inner oi = new Outer().new Inner();

成员内部类如何获取外部类的成员变量

public class Outer{
    private int a = 10;
    class Inner{
        private int a = 20;
        public void show(){
            int a = 30;
            sout(Outer.this.a);//10
            sout(this.a);//20
            sout(a);//30
        }
    }
}

public class Test{
    public static void main(String[] args){
        //创建内部类对象，并且调用show方法
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

静态内部类

静态内部类是一种特殊的成员内部类

静态内部类只能访问外部类中的静态变量和静态方法，如果学习访问非静态的需要创建对象

public class Car{//外部类
    String carName;
    int carAge;
    int carColor;
    static class Engine{//静态内部类
        String engineName;
        int engineAge;
    }
}

创建静态内部类对象的格式：外部类名.内部类名 对象名 = new 外部类名.内部类名（）；

调用非静态方法的格式：先创建对象，用对象调用

调用静态方法的格式：外部类名.内部类名.方法名();

局部内部类

1.将内部类定义在方法里面的就叫做局部内部类，类似于方法里面的局部变量。

2.外界无法直接使用，需要在方法内创建对象并使用。

3.该类可以直接访问外部类的成员，也可以访问方法内的局部变量

匿名内部类

匿名内部类本质上就是隐藏了名字的内部类

//格式
new 类名或接口名（）{
    重写方法；
}；

什么是匿名内部类：隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置

格式的细节

1.包含了继续或实现，方法重写，创建对象

2.整体就是一个类的子类对象或者接口的实现类对象

3.使用场景：当方法的参数是接口或者类时

以接口为例，可以传递这个接口的实现类对象，

如果实现类只要使用一次，就可以用匿名内部类简化代码