Java复习打卡day28

DP-工厂模式

public interface Bread {
    void getColor();
}
public abstract class AbstractFactory {
    public abstract Bread createBread(Class cls);
}
public class BreadFactory extends AbstractFactory{
    @Override
    public Bread createBread(Class cls) {
        Bread bread = null;
        try {
            bread = (Bread) Class.forName(cls.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("烤面包出现了问题~");
        }
        return bread;
    }
}
public class PoloBread implements Bread {
    @Override
    public void getColor() {
        System.out.println("烘烤的时间太短，烤出了北极熊面包-----------------------");
    }
}
public class BlackBread implements Bread {
    @Override
    public void getColor() {
        System.out.println("烘烤的时间太长，烤出了黑熊面包-----------------------");
    }
}
public class BrownBread implements Bread {
    @Override
    public void getColor() {
        System.out.println("烘烤的时间刚刚好，烤出了布朗熊面包-----------------------");
    }
}
public class Clients {
    public static void main(String[] args) {
        BreadFactory breadFactory = new BreadFactory();
        Bread poloBread = breadFactory.createBread(PoloBread.class);
        System.out.println("厨师第一次烤面包~");
        poloBread.getColor();
        Bread blackBread = breadFactory.createBread(BlackBread.class);
        System.out.println("厨师第二次烤面包~");
        blackBread.getColor();
        Bread brownBread = breadFactory.createBread(BrownBread.class);
        System.out.println("厨师第三次烤面包~");
        brownBread.getColor();
    }
}

抽象工厂模式

//抽象产品类
public abstract class AbstractBread {
    public abstract void contentments();
}
//抽象工厂类

public abstract class AbstractFacotry {
        public abstract AbstractBread createPineApplePoloBread();
        public abstract AbstractBread createMongoPoloBread();
        public abstract AbstractBread createPineAppleBlackBread();
        public abstract AbstractBread createMongoBlackBread();
        public abstract AbstractBread createPineAppleBrownBread();
        public abstract AbstractBread createMongoBrownBread();
}
//具体面包生产工厂
public class Factory extends AbstractFacotry{

    @Override
    public AbstractBread createPineApplePoloBread() {
        return new PineApplePoloBread();
    }

    @Override
    public AbstractBread createMongoPoloBread() {
        return new MongoPoloBread();

    }

    @Override
    public AbstractBread createPineAppleBlackBread() {
        return new PineAppleBlackBread();
    }

    @Override
    public AbstractBread createMongoBlackBread() {
        return new MongoBlackBread();
    }

    @Override
    public AbstractBread createPineAppleBrownBread() {
        return new PineAppleBrownBread();
    }

    @Override
    public AbstractBread createMongoBrownBread() {
        return new MongoBrownBread();
    }
}
//具体的六中面包类
       /**
         * 北极熊面包：
         *      菠萝味、芒果味
         *  黑熊面包：
         *      菠萝味、芒果味
         *  布朗熊面包：
         *      菠萝味、芒果味
         */
public class PineApplePoloBread extends AbstractBread {
    @Override
    public void contentments() {
        System.out.println("菠萝味的~");
        System.out.println("烤的时间短了，烤出了一个北极熊面包~");
    }
}
public class MongoPoloBread extends AbstractBread {
    @Override
    public void contentments() {
        System.out.println("芒果味的~");
        System.out.println("烤的时间短了，烤出了一个北极熊面包~");
    }
}
public class PineAppleBlackBread extends AbstractBread {
    @Override
    public void contentments() {
        System.out.println("菠萝味的~");
        System.out.println("烤的时间长了，烤出了一个黑熊面包~");
    }
}
public class MongoBlackBread extends AbstractBread {
    @Override
    public void contentments() {
        System.out.println("芒果味的~");
        System.out.println("烤的时间长了，烤出了一个黑熊面包~");
    }
}
public class PineAppleBrownBread extends AbstractBread {
    @Override
    public void contentments() {
        System.out.println("菠萝味的~");
        System.out.println("烤的时间刚刚好，烤出了一个布朗熊面包~");
    }
}
public class MongoBrownBread extends AbstractBread {
    @Override
    public void contentments() {
        System.out.println("芒果味的~");
        System.out.println("烤的时间刚刚好，烤出了一个布朗熊面包~");
    }
}
public class Clients {
    public static void main(String[] args) {
       Factory factory = new Factory();

        factory.createMongoBrownBread().contentments();
        factory.createPineAppleBrownBread().contentments();
        factory.createMongoBlackBread().contentments();
        factory.createPineAppleBlackBread().contentments();
        factory.createMongoPoloBread().contentments();
        factory.createPineApplePoloBread().contentments();
    }
}

DP-建造者模式

建造者模式
    指讲一个复杂对象的构造和它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。他将复杂的产品分解成一个一个
简单的表示，然后一步一步构建而成，他将变与不变相分离，即产品的组成部分是不变的，但是每一部分是可以灵活表示的。

