Java基础二十三（interface）

接口的使用

• 1.接口的使用interface来定义
• 2.Java中，接口和类是并列的两个结构
• 3.如何定义接口：定义接口中的成员
    3.1 JDK7及以前：只能定义全局常量和抽象方法
      >全局常量：public static final。可以省略不写
      >抽象方法：public abstract

    3.2 JDK8：除了定义全局变量和抽象方法之外，还可以定义静态方法、默认方法

• 4.接口中不能定义构造器，意味着接口不可以实例化
• 5.Java开发中，接口都通过类去实现（implements）的方式来使用。
    如果实现类覆盖率接口中所有抽象法，则此实现类就可以实例化
    如果没有覆盖，则此实现类仍为一个抽象类
• 6.java类可以实现多个接口 -->弥补了java类单继承性的局限性
    格式：class AA extends BB implements CC,DD
• 7.接口与接口之间可以继承，而且可以多继承
• 8.接口具体使用，体现多态性
• 面试题：抽象类与接口有哪些异同
    相同点：不能实例化，都可以被继承
    不同点：抽象类有构造器。接口不能声明构造器。

public class InterfaceTest {

    public static void main(String[] args) {
        System.out.println(Flyable.MAX_SPEED);
        System.out.println(Flyable.MIN_SPEED);
//        Flyable.MIN_SPEED = 2;//不可修改

        Plane plane = new Plane();
        plane.fly();
    }
}

interface AttackAble{

    void attack();
}

interface Flyable{

    //全局常量
    public static final int MAX_SPEED = 7900;//第一宇宙速度
    int MIN_SPEED = 1;//省略 public static final

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

    //省略public abstract
    void stop();

    //不能定义构造器
//    public Flyable(){
//
//    }
}

class Plane implements Flyable{

    @Override
    public void fly() {
        System.out.println("通过引擎起飞");
    }

    @Override
    public void stop() {
        System.out.println("驾驶员减速停止");
    }
}

//没有覆盖所有方法，需加上abstract，不能实例化
abstract class Kite implements Flyable{

    @Override
    public void fly() {

    }

}

class Bullet extends Object implements Flyable, AttackAble, CC{

    @Override
    public void attack() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void stop() {

    }

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }
}

//****************************************************

interface AA{
    void method1();
}

interface BB{
    void method2();
}

interface CC extends AA,BB{

}

/*
*
* 接口的使用
* 1.接口使用上也满足多态性
* 2.接口，实际上定义了一种规范
*
* */
public class USBTest {
    public static void main(String[] args) {

        Computer computer = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
//        computer.transferData(usb);//接口不能实例化
        computer.transferData(flash);

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

        //3.创建接口的匿名实现类的非匿名对象
        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("mp3开始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3结束工作");
            }
        });
    }
}

class Computer{

    public void transferData(USB usb){//USB usb = new Flash();
        usb.start();
        System.out.println("具体传输数据细节");

        usb.stop();
    }
}

interface USB{
    //定义了长、宽、最大最小的传输速度

    void start();

    void stop();
}

class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盘开启工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }
}

class Printer implements USB{

    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }
}

代理模式

public class NetWorkTest {

    public static void main(String[] args) {
        Server server = new Server();
//        server.browse();
        ProxyServer proxyServer = new ProxyServer(server);

        proxyServer.browse();
    }
}

interface NetWork{

    public void browse();
}



//被代理类
class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("真实的服务器访问网路");
    }
}

//代理类
class ProxyServer implements NetWork{

    private NetWork work;
    public ProxyServer(NetWork work){
        this.work = work;
    }

    public void check(){
        System.out.println("联网前的检查工作");

    }
    @Override
    public void browse() {
        check();
        work.browse();
    }


}

代理模式举例

public class StaticProxyTest {
    public static void main(String[] args) {
//        Star s = new Proxy(new RealStar());
        Proxy s = new Proxy(new RealStar());
        s.confer();
        s.signContract();
        s.bookTicket();
        s.sing();
        s.collectMoney();
    }
}

interface Star{
    void confer();//面谈

    void signContract();//签合同

    void bookTicket();//订票

    void sing();//唱歌

    void collectMoney();//收钱
}

//被代理类
class RealStar implements Star{

    @Override
    public void confer() {

    }

    @Override
    public void signContract() {

    }

    @Override
    public void bookTicket() {

    }

    @Override
    public void sing() {
        System.out.println("明星：唱歌~~");
    }

    @Override
    public void collectMoney() {

    }
}

