Java（36）：设计模式

静态工厂模式：

package shejimoshi;

/*
 * 静态工厂模式（工厂模式）
 * 
 * */

public class Demo1 {

    public static void main(String[] args) {
        
//        Restaurant r1 = new Fish();
//        r1.cook();
//        Restaurant r2 = new Duck();
//        r2.cook();
        
        Restaurant r3 = Waiter.getMenu(Waiter.MENU_FISH);
        r3.cook();
        
    }
    
}

interface Restaurant {
    public void cook();
}

class Fish implements Restaurant {
    @Override
    public void cook() {
        System.out.println("cook fish...");
    }
}

class Duck implements Restaurant {
    @Override
    public void cook() {
        System.out.println("cook duck...");
    }
}

class Meet implements Restaurant {
    @Override
    public void cook() {
        System.out.println("cook meet...");
    }
}

class Waiter {
    public static final int MENU_FISH = 1;
    public static final int MENU_DUCK = 2;
    public static final int MENU_MEET = 3;
    
    public static Restaurant getMenu(int type) {
        switch(type) {
        case MENU_FISH:
            return new Fish();
        case MENU_DUCK:
            return new Duck();
        case MENU_MEET:
            return new Meet();
        default:
            return null;
        }
    }
}

参考：。。。

多方法静态工厂：

package shejimoshi;

/*
 * 多方法静态工厂
 * 
 * */

public class Demo2 {

    public static void main(String[] args) {
        
        CPU c1 = CreateFactory.makeIntelCpu();
        c1.makeCPU();
        
        CPU c2 = CreateFactory.makeAmdCpu();
        c2.makeCPU();
        
    }
    
}

interface CPU {
    public void makeCPU();
}

class intelCPU implements CPU {
    @Override
    public void makeCPU() {
        System.out.println("make intel cpu...");
    }
}

class amdCPU implements CPU {
    @Override
    public void makeCPU() {
        System.out.println("make amd cpu...");
    }
}

class CreateFactory {
    public static CPU makeIntelCpu() {
        return new intelCPU();
    }
    public static CPU makeAmdCpu() {
        return new amdCPU();
    }
}

单例模式：

package shejimoshi;

/*
 * 单例模式
 * 
 * */

class SingleObject {

    private static SingleObject instance = new SingleObject();
    
    private SingleObject() {
        
    }
    
    public static SingleObject getInstance() {
        return instance;
    }
    
    public void showMessage() {
        System.out.println("hello world");
    }
    
}

public class Demo3 {
    
    public static void main(String[] args) {
        
        SingleObject singleObject = SingleObject.getInstance();
//        SingleObject s2 = SingleObject.getInstance();
//        System.out.println(singleObject == s2);
        
        singleObject.showMessage();
        
    }
    
}

 抽象工厂模式：

package shejimoshi;

public class Demo4 {

    public static void main(String[] args) {
        
        // 1.安装宝马轮胎和方向盘
        BMWCarFactory bmwCarFactory = new BMWCarFactory();
        bmwCarFactory.installWheel();
        bmwCarFactory.installSteeringWheel();
    
        // 2.安装奔驰轮胎和方向盘
        BenzCarFactory benzCarFactory = new BenzCarFactory();
        benzCarFactory.installWheel();
        benzCarFactory.installSteeringWheel();
        
    }
    
}

// 1.生产轮胎的工厂接口
interface WheelFactory {
    public String createWheel();
}

// 1.生产宝马轮胎的工厂
class BMWWheelFactory implements WheelFactory {
    @Override
    public String createWheel() {
        System.out.println("生产宝马轮胎...");
        return "宝马轮胎";
    }
}

// 1.生产奔驰轮胎
class BenzWheelFactory implements WheelFactory {
    @Override
    public String createWheel() {
        System.out.println("生产奔驰轮胎...");
        return "奔驰轮胎";
    }
}

// 2.生产方向盘的工厂接口
interface SteeringWheelFactory {
    public String createSteeringWheel();
}

// 2.生产宝马方向盘的工厂
class BMWSteeringWheelFactory implements SteeringWheelFactory {
    @Override
    public String createSteeringWheel() {
        System.out.println("生产宝马方向盘...");
        return "宝马方向盘";
    }
}

// 2.生产奔驰方向盘的工厂
class BenzSteeringWheelFactory implements SteeringWheelFactory {
    @Override
    public String createSteeringWheel() {
        System.out.println("生产奔驰方向盘...");
        return "奔驰方向盘";
    }
}


// 3.抽象的汽车工厂接口：需要生产轮胎（宝马、奔驰）、方向盘（宝马、奔驰）
interface AbstractCarFactory {
    public void installWheel();
    public void installSteeringWheel();
}

// 3.宝马工厂
class BMWCarFactory implements AbstractCarFactory {
    @Override
    public void installWheel() {
        BMWWheelFactory bmwWheelFactory = new BMWWheelFactory();
        String wheel = bmwWheelFactory.createWheel();
        System.out.println("安装轮胎：" + wheel);
    }
    @Override
    public void installSteeringWheel() {
        BMWSteeringWheelFactory bmwSteeringWheelFactory = new BMWSteeringWheelFactory();
        String steeringWheel = bmwSteeringWheelFactory.createSteeringWheel();
        System.out.println("安装方向盘：" + steeringWheel);
    }
}

// 3.奔驰工厂
class BenzCarFactory implements AbstractCarFactory {
    @Override
    public void installWheel() {
        BenzWheelFactory benzWheelFactory = new BenzWheelFactory();
        String wheel = benzWheelFactory.createWheel();
        System.out.println("安装轮胎：" + wheel);
    }
    @Override
    public void installSteeringWheel() {
        BenzSteeringWheelFactory benzSteeringWheelFactory = new BenzSteeringWheelFactory();
        String steeringWheel = benzSteeringWheelFactory.createSteeringWheel();
        System.out.println("安装方向盘：" + steeringWheel);
    }
}