    和工厂模式不同的是，工厂模式注重的是创建对象，而建造者模式注重的是获得对象的过程和细节，所以两者有不同但是可以互补，
随着大家在编程的领域更进一步的话，将会看到这两种模式相互协作的案例。

//先创建了一个车辆模型的类
import java.util.ArrayList;

public abstract class CarModel {
    private ArrayList<String> list = new ArrayList<>();

    public void setList(ArrayList<String> list) {
        this.list = list;
    }

    protected abstract void start();
    protected abstract void stop();
    protected abstract void engineBoom();
    protected abstract void alarm();

    public void run(){
        for (String li:list) {
            if("start".equals(li)){
                start();
            }else if("stop".equals(li)){
                stop();
            }else if("engineBoom".equals(li)){
                engineBoom();
            }else if("alarm".equals(li)){
                alarm();
            }
        }
    }
}
//奔驰车类
public class Benz extends CarModel {
    @Override
    protected void start() {
        System.out.println("奔驰车启动-----------");
    }

    @Override
    protected void stop() {
        System.out.println("奔驰车停止-----------");
    }

    @Override
    protected void engineBoom() {
        System.out.println("奔驰车引擎轰鸣-----------");
    }

    @Override
    protected void alarm() {
        System.out.println("奔驰车鸣笛-----------");
    }
}
//宝马车类
public class BMW extends CarModel {
    @Override
    protected void start() {
        System.out.println("宝马车启动-----------");
    }

    @Override
    protected void stop() {
        System.out.println("宝马车停止-----------");
    }

    @Override
    protected void engineBoom() {
        System.out.println("宝马车引擎轰鸣-----------");
    }

    @Override
    protected void alarm() {
        System.out.println("宝马车鸣笛-----------");
    }
}
//建造者抽象类
//一方面要得到，顺序，一方面要将顺序传到模型类里面，得到车辆的对象。
import java.util.ArrayList;

public abstract class Builder {
    abstract void getList(ArrayList list);

    abstract CarModel getCar();
}
//奔驰建造者类
import java.util.ArrayList;

public class BenzBuilder extends Builder {
    private Benz benz = new Benz();
    @Override
    void getList(ArrayList list) {
        this.benz.setList(list);
    }

    @Override
    CarModel getCar() {
        return benz;
    }
}
//宝马建造者类
import java.util.ArrayList;

public class BMWBuilder extends Builder {
    private BMW bmw= new BMW();
    @Override
    void getList(ArrayList list) {
        this.bmw.setList(list);
    }

    @Override
    CarModel getCar() {
        return bmw;
    }
}
 //导演类
    private ArrayList<String> list = new ArrayList<>();
    /**
     * 奔驰A：先启动，再引擎轰鸣，在停止
     * 宝马B：先启动，在按喇叭，在停止
     * 宝马C：先启动，再引擎轰鸣，在按喇叭，最后停止。
     */
    ArrayList<String> BenzA(){
        list.clear();
        list.add("start");
        list.add("engineBoom");
        list.add("stop");
        return list;
    }
    ArrayList<String> BMWB(){
        list.clear();
        list.add("start");
        list.add("alarm");
        list.add("stop");
        return list;
    }
    ArrayList<String> BMWC(){
        list.clear();
        list.add("start");
        list.add("engineBoom");
        list.add("alarm");
        list.add("stop");
        return list;
    }
}
//场景类
import java.util.ArrayList;