//代理类
class Proxy implements Star{

    private Star real;

    public Proxy(Star real){
        this.real = real;
    }

    @Override
    public void confer() {
        System.out.println("经纪人面谈");
    }

    @Override
    public void signContract() {
        System.out.println("经纪人签合同");
    }

    @Override
    public void bookTicket() {
        System.out.println("经纪人买票");
    }

    @Override
    public void sing() {
        real.sing();
    }

    @Override
    public void collectMoney() {
        System.out.println("经纪人收钱");
    }
}

举例

• 定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。
• 在ComparableCircle类中给出接口中方法compareTo的实现题，用来比较两个圆的半径大小.

public class ComparableCircle extends Circle implements CompareObject{

    public ComparableCircle(double radius){
        super(radius);
    }
    @Override
    public int compareTo(Object o) {
        if(this == o){
            return 0;
        }
        if(o instanceof ComparableCircle){
            ComparableCircle c = (ComparableCircle)o;
//            return (int)(this.getRadius() - c.getRadius());
            //方式一
//            if(this.getRadius() > c.getRadius()){
//                return 1;
//            }else if(this.getRadius() < c.getRadius()){
//                return -1;
//            }else{
//                return 0;
//            }

            //方式二
            // 当属性radius声明为Double类型时，可以调用包装类的方法
            return this.getRadius().compareTo(c.getRadius());
        }else{
            return 0;
        }
    }
}

public interface CompareObject {
    //若返回值是0，代表相等；若为正数，代表当前对象大；负数代表当前对象小
    public int compareTo(Object o);

}

/*
* 定义一个Circle类，声明radius属性，提供getter和setter方法
* */
public class Circle {

//    private double radius;
    //改成包装类，下同
    private Double radius;

    public Double getRadius() {
        return radius;
    }

    public void setRadius(Double radius) {
        this.radius = radius;
    }

    public Circle() {
    }

    public Circle(Double radius) {
        this.radius = radius;
    }
}

public class ComparableCircleTest {
    public static void main(String[] args) {
        ComparableCircle c1 = new ComparableCircle(3.4);
        ComparableCircle c2 = new ComparableCircle(3.6);

        int compareValue = c1.compareTo(c2);
        if (compareValue > 0){
            System.out.println("c1对象大");
        }else if(compareValue < 0){
            System.out.println("c2对象大");
        }else {
            System.out.println("一样大");
        }

        int compareValue1 = c1.compareTo(new String("AA"));
        System.out.println(compareValue1);//0

    }
}

JDK8：除了定义全局变量和抽象方法之外，还可以定义静态方法、默认方法

public class SubClassTest {

    public static void main(String[] args) {
        SubClass s = new SubClass();

        //1.接口中定义的静态方法只能通过接口调用
//        s.method1();
//        SubClass.method1();
        CompareA.method1();
        //2.通过实现类的对象，可以调用接口中的方法
        //如果实现类重写了接口中的默认方法，调用时仍然调用的是重写以后的方法
        s.method2();
        //3.如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法
        //那么子类在没有重写次方法的情况下，默认的是调用的是父类中的同名同参数的方法。-->类优先原则
        s.method3();

        s.myMethod();
    }
}

class SubClass extends SuperClass implements CompareA,CompareB{
    @Override
    public void method2() {
        System.out.println("SubClass：上海");
    }

    public void method3(){
        System.out.println("SubClass：深圳");
    }

    public void myMethod(){
        method3();//调用自己定义的重写方法
        super.method3();//调用父类中声明的
        //5.如估计在子类（或者实现类）的方法中调用父类、接口中被重写的方法
        CompareB.super.method3();
        CompareA.super.method3();
    }
}


//4.如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法
//那么在实现类没有重写次方法的情况下，报错。-->接口冲突
//这就需要在实现类中重写此方法
//class SubClass implements CompareA,CompareB{
//    @Override
//    public void method2() {
//        System.out.println("SubClass：上海");
//    }
//
//    public void method3(){
//        System.out.println("SubClass：深圳");
//    }
//}

public class SuperClass {
    public void method3(){
        System.out.println("SuperClass：上海");
    }
}

public interface CompareA {

    //静态方法
    public static void method1(){
        System.out.println("CompareA：北京");
    }

    //默认方法
    public default void method2(){
        System.out.println("CompareA：上海");
    }

    default void method3(){
        System.out.println("CompareA：上海");
    }
}

public interface CompareB {

    default void method3(){
        System.out.println("CompareB：上海");
    }
}