interface的理解和使用(JDK7的,不推荐)

接口的理解和使用- Interface

1-接口的理解

/*
接口的使用
1- 接口的使用用--interface来定义
2- Java中。接口和类是并列的两个结构
3--如何定义接口：定义接口中的成员
JDK8：
      1- 全局常量：public static  final（可以省略）
      2- 抽象方法：public abstract  （可省略）
      3- 静态方法：
      4- 默认方法：

4- 接口中不能定义"构造器"，接口不可以"实例化"----所以，"接口"让"类"去实现接口（用--implement）
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以"实例化"
反之--如果实现类没有覆盖接口中所有抽象方法，则实现类还是抽象类

5- java类可以实现多个接口 ---> 弥补类java单继承性（单继承，多实现）
单继承，多实现--的格式：
               class Word extend AA implements BB，CC（单继承，多实现）

6- 接口的具体使用，体系多态性：
7- 接口，实际上可以看做是一种规范：

 */

2- 接口的基础理解使用(1)

public class interfaceTest {
    public static void main(String[] args) {
        Flane flane = new Flane();
        flane.fly();//调用，类实现接口后，重写的方法
    }
}

//1- 接口的测试
interface Flyable {
    //全局常量
    public static final int MAX_SPEED = 7900;
    int MIN_SPEED = 1;//----> 前面的"public static final"可以略，但是效果还在

    //抽象方法
    public abstract void fly();

    void stop(); //----- 前面的"public abstract"可以略

}

//2- 类实现接口的测试（implement）--重写完抽象类的方法，不是抽象类，可以实例化
class Flane implements Flyable {

    @Override//重写，抽象类的方法
    public void fly() {
        System.out.println("awkward-我可以飞");
    }

    @Override//重写，抽象类的方法
    public void stop() {
        System.out.println("我可以停");
    }
}

//3-  类实现接口的测试（implement）--没重写完抽象类的方法，是抽象类，不可以实例化
//我就只，重写了部分的方法，这个还是抽象类abstract
abstract class Kite implements Flyable {
    @Override
    public void fly() {
    }
}

3-接口的使用(3)（区分匿名对象、匿名实现类、非匿名对象、非匿名实现类）

/*
接口的使用:
1- 接口上，体现出了多态
2- 接口，实际上就是定义了一种规范
3- 开发中，体会面向接口编程
 */
public class Use_interface {
    public static void main(String[] args) {
        //解析实现类和对象
        /*
        Computer c = new Computer();
       1-  c是new出来的="对象"
       2-  new Computer();这个Computer="实现类"
       情况：
           1- 如果是匿名对象，非匿名实现类，就不写前面，直接new本身就可以了
           2- 如果是匿名对象，匿名实现类，就不写前面，直接new接口就可以了
           3- 如果是非匿名对象，匿名实现类，前都都写，但是后面new的是接口
           4-如果是非匿名对象，非匿名实现类，前后都写，前面new的一样
         */

        Computer computer = new Computer();
        //1- 创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();//Flash,实现类USB的特性
        computer.transferData(flash);

        //2-  创建了接口的非匿名实现类的匿名对象
        computer.transferData(new Printer());

        //3-创建了接口的匿名实现类的非匿名对象
        //匿名实现类，用接口USB来充当
        USB phone = new USB() {
            @Override
            public void start() {
                System.out.println("我是--匿名实现类的非匿名对象--开始工作");
            }

            @Override
            public void stop() {
                System.out.println("我是--匿名实现类的非匿名对象--停止");
            }
        };
        computer.transferData(phone);

        //4-创建了接口的匿名实现类的匿名对象
        //都匿名
        computer.transferData(new USB() {
            @Override
            public void start() {
                System.out.println("我是--匿名实现类的匿名对象--开始工作");
            }

            @Override
            public void stop() {
                System.out.println("我是--匿名实现类的匿名对象--停止工作");
            }
        });

    }
}

//电脑链接USB
class Computer {
    public void transferData(USB usb) {
        usb.start();
        System.out.println("开始工作----");
        usb.stop();
    }
}

//1-接口
interface USB {
    //定义：长，宽，最大，最小的传输速度

    void start();

    void stop();

}

//2-实现类1
class Flash implements USB {

    @Override
    public void start() {
        System.out.println("USB开始传输");
    }

    @Override
    public void stop() {
        System.out.println("USB停止传输");
    }
}

//3- 实现类2
class Printer implements USB {
    @Override
    public void start() {
        System.out.println("打印机开始传输");
    }

    @Override
    public void stop() {
        System.out.println("打印机停止传输");
    }
}

4- Interface的测试题目

/*
    对interface的测试题目
     */
interface A {
    int x = 0;
}

class B {
    int x = 1;
}

class C extends B implements A{
    public void pX(){
        //问题一，父类和接口--重名的情况
        //System.out.println(x);-->错误，因为（接口和父类，是并列的关系，所以不知道x到底是什么，报错）
        System.out.println(super.x);//这个是父类的，所以x=1；
        System.out.println(A.x);//接口中的是-抽象类，可以直接用类.出来（所以这个是x=0）

    }

    public static void main(String[] args) {
        new C().pX();
    }
}