public class Clients {
     public static void main(String[] args) {
     Director director = new Director();
     //先生产一个奔驰A类型的车
         BenzBuilder benzBuilder = new BenzBuilder();
         benzBuilder.getList(director.BenzA());
         benzBuilder.getCar().run();
    //再生产一辆宝马B和宝马C车
         BMWBuilder bmwBuilder = new BMWBuilder();
         bmwBuilder.getList(director.BMWB());
         bmwBuilder.getCar().run();
         bmwBuilder.getList(director.BMWB());
         bmwBuilder.getCar().run();
         //这样编写代码逻辑清晰，是工厂量化生产时理想的代码实现模式。
    }
    public static void main2(String[] args) {
        //先生产一个宝马车
        ArrayList<String> list = new ArrayList<>();
        list.add("start");
        list.add("alarm");
        list.add("stop");
        BMWBuilder bmwBuilder = new BMWBuilder();
        bmwBuilder.getList(list);
        bmwBuilder.getCar().run();
        //再生产一个奔驰车
        BenzBuilder benzBuilder = new BenzBuilder();
        benzBuilder.getList(list);
        benzBuilder.getCar().run();
        //这个方法已经很好了，思路比第一个更清晰，但是还是要在客户端写上顺序，所以下面我们将会提供导演类。
    }
    public static void main1(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Benz benz = new Benz();
        list.add("start");
        list.add("alarm");
        list.add("stop");
        benz.setList(list);
        benz.run();
        //但是这种方法每次生产的时候都要将顺序写下来，不适合量产。
    }
}

DP-代理模式

代理模式

    疫情期间，小红没事干，尽然成迷到了打游戏的泥沼中无法自拔，每天登陆，上线，打怪，退线。虽然每天的生活很单一，但是
最后，成功的和队友将城墙推倒的时候，还是小有成就感的。
    现在，小红回到单位上了，虽然日常的编程任务很多，但是对小红这位变成大佬来说，都是小kiss，所以闲暇之余，小红就在想
能不能把那段难忘的美好经历实现为代码？
    下面就是小红的代码。


    代理模式的优缺点：
        优点：1.代理对象在目标对象和客户端之间气到了一个中介的作用，在一定程度上保护了目标对象。
        2.代理模式可以在目标对象的基础上增加功能。
        3.代理模式和目标模式之间是分离的，在一定程度上降低了代码的耦合度。
        缺点：1.在目标对象和客户端之间加上了一个代理对象增加了请求时间。
        2.在一定程度上增加了代码的复杂度。

//写一个通用的玩家类
import java.util.Date;

public interface IGamePlayer {
    //登陆
    public void login(String name, int password);
    //打怪
    public void killBoss();
    //升级
    public void upDate();
    //退出游戏，睡觉
    public void loadDown(Date downloadtime);
}
//具体的玩家类
import java.util.Date;

public class Player implements IGamePlayer {
    private String name;
    private int password;

    public Player() {
    }

    public Player(String name, int password) {
        this.name = name;
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPassword() {
        return password;
    }

    public void setPassword(int password) {
        this.password = password;
    }

    @Override
    public void login(String name, int password) {
        this.name = name;
        this.password = password;
        System.out.println("恭喜玩家" + this.name + "，登陆游戏成功~开始你的旅程吧~");
    }

    @Override
    public void killBoss() {
        System.out.println("恭喜你，在你教科书式的打法下，Boss终于倒下了~");
    }

    @Override
    public void upDate() {
        System.out.println("功夫不负有心人，在你这段时间的努力下，你成功的又升一级了~");
    }

    @Override
    public void loadDown(Date downlosdtime) {
        System.out.println("玩家：" + this.name + "在" + downlosdtime.toString() + "登出了游戏，期待你的下一次征战沙场~");
    }
}
import java.util.Date;

//代练类
public class ProxyPlayer extends Player{
    Date date = new Date();

    //被代理的玩家
    private Player player = null;

