接口:代理模式:工厂模式

package com.atguigu.java10;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

/*
 * 接口的使用
 * 1.接口使用interface来定义
 * 2.Java种，接口和类是并列的两个结构
 * 3.如何定义接口：定义接口种的成员
 *   JDK7及以前：只能定义全局常量和抽象方法
 *   全局常量：public static final的但是书写时可以省略不写
 *   抽象方法：public abstract的
 *   IDK8及以后：除了定义全局常量和抽象方法之外，还可以定义静态方法，默认方法（）
 * 4.接口中不能定义构造器！意味着接口不可以实例化
 * 5.java开发中，接口通过让类去实现（implements）的方式使用,
 *    如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
 *    如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类，需要在该类前面加abstract
 * 6.java类可以实现多个接口--》弥补了java单继承性的局限性
 *  格式：class AA extends BB implements CC,DD,EE
 * 7.接口与接口之间可以继承，而且可以多继承
 * 8.接口的具体使用，体现多态性
 * 9.接口。实际上可以看做是一种规范
 *
 * */
public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.MAX_SPEED);
        System.out.println(Flyable.MIN_SPEED);
    }

}

interface Flyable {
    //全局常量
    public static final int MAX_SPEED = 7900;//第一宇宙速度
     int MIN_SPEED = 1;//省略了public static final
    //抽象方法
    public abstract void fly();
    void stop();//省略了public abstract
}
class Plane implements Flyable{

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

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

    @Override
    public void fly() {

    }

    @Override
    public void stop() {

    }
}

package com.atguigu.java10Test;

/*
 * 接口的使用
 * 接口的使用也满足多态性
 * 接口实际上就是定义了一种规范
 * 开发中，体会面向接口编程
 * */
public class USBTest {
    public static void main(String[] args) {
        Computer com = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();//实现类的对象
        com.transferData(flash);
        //2.创建了接口的非匿名实现类的匿名对象
        com.transferData(new Printer());
        //3.创建了接口的匿名实现类的非匿名对象
        USB phone = new USB() {
            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }
        };
        com.transferData(phone);
        //3.创建了接口的匿名实现类的匿名对象
        com.transferData(new USB() {
            @Override
            public void start() {
                System.out.println("MP4开始工作");
            }

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

}

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("打印机结束工作");
    }
}

此处的Object是接口
ProxyObject是代理类（中介）
Objectimpl是被代理类

package com.atguigu.java10Test;

/*
 * 接口的应用：代理模式
 *
 * */
public class NetWorkTest {
    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("真实的服务器访问网络");
    }
}

//代理类
class ProxyServer implements NetWork {
    private NetWork netWork;

    public ProxyServer(NetWork netWork) {
        this.netWork = netWork;
    }

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

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

工厂设计模式

package com.atguigu.java10Test;
//不是工厂模式
public class FactoryTest {
    public static void main(String[] args) {
        Car a = new Audi();
        Car b = new BYD();
        a.run();
        b.run();
    }

}
interface Car{
    void run();

}
class Audi implements Car{

    @Override
    public void run() {
        System.out.println("奥迪再跑");
    }
}
class BYD implements Car{

    @Override
    public void run() {
        System.out.println("比亚迪再跑");
    }
}
//简单工厂类
//方式一
class CarFactory{
/*    public static Car getCar(String type){
        if ("奥迪".equals(type)){
            return new Audi();
        }else if ("比亚迪".equals(type)){
            return new BYD();
        }else {
            return null;
        }
    }*/
//方式二
    public static Car getAudi(){
        return new Audi();
    }
    public static Car getBYD(){
        return new BYD();
    }

}

class Factory1{
    public static void main(String[] args) {
        Car a = CarFactory.getAudi();
        Car b = CarFactory.getBYD();
    }

}

//工厂接口
interface Factory{
    Car getCar();//抽象方法返回Car类型的
}
//两个工厂类
class AudiFactory implements Factory{
    public Audi getCar(){
        return new Audi();
    }
}
class BYDFactory implements Factory{
    public BYD getCar(){
        return new BYD();
    }

}