夜光带你走进 Java 成神之路（十一）擅长的领域

夜光序言：

 

 

即使摔得满身是伤，笑容依旧可以灿烂如花。

 

 

 

 

 

 

 

 

 

正文：

                           以道御术 / 以术识道

package 工厂设计模式.抽象工厂模式;

public class BJCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京的奶酪披萨");
        System.out.println("北京的奶酪披萨 准备原材料~");
    }
}

package 工厂设计模式.抽象工厂模式;

public class BJPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("北京的胡椒披萨");
        System.out.println("北京的胡椒披萨 准备原材料~");
    }
}

package 工厂设计模式.抽象工厂模式;

public class LDCheesePizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦的奶酪披萨");
        System.out.println("伦敦的奶酪披萨 准备原材料~");
    }
}

package 工厂设计模式.抽象工厂模式;

public class LDPepperPizza extends Pizza {
    @Override
    public void prepare() {
        setName("伦敦的胡椒披萨");
        System.out.println("伦敦的胡椒披萨 准备原材料~");
    }
}

package 工厂设计模式.抽象工厂模式;

//夜光：将Pizza类做成抽象类
public abstract class Pizza {

    protected String name;


    //准备原材料，因为不同的披萨材料不一样，因此，我们做成抽象方法
    public abstract void prepare();

    public void bake(){
        System.out.println(name + "baking~");
    }

    public void cut(){
        System.out.println(name + "cutting~");
    }

    public void box(){
        System.out.println(name + "boxing~");
    }

    public String getName() {
        return name;
    }

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

 

 

 

package 工厂设计模式.抽象工厂模式;

public class LDFactory implements AbsFactory{
    @Override
    public Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if(orderType.equals("cheese")){
            pizza = new LDCheesePizza();
        }else if(orderType.equals("pepper")){
            pizza = new LDPepperPizza();
        }
        return pizza;
    }
}

 

package 工厂设计模式.抽象工厂模式;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class OrderPizza {

    AbsFactory factory; //嗯唔

    //构造器
    public OrderPizza(AbsFactory factory){  //传入的参数对象AbsFactory
        setFactory(factory); //factory
    }


    private void setFactory(AbsFactory factory){
        Pizza pizza = null;
        String orderType = "";  //这是用户输入的

        this.factory = factory;

        do{
            orderType = gettype();
            //夜光：factory可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if(pizza != null){  //订购成功，不为空的话
                  pizza.prepare();
                  pizza.bake();
                  pizza.cut();
                  pizza.box();
            }else {
                System.out.println("订购失败");
                break;
            }
        }while (true);
    }


    //写一个方法，可以获取客户希望订购的披萨类型
    private String gettype(){
        try{
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));

            System.out.println("请输入披萨类型：");
            String str = strin.readLine();
            return str;

        }catch (IOException e){

            e.printStackTrace();
            return "";
        }
    }
}

 

package 工厂设计模式.抽象工厂模式;

/**
* @Description: 这是抽象工厂模式的抽象层（接口）
* @Author: Hy
* @Date: 2019/11/29
*/
public interface AbsFactory {

    //夜光：让下面的工厂子类来具体实现
    public Pizza createPizza(String orderType);

}

Opentcs就是运用的抽象工厂模式，到炉火纯青的地步

 

 

calendar就是用到了简单工厂模式

package 原型设计模式.传统方式解决克隆羊问题;

//先写一个羊类
public class Sheep {

    //定义几个字段
    private String name;
    private int age;
    private String color;

    //1. 创建一个构造器

    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    //夜光：2. 自动生成一下set和get方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //夜光：3. 如果我们想要输出信息，我们还需要tostring


    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}

 

 

 

 

package 原型设计模式.改进1;



public class Client {
    public static void main(String[] args) {

        Sheep sheep = new Sheep("jim",1,"黑色");
        Sheep sheep1 = (Sheep)sheep.clone();  //你会发现，夜光：并没有使用new方法
        Sheep sheep2 = (Sheep)sheep.clone();  //你会发现，夜光：并没有使用new方法
        Sheep sheep3 = (Sheep)sheep.clone();  //你会发现，夜光：并没有使用new方法
        Sheep sheep4 = (Sheep)sheep.clone();  //你会发现，夜光：并没有使用new方法

        System.out.println(sheep);
        System.out.println(sheep1);
        System.out.println(sheep2);
        System.out.println(sheep3);
        System.out.println(sheep4);


    }
}

package 原型设计模式.改进1;

//先写一个羊类
//这里，我们使用原型模式进行修改
public class Sheep implements Cloneable{  //实现一下这个接口

    //定义几个字段
    private String name;
    private int age;
    private String color;

    //1. 创建一个构造器

    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    //夜光：2. 自动生成一下set和get方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //夜光：3. 如果我们想要输出信息，我们还需要tostring


    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }

    //我们还需要重写一个克隆的方法
    /**
    * @Description:  克隆该实例，我们使用默认的克隆方法
    * @Param: []
    * @return: java.lang.Object
    * @Author: Hy
    * @Date: 2019/11/29
    */
    @Override
    protected Object clone(){

        Sheep sheep = null;
        //抛出一个异常
        try{
            sheep = (Sheep)super.clone();
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        return sheep;
    }
}