    public void playGame(Player player){
     super.login(player.getName(),player.getPassword());
     super.killBoss();
     super.upDate();
     super.loadDown(date);
    }
}
//场景类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.Date;

public class Clients {
    public static void main(String[] args) {
        Player player = new Player("宋仲基",193500222);
        InvocationHandler invocationHandler = new MyInvocationHandler(player);
        System.out.println("开始时间：2021-10-4 15:12");
        ClassLoader loader = player.getClass().getClassLoader();
        //动态产生一个代理者
        IGamePlayer proxy = (IGamePlayer) Proxy.newProxyInstance(loader, player.getClass().getInterfaces(), invocationHandler);
        //通过动态产生的代理实现打游戏
        proxy.login("松松",1935022333);
        proxy.killBoss();
        proxy.upDate();
        Date date = new Date();
        //其实，上面的代码可以包装成一个导演类，以避免在客户端代码的冗长。
        proxy.loadDown(date);
        //在整段代码中，并未出现任何的创建代理对象的部分，但最后游戏确实是代理完成升级的，
        //这就是动态代理的实现
    }

    public static void main2(String[] args) {
        Player player = new Player("宋仲基",1935023318);
        ProxyPlayer proxyPlayer = new ProxyPlayer();
        proxyPlayer.playGame(player);
        //看到了吧，你全程什么都没干，躺着也升级。
    }
    public static void main1(String[] args) {
        Player player = new Player();
        Date date = new Date();
        player.login("孟令朋",1935023318);
        player.killBoss();
        player.upDate();
        player.loadDown(date);
        //这样写固然是没有任何问题的，但是小红觉得每天自己打怪上分太累了，不符合自己一贯的懒人风格，
        //但是呢，上面管的太严了，不能开挂，所以，小红就想到了自己可以找代练。这也就有了代练的代码。
    }
}
//拓展

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 *代理模式的扩展：
 *      前面的代码总是一个代理对应一个目标对象，这不符合日常。所以这里给代码拓展了一下
 *      就是实现了InvocationHandler接口和MyInvocationHandler类，其中InvocationHandler接口
 *      是JDK自己提供的动态代理的接口
 */

public class MyInvocationHandler implements InvocationHandler {
    Object obj = null;

    public MyInvocationHandler(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(this.obj,args);
        //如果你担心自己的账号在自己不知情的情况下，被他人登陆，可以实现一个当他人在登陆你的脏好事，自动给我发信息的功能。
        // 代码实现如下
        if(method.getName().equalsIgnoreCase("login")){
            System.out.println("滴滴滴滴滴-----------------有人登陆你的账号了~~");
        }
        return result;
    }
}

DP-适配器模式

适配器模式
    将一个类的接口转换为用户希望的另外一个类的接口，使得原来因为借口不相容而不能一起工作的两个类，能够一起工作。

    通常适配器模式都需三个部分：
    1.Adaptee类：目前有的类
    2.Target类：目标想生成的类
    3.Adaptor类：适配器类，将Adaptee类转换为Target类的类

    暑假期间，小红想要好好的放松放松，便决定好了到欧洲去玩。到了欧洲后，住在宾馆里，却发现宾馆里面的插座都是
两孔圆插座，这跟中国的三孔扁插条不匹配，这样小红就充不了电了。不过好在服务员热情的送来了转换器，小红高兴地给自己
的手机充上了电，过了一个余款的欧洲暑假行。
    回到单位之后，小红象把这段经历有代码的方式实现出来并记录。
    这对小红来说只是小kiss，下面是小红的代码。

//Adaptee 源角色
public class TwoHoleSocket {
    public void getElectricity(){
        System.out.println("将电传送给华为手机~~");
    }
}
//Target类
public interface ThreeHoleSocket {
    public void getElectricity1();
}
//Adaptor类
public class Adaptor extends TwoHoleSocket implements ThreeHoleSocket {

    @Override
    public void getElectricity1() {
        super.getElectricity();
    }
}
//场景类
public class Clients {
    public static void main(String[] args) {
        ThreeHoleSocket charge = new Adaptor();
        charge.getElectricity1();
        //上面的代码，只用到了三孔插座和Adaptor，但是确实现了两孔插座的方法，这就是适配器模式。
    }
}

DP-装饰者模式

装饰模式
    在不改变对象结构的前提下，给对象动态的给该对象增加一些职责的模式。

    不知道大家在小学的时候有没有这样的困扰呢？
    每次考试成绩下来的时候，考的好还行好说，
    考得不好-------（可能就烧不了一顿’竹笋炒肉‘了）
    这不，小红，这次的考试成绩就不太理想。。。。

//成绩报告接口
public interface ScoreReport {
    //成绩展示
    public void show();
    //家长签字
    public void sign();
}
//我的成绩单
public class MyScoreReport implements ScoreReport{

