JAVA学习22---接口

接口的理解

        接口就是规范，定义的是一组规则，本质是契约、标准、规范。Java不支持多重继承，有了接口，就可以得到多重继承的效果。

接口的使用

• 用interface关键字来定义接口
• Java中，接口和类是并列的两个结构
• 定义接口的成员：
  1.JDK7及以前，只能定义全局常量和抽象方法
          全局常量：public static final
          抽象方法：public abstract
  2.JDK8除了定义全局常量和抽象方法外，还可以定义静态方法、默认方法
          接口中定义的静态方法，只能通过接口来调用
          接口中定义的默认方法，可以通过实现类的对象来调用
• 接口中不能定义构造器，不可以被实例化
• 类通过implements方法实现接口
  如果实现类重写了接口中的所有抽象方法，则此实现类可以实例化
  如果实现类没有重写接口中的所有抽象方法，则此实现类为一个抽象类
• Java类可以实现多个接口
  格式：class AA extends BB implements CC,DD,EE
• 接口与接口之间可以实现多继承

public class demo {
    public static void main(String[] args) {
        System.out.println(fly.Max_speed);
    }
}
interface fly{
    //全局常量
    public static final int Max_speed = 7900;
    int Min_speed = 0;
    //抽象方法
    public abstract void fly();
    void down();
}
interface attack{
    void attack();
}
class plane implements fly{

    @Override
    public void fly() {
        System.out.println("fly");
    }

    @Override
    public void down() {
        System.out.println("down");
    }
}
abstract class kite implements fly{
}
class  Bullet extends Object implements fly,attack{
    @Override
    public void fly() {
        
    }

    @Override
    public void down() {

    }

    @Override
    public void attack() {

    }
}

接口的创建

1. 创建接口的非匿名实现类的非匿名对象

Flash f = new Flash();
com.transfer(f);

2. 创建接口的非匿名实现类的匿名对象

com.transfer(new Flash());

3. 创建接口的匿名实现类的非匿名对象

        USB usb = new USB() {
            @Override
            public void start() {
                System.out.println("start");
            }

            @Override
            public void stop() {
                System.out.println("stop");
            }
        };
        com.transfer(usb);

4. 创建接口的匿名实现类的匿名对象

        com.transfer(new USB() {
            @Override
            public void start() {
                System.out.println("start");
            }

            @Override
            public void stop() {
                System.out.println("stop");
            }
        });

以下为全部代码：

public class demo {
    public static void main(String[] args) {
        Computer com = new Computer();
        
        //1
        Flash f = new Flash();
        com.transfer(f);
        
        //2
        com.transfer(new Flash());
        
        //3
        USB usb = new USB() {
            @Override
            public void start() {
                System.out.println("start");
            }

            @Override
            public void stop() {
                System.out.println("stop");
            }
        };
        com.transfer(usb);

        //4
        com.transfer(new USB() {
            @Override
            public void start() {
                System.out.println("start");
            }

            @Override
            public void stop() {
                System.out.println("stop");
            }
        });
    }
}

interface USB{
    void start();
    void stop();
}
class Flash implements USB{
    public void start(){
        System.out.println("start");
    }
    public void stop(){
        System.out.println("stop");
    }
}
class Computer{
    public void transfer(USB usb){
        usb.start();
        System.out.println("loding");
        usb.stop();
    }
}

接口的应用

• 代理模式

        代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。

        应用场景：
1.安全代理：屏蔽对真实对象的直接访问
2.远程代理：通过代理类处理远程方法调用（RMI）
3.延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象

        分类：静态代理、动态代理

        代码实现：

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

interface NetWork{
    public void browse();
}
//被代理类
class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("browse");
    }
}
//代理类
class ProxyServer implements NetWork{
    private NetWork work;
    public ProxyServer(NetWork work){
        this.work=work;
    }
    public void check(){
        System.out.println("check");
    }
    @Override
    public void browse() {
        check();
        work.browse();
    }
}

• 工厂模式

        工厂模式实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

        分类：

• 简单工厂模式：用来生成同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
• 工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
• 抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力，但支持增加产品族）