概念

  1. 接口是和类一个概念，主要定义方法名称，不实现方法体（写方法-不实现）
  2. 接口里面只有抽象方法，可以省掉

  3. 接口中定义所有的属性就是常量

    基本使用

    创建一个接口

    image.png

    1. public interface MyInterface{
    2.  //定义常量,public static final可以省略
    3.  //全：public static final int money=10；
    4.  int money=10;
    5.  //定义抽象方法，public abstract可以省略
    6.  //public abstract void say();
    7.  void say();
    8.  //封装方法
    9.  int getMoney();

    需要创建一个类，实现接口

    image.png

    通过类创建对象，调用接口方法

    1. public class Test001{
    2.  public static void main(String[] args){
    3.      MyObject myobject=new MyObject();
    4.      MyObject.say();
    5.  }
    6. }

    和抽象类的区别

    image.png

  4. 相同点

    1. 都不可以直接创建对象，除非使用匿名内部类(主要)image.png
    2. 可以作为引用类型（主要)
    3. 具备Object类中所定义的方法
    4. 可编译成字节码文件

  5. 不同点

    1. 接口定义的所有属性都是公开静态常量
    2. 接口定义的所有方法都是公开抽象方法
    3. 接口没有构造方法、动态代码块、静态代码块
    4. 一个类只能继承一个抽象类，但是可以实现多个接口（抽象类只能被继承一个，但是接口可以被实现多次）-（主要）image.png

      JDK1.8之后新增的功能

      在jdk1.8之后，接口新增了默认方法和静态方法;

      默认方法—修饰非抽象方法

  6. 语法格式（必须加default）：提示（接口与接口也是可以继承的）image.png

    1. 在创建接口的时候，可以使用default修饰默认的方法，是可以有实现体的
    2. 抽象方法必须被重写，但是默认方法可以不被重写，也可以重写默认方法（如果重写则不需要default）image.png
    3. 在实现的类中，可以使用接口名称.super.默认方法名调用接口中的默认方法image.png

  7. 接口代码image.png

    静态方法

  8. 直接使用静态static进行修饰，不可以被实现类（子类）重写image.png

  9. 直接使用接口名.方法名调用即可image.png

    接口的应用

  10. 接口可以使得不同的类之间的耦合性降低

    1. 如果不使用接口，不同类之间直接通信耦合性很紧密
    2. 在使用接口之后，接口之间的耦合性降低
  11. 在设计类的时候，如果出现了不同类之间的通信，首先应该想到接口进行接耦

接口 - 图12
电脑读取不同的设备的案例

  1. 如果不使用接口，那么电脑需要依赖很多其他不同的的设备，新增设备电脑类也需要更改
  2. 可以定义应该Usb接口，实现电脑类与其他类之间的接耦
    1. 设计一个Usb接口image.png
    2. 直接在电脑中使用接口image.pngimage.png
    3. 在其他需要接入电脑的设备中实现接口image.png
    4. 测试代码image.png
    5. 总结代码 ```java /就可以定义一个Usb接口，实现电脑类和其他设备类的解耦 设计一个Usb接口/

public interface Usb { void work(); }

  1. ```java
  2. //在其他需要接入电脑的设备中实现接口
  4. public class MyDisk implements Usb {
  6.    public void work(){
  7.        System.out.println("移动硬盘正在工作");
  8.    }
  9. }
  1. //直接在电脑中使用接口
  3. public class MyComputer2 {
  4.    Usb usb1;
  5.    Usb usb2;
  7.    public Usb getUsb1() {
  8.        return usb1;
  9.    }
  11.    public void setUsb1(Usb usb1) {
  12.        this.usb1 = usb1;
  13.    }
  15.    public Usb getUsb2() {
  16.        return usb2;
  17.    }
  19.    public void setUsb2(Usb usb2) {
  20.        this.usb2 = usb2;
  21.    }
  23.    public void work(){
  24.        if(usb1!=null){
  25.            usb1.work();
  26.        }
  27.        if(usb2!=null){
  28.            usb2.work();
  29.        }
  30.        System.out.println("这台电脑正常工作了");
  31.    }
  32. }
  1. //测试代码
  3.    public static void main(String[] args) {
  4.        MyComputer2 myComputer2 = new MyComputer2();
  5.        myComputer2.setUsb1(new MyDisk());
  6.        myComputer2.setUsb2(new MyFan());
  7.        myComputer2.work();
  8.    }

设计模式（重点）

概念

  1. -套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
  2. 可以简单理解为特定问题的固定解决方法。

  3. 在Gof的《设计模式》书中描述了23种设计模式。

    工厂设计模式（重点）

    概念

    是可以方便快速创建产品（对象）的一种模式image.png

    基本使用

  4. 创建一个工厂可以创建设备的接口 ```java /就可以定义一个Usb接口，实现电脑类和其他设备类的解耦 设计一个Usb接口/

public interface Usb { void work(); }

  2. 2. 所有的可以被这个工厂创建的类都需要实现这个接口
  3. ```java
  4. //在其他需要接入电脑的设备中实现接口
  6. public class MyDisk implements Usb {
  8.    public void work(){
  9.        System.out.println("移动硬盘正在工作");
  10.    }
  11. }

  1. 创建工厂类实现设备的创建

    1. public Usb createUsbDevice(int type){
    2.  switch(type){
    3.      case 1:
    4.          return new MyMouse();
    5.      case 2:
    6.          MyFan fan=new MyFan();
    7.          return fan;
    8.      case 3:
    9.          Usb usb=new MyDisk();
    10.          return usb;
    11.  }
    12. }

  2. 在使用的时候直接通过工厂类创建对象

image.png
image.png