    @Override
    public void show() {
        System.out.println("尊敬的家长，你好！\n\t\t小红xxx考试成绩如下：\n\t\t\t语文：58\n\t\t\t数学：68\n\t\t\t英语：71\n\t\t\t体育：90");
    }

    @Override
    public void sign() {
        System.out.print("\t\t家长签字：");
    }
}
//总体优化
public class BeautifyScoreReport {
    //这次的各科最高分
    public void highestScore(){
        System.out.println("这次班级的几个科目的最高分是：\t语文：70\t数学：85\t英语：90\t体育：90");
    }
    //这次小红在班级的排名（虽然班级的总人数只有32人，但是这是个秘密，只有你我知道）
    public void classRank(){
        System.out.println("这次我在班级的排名是32哦~~~");
    }
}
//最高分优化
public class HighestScoreReport extends BeautifyScoreReport{
    public void highestScoreReport(ScoreReport scoreReport) {
        super.highestScore();
        scoreReport.show();
        scoreReport.sign();
    }
}
//排名优化
public class ClassRankReport extends BeautifyScoreReport{
    public void classRankReport(ScoreReport scoreReport) {
        scoreReport.show();
        super.classRank();
        scoreReport.sign();
    }
}
//家长查看成绩单
public class Parent {
    public static void main(String[] args) {
        HighestScoreReport highestScoreReport = new HighestScoreReport();
        highestScoreReport.highestScoreReport(new MyScoreReport());
        //家长：还不错
        System.out.println("贾政");
        System.out.println("============================================");
        ClassRankReport classRankReport = new ClassRankReport();
        classRankReport.classRankReport(new MyScoreReport());
        System.out.println("贾政");
        //就是这样！小红要的就是这个效果，各种忧患互不干扰，可以有选择的灵活的调用修饰者
    }
    public static void main2(String[] args) {
        ScoreReport scoreReport = new MyScoreReport();
        BeautifyScoreReport beautifyScoreReport = new BeautifyScoreReport();
        beautifyScoreReport.highestScore();
        scoreReport.show();
        beautifyScoreReport.classRank();
        //家长：好像还不错哎~
        scoreReport.sign();
        System.out.println("贾政");
        //虽然已经修饰的很完美了，也过了家长的那关，但是小红不满意，他还想讲代码优化一下：
        //就是，上面的代码要在客户端上面创建两个类，冗长，请求实现的也很慢，所以小红想到
        //将show方法写到具体的修饰类里面
    }

    public static void main1(String[] args) {
        ScoreReport scoreReport = new MyScoreReport();
        scoreReport.show();
        scoreReport.sign();
        System.out.println("这样的成绩也想签名？");
        //这个结果可不是小红期待的，所以小红就想给试卷修饰一下。就这样有了接下来的修饰类。
    }
}

DP-亨元模式

//职工接口
public interface Employee {
    public void report();
}
//具体的职工类
public class Manager implements Employee{
    private String title = "部门经理";
    private String department;
    private String reportContentment;


    @Override
    public void report() {
        System.out.println(reportContentment);
    }

    public void getReportContentment(String reportContentment){
        this.reportContentment = reportContentment;
    }
    public Manager(String department){
        this.department = department;
    }

}
//享元工厂类
import java.util.HashMap;
import java.util.Map;

public class EmployeeFactory {
    private static final Map<String, Employee> EMPLOYEE_MAP = new HashMap<>();
    public static Employee getEmployee(String department){
        Manager manager = (Manager) EMPLOYEE_MAP.get(department);
        if(manager == null){
            manager = new Manager(department);
            System.out.println("创建部门经理" + department);
            String reportContentment = department + "经理的汇报内容是------------";
            manager.getReportContentment(reportContentment);
            System.out.println("\t创建报告：" + reportContentment);
            EMPLOYEE_MAP.put(department, manager);
        }
        return manager;
    }
}
//场景类
public class Clients {
    private static final String departments[] = {"RD", "FD", "SD", "PD"};
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {//开了十次会
            String department = departments[(int) (Math.random()*departments.length)];
            Manager manager = (Manager) EmployeeFactory.getEmployee(department);
            manager.report();

        }
    }
}
//这便是享元模式