面向对象8（接口）

接口：

概念：使用 interface 修饰的代码块。
语法:
访问修饰符 interface 接口名{
接口成员
}

访问修饰符：暂时使用public
interface：关键字，含义是接口。
接口名：标识符。
接口成员：静态常量，抽象方法。

interface inter{
    public static final int x = 100;

    public abstract void show();
}
class Method implements inter{

    @Override
    public void show() {
        System.out.println( x + "输出接口方法");
    }
}
public class Demo {

    public static void main(String[] args) {
        Method method = new Method();
        method.show();//100输出接口方法
    }
}

结论：
接口的静态常量可以不写 public static final
接口的抽象方法可以不写public abstract
建议写上，方便后面方法的重写

语法：
访问修饰符 class 类名 [extends 父类] implements 接口名1,接口名2,接口名3,…
{
成员
}
类名：实现了接口的类名，该类又称之为实现类。
implements：关键字，含义是实现，在implements前可以让类继承其他类。在implements后可以实现多个接口，每个接口以”,”隔开，简称多实现。【为了打破类的单继承】
成员：必须实现接口中所有抽象方法，除非该实现类是抽象类。

作用：

• 扩展类的功能。
• 约束类

扩展类的功能。

interface Copy{//复印功能接口
    public abstract void copy();
}

class Printer implements Copy{//打印机

    private String page;//纸张尺寸
    private String ink;//打印墨水

    public String getPage() {
        return page;
    }

    public void setPage(String page) {
        this.page = page;
    }

    public String getInk() {
        return ink;
    }

    public void setInk(String ink) {
        this.ink = ink;
    }

    public void print(){
        System.out.println("使用"+ink+"墨水将文字打印到"+page+"纸张上");
    }

    @Override
    public void copy() {
        System.out.println("复印资料......");
    }
}

public class Demo {

    public static void main(String[] args) {
        
        /* 需求：模拟打印机打印，复印
         */
        Printer printer1 = new Printer();
        Printer printer2 = new Printer();

        printer1.setPage("A4");
        printer1.setInk("黑白");
        printer2.setPage("报纸");
        printer2.setInk("污水");
        
        printer1.print();//使用黑白墨水将文字打印到A4纸张上
        printer2.print();//使用污水墨水将文字打印到报纸纸张上
        
        printer1.copy();//复印资料......
    }
}

结论：

• 接口可以扩展类的功能，上面打印机连上复印的接口，具有了复印的功能方法。

• 但是没有约束类，导致污水，报纸也能打印，现实中是不可以的，属于误操作。 所以我们需要对类进行约束

约束类：

interface Ink{//墨水
    public String getColor();
}

interface Page{//纸张尺寸
    public String getSize();
}

class ColorInk implements Ink{

    @Override
    public String getColor() {
        return "彩色";
    }
}

class GaryInk implements Ink{

    @Override
    public String getColor() {
        return "黑白";
    }
}

class A4Page implements Page{

    @Override
    public String getSize() {
        return "A4";
    }
}

class B5Page implements Page{

    @Override
    public String getSize() {
        return "B5";
    }
}

interface Copy{
    public abstract void copy();
}

class Printer implements Copy{//打印机

    private Page page;
    private Ink ink;

    public Page getPage() {//返回的是接口类型
        return page;
    }

    public void setPage(Page page) {//参数是接口，类似多态的向上转型，父类引用子类对象
        this.page = page;
    }

    public Ink getInk() {
        return ink;
    }

    public void setInk(Ink ink) {
        this.ink = ink;
    }

    public void print(){
        System.out.println("使用"+ink.getColor()+"墨水将文字打印到"+page.getSize()+"纸张上");
    }

    @Override
    public void copy() {
        System.out.println("复印资料......");
    }
}

public class Demo {

    public static void main(String[] args) {
        //类的约束
        /* 需求：模拟打印机打印
         */
        Printer printer1 = new Printer();
        Printer printer2 = new Printer();

        Page page = new A4Page();//多态第二种形式：接口类型引用指向实现类对象。
        Ink ink = new ColorInk();
        //约束。。。。。
        //printer1.setPage("A4");报错
        //printer1.setInk("黑白");报错
        //printer2.setPage("报纸");报错
        //printer2.setInk("污水");报错
        printer1.setPage(page);
        printer1.setInk(ink);

        printer1.print();//使用彩色墨水将文字打印到A4纸张上
        printer1.copy();//复印资料......
    }
}

结论：

• 把墨水类型单独做一个接口，然后各款墨水类连接墨水接口，类似子类继承父类，暂时称之为接口的子类。 同理，把纸张尺寸也是如此。

• class Printer implements Copy{//打印机

  private Page page;
  private Ink ink;
  public Page getPage() {//返回的是接口类型
  return page;
  }

  public void setPage(Page page) {//参数是接口，类似多态的向上转型，父类引用子类对象
  this.page = page;
  }
  …
  }
  把接口作为打印机类的属性，然后用setter / getter方法访问。返回的类型也是引用类型

• public void print(){
  System.out.println(“使用”+ink.getColor()+“墨水将文字打印到”+page.getSize()+“纸张上”);
  }
  因为接口的都是抽象方法，调用时类名.方法名

接口与抽象类区别

1. 定义不同：接口使用interface修饰，抽象类使用abstract class修饰
2. 成员不同：接口只能有静态常量和抽象方法，抽象类可以有抽象方法也可以有普通成员
3. 构造方法不同：接口没有构造方法，抽象类有构造方法。
4. 使用方式不同：接口多继承和多现实，抽象类单继承
5. 继承关系上不同：接口被接口继承，抽象类被类继承。