设计模式 - 应试笔记

// 注意静态体现在 public static
// 简单工厂模式和工厂方式模式都是类模式，是静态的
public class TVFactory
{
	public static TV produceTV(String brand) throws Exception
	{
		if(brand.equalsIgnoreCase("Haier"))
		{
			System.out.println("电视机工厂生产海尔电视机！");
			return new HaierTV();
		}
		else if(brand.equalsIgnoreCase("Hisense"))
		{
			System.out.println("电视机工厂生产海信电视机！");
			return new HisenseTV();
		}
		else
		{
			throw new Exception("对不起，暂不能生产该品牌电视机！");
		}
	}
}

public class HaierTV implements TV
{
	public void play()
	{
		System.out.println("海尔电视机播放中......");
	}
}

public class HisenseTV implements TV
{
	public void play()
	{
		System.out.println("海信电视机播放中......");
	}	
}

public interface TV
{
	public void play();
}

// 在另一个样例中，product 可以用 abstract 类，使用实线空箭头
public abstract class User
{
	public void sameOperation()
	{
        System.out.println("修改个人资料！");
	}
	
	public abstract void diffOperation();
}

// 最上面和最下面的两个接口
public interface TV {
	public void play();
}
public interface TVFactory {
    public TV produceTV();
}

// 具体工厂
public class HisenseTVFactory implements TVFactory {
    public TV produceTV() {
    	System.out.println("海信电视机工厂生产海信电视机。");
    	return new HisenseTV();
    }
}

// 具体产品
public class HisenseTV implements TV {
	public void play() {
		System.out.println("海信电视机播放中......");
	}	
}

// 不过是一个工厂可以创造多个产品
public class HaierFactory implements EFactory
{
	public Television produceTelevision()
	{
		return new HaierTelevision();
	}
	
	public AirConditioner produceAirConditioner()
	{
        // 这个是空调
		return new HairAirConditioner();
	}
}

// 客户端类
public class Client {
    public static void main(String args[]) {
        // 动态确定套餐种类，使用 XML 配置读取具体的建造者类
        MealBuilder mb = (MealBuilder) XMLUtil.getBean();
        KFCWaiter waiter = new KFCWaiter();   // 服务员是指挥者，负责构建套餐
        waiter.setMealBuilder(mb);        // 服务员设置当前的套餐建造者
        Meal meal = waiter.construct();	 // 用 director 中的 construct 构造 Product
        
        System.out.println(meal.getFood());
        System.out.println(meal.getDrink());
    }
}

// 指挥者类
public class KFCWaiter {
    private MealBuilder mb;
    public void setMealBuilder(MealBuilder mb) {
        this.mb = mb;
    }
    // 构建套餐并返回
    public Meal construct() {
        mb.buildFood();  // 构建主食
        mb.buildDrink(); // 构建饮料
        return mb.getMeal();  // 返回最终构建的套餐
    }
}

// 产品类，表示套餐
public class Meal {
    // 套餐的部件：食物和饮料
    private String food;
    private String drink;
    public void setFood(String food) {
        this.food = food; 
    }
    public void setDrink(String drink) {
        this.drink = drink; 
    }
    public String getFood() {
        return this.food; 
    }
    public String getDrink() {
        return this.drink; 
    }
}

// 抽象建造者类，定义构建流程的接口
public abstract class MealBuilder {
    // 需要构建的套餐对象，因此其和 Meal 是组合关系
    protected Meal meal = new Meal();
    public abstract void buildFood();
    public abstract void buildDrink();
    // 返回构建好的套餐
    public Meal getMeal() {
        return meal;
    }
}

// 具体建造者A，实现套餐A的构建
public class SubMealBuilderA extends MealBuilder {
    public void buildFood() {
        meal.setFood("一个鸡腿堡");
    }
    public void buildDrink() {
        meal.setDrink("一杯可乐");
    }
}

// 具体建造者B，实现套餐B的构建
public class SubMealBuilderB extends MealBuilder {
    public void buildFood() {
        meal.setFood("一个鸡肉卷");
    }
    public void buildDrink() {
        meal.setDrink("一杯果汁"); 
    }
}

// 附件类
public class Attachment {
    // 模拟下载附件的方法
    public void download() {
        System.out.println("下载附件");    
    }
}

// 客户端类，测试克隆功能
public class Client {
    public static void main(String a[]) {
        Email email, copyEmail;
        email = new Email();
        // 克隆原始邮件
        copyEmail = (Email) email.clone()
        // 对象是深拷贝
        System.out.println("email==copyEmail?");
        System.out.println(email == copyEmail); //false
        
        // 附件是同一个对象的浅拷贝
        System.out.println("email.getAttachment==copyEmail.getAttachment?"); 
        System.out.println(email.getAttachment() == copyEmail.getAttachment());//true
    }
}

// 邮件类，实现了 Cloneable 接口，支持克隆
public class Email implements Cloneable {
    // 克隆方法，返回当前对象的浅拷贝
    public Object clone() {
        Email clone = null;
        try {
            // 调用父类的 clone() 方法进行浅拷贝
            clone = (Email) super.clone();
        } catch (CloneNotSupportedException e) {
            System.out.println("Clone failure!"); // 如果克隆失败，输出错误信息
        }
        return clone;
    }
    
    // 获取附件的方法
    public Attachment getAttachment() {
        return this.attachment;
    }
    
    // 显示邮件内容的方法
    public void display() {
        System.out.println("查看邮件");    
    }
}

import java.io.*;

// 附件类，需要实现 Serializable
public class Attachment implements Serializable {
    public void download() {
        System.out.println("下载附件");
    }
}

// 客户端类
public class Client {
    public static void main(String a[]) {
        Email email, copyEmail = null;
        email = new Email();
        try {
            // 深克隆 email 对象，区别就在 deep
            copyEmail = (Email) email.deepClone();
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 对象不是一个对象
        System.out.println("email==copyEmail?");
        System.out.println(email == copyEmail); // false，表示是不同的对象

        // 附件对象不是一个附件对象
        System.out.println("email.getAttachment==copyEmail.getAttachment?");
        System.out.println(email.getAttachment() == copyEmail.getAttachment());
    }
}

// 继承的是
public class Email implements Serializable {
    private Attachment attachment = null;
    public Email() {
        this.attachment = new Attachment();
    }

    // 深克隆实现方法
    public Object deepClone() throws IOException, ClassNotFoundException {
        // 将对象写入字节数组输出流
        ByteArrayOutputStream bao = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bao);
        oos.writeObject(this); // 序列化当前对象到流中

        // 从字节数组输入流中读取对象
        ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject(); // 反序列化生成新的对象
    }

    // 获取附件的方法
    public Attachment getAttachment() {
        return this.attachment;
    }

    // 显示邮件内容的方法
    public void display() {
        System.out.println("查看邮件");
    }
}

import java.util.*;

// 定义颜色接口,继承Cloneable接口以支持克隆
interface MyColor extends Cloneable {
    public Object clone();    // 克隆方法
    public void display();    // 显示颜色
}

// 实现红色类
class Red implements MyColor {
    // 实现克隆方法
    public Object clone() {
        Red r = null;
        try {
            r = (Red)super.clone();  // 调用Object的clone()方法
        }
        catch(CloneNotSupportedException e) {
        }
        return r;
    }
    
    public void display() {
        System.out.println("This is Red!");
    }
}

// 实现蓝色类,结构同Red类
class Blue implements MyColor {
    public Object clone() {
        Blue b = null;
        try {
            b = (Blue)super.clone();
        }
        catch(CloneNotSupportedException e) {
        }
        return b;
    }
    
    public void display() {
        System.out.println("This is Blue!");
    }
}

// 原型管理器类
class PrototypeManager {
    private Hashtable ht = new Hashtable();    // 存储原型对象的哈希表
    
    // 初始化,加入默认原型
    public PrototypeManager() {
        ht.put("red", new Red());
        ht.put("blue", new Blue());
    }
    
    // 添加新原型
    public void addColor(String key, MyColor obj) {
        ht.put(key, obj);
    }
    
    // 获取原型克隆
    public MyColor getColor(String key) {
        return (MyColor)((MyColor)ht.get(key)).clone();
    }
}

// 客户端测试类
class Client {
    public static void main(String args[]) {
        PrototypeManager pm = new PrototypeManager();
        
        // 获取两个红色对象并显示
        MyColor obj1 = (MyColor)pm.getColor("red");
        obj1.display();
        
        MyColor obj2 = (MyColor)pm.getColor("red");
        obj2.display();
        
        // 判断两个对象是否相同
        System.out.println(obj1 == obj2);  // 输出false,因为是克隆对象
    }
}

public static void main(String args[]) {
    // 创建原型对象
    stu1 = new Student("张无忌","男",24,"软件工程","软件学院","中南大学");
    
    // 克隆两个新对象并修改部分属性
    stu2 = stu1.clone();  // 克隆stu1
    stu2.setStuName("杨过");  // 只修改姓名
    
    stu3 = stu1.clone();  // 再次克隆stu1
    stu3.setStuName("小龙女");  // 修改姓名和性别
    stu3.setStuSex("女");
}

// 下面为懒汉式，第一次调用才创建对象
// 需要处理好多线程问题
public class Singleton {
    // 静态变量，保存类的唯一实例
    private static Singleton instance = null;
    // 私有构造函数，防止外部实例化
    private Singleton() {    
    }
    // 静态方法，返回类的唯一实例
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

// 下面是饿汉式，在类加载时，便将单例实例创建好
// 该方式的实现是线程安全的，但稍微浪费资源（实例可能用不到）
public class HungrySingleton {
    // 在类加载时，立即初始化实例
    private static final HungrySingleton instance = new HungrySingleton();
    // 私有构造函数，防止外部实例化
    private HungrySingleton() {}
    // 提供静态方法获取唯一实例
    public static HungrySingleton getInstance() {
        return instance;
    }
}

// 哈希表多例模式，不指定数量，而是每个 key 对应一个多例
public class Multiton {
    // 存储不同实例的Map，按标识符存储
    private static Map<String, Multiton> instances = new HashMap<>();
    // 私有构造函数，防止外部实例化
    private Multiton() {
    }
    // 获取多例实例的方法，根据标识符返回不同的实例
    public static Multiton getInstance(String key) {
        if (!instances.containsKey(key)) {
            instances.put(key, new Multiton());  // 如果不存在，则创建并保存实例
        }
        return instances.get(key);  // 返回已有的实例
    }
}

// 三例模式
public class Multiton {
    // 定义固定数量的实例（如三例）
    private static final int INSTANCE_COUNT = 3;
    // 用于存储三个实例的数组
    private static final Multiton[] instances = new Multiton[INSTANCE_COUNT];
    // 使用一个计数器来轮流分配实例
    private static int currentInstanceIndex = 0;
    // 私有构造函数，防止外部通过 new 创建对象
    private Multiton() {
    }
    // 获取下一个实例的方法
    public static synchronized Multiton getInstance() {
        // 如果实例未被创建，先创建实例
        if (instances[currentInstanceIndex] == null) {
            instances[currentInstanceIndex] = new Multiton();
        }
        // 获取当前实例
        Multiton instance = instances[currentInstanceIndex];
        // 循环更新索引，以便下次调用时返回下一个实例
        currentInstanceIndex = (currentInstanceIndex + 1) % INSTANCE_COUNT;
        return instance;
    }
    
    // 示例方法，模拟实例执行的操作
    public void doSomething() {
        System.out.println("实例 " + this + " 正在执行操作");
    }
}

// 被适配者类 (旧的接口)
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee: Handling specific request");
    }
}

// 目标接口 (客户端期望的接口)
interface Target {
    void request();
}

// 适配器类 (实现了Target接口，适配Adaptee)
public class Adapter extends Adaptee implements Target {
    public void request() {
        specificRequest(); // 把客户端的request方法适配为Adaptee的specificRequest
    }
}

// 客户端类
public class Client {
    public static void main(String[] args) {
        Target target = new Adapter();   // 客户端通过Target接口使用Adapter
        target.request();  // 实际上调用的是Adaptee的specificRequest方法
    }
}

// 目标接口 (客户端期望的接口)
public class Target {
    public void request() {
        System.out.println("Target: Handling request");
    }
}

// 被适配者类 (旧的接口)
public class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee: Handling specific request");
    }
}

// 适配器类 (通过组合方式实现适配)
public class Adapter extends Target {
    private Adaptee adaptee;  // 适配器持有被适配者的引用

    // 构造函数，传入被适配者的实例
    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }
    // 实现Target的request方法，实际上调用Adaptee的specificRequest方法
    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

// 客户端类，和类对象一致
public class Client {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        target.request();  // 实际上调用的是Adaptee的specificRequest方法
    }
}

// 实现部分：Color接口
public interface Color {
    void bepaint(String penType, String name);
}

public class Red implements Color {
    @Override
    public void bepaint(String penType, String name) {
        System.out.println(penType + " Red color " + name + ".");
    }
}

public class Green implements Color {
    @Override
    public void bepaint(String penType, String name) {
        System.out.println(penType + " Green color " + name + ".");
    }
}

// 抽象部分：Pen类
public abstract class Pen {
    protected Color color;
    // 设置颜色
    public void setColor(Color color) {
        this.color = color;
    }
    // 抽象绘画方法
    public abstract void draw(String name);
}

public class SmallPen extends Pen {
    @Override
    public void draw(String name) {
        color.bepaint("SmallPen", name);
    }
}

public class BigPen extends Pen {
    @Override
    public void draw(String name) {
        color.bepaint("BigPen", name);
    }
}

// 测试类
public class Client {
    public static void main(String[] args) {
        // 创建一种颜色（红色）
        Color red = new Red();
        // 创建一种笔（大号笔），并设置颜色
        Pen bigPen = new BigPen();
        bigPen.setColor(red);
        bigPen.draw("Flower");
        // 创建另一种颜色（绿色）
        Color green = new Green();
        // 使用小号笔，并设置为绿色
        Pen smallPen = new SmallPen();
        smallPen.setColor(green);
        smallPen.draw("Tree");
    }
}

// 抽象部分：报表显示
abstract class ReportDisplay {
    protected DataCollector dataCollector;

    public ReportDisplay(DataCollector dataCollector) {
        this.dataCollector = dataCollector;
    }

    public abstract void display();
}

// 具体实现：报表显示方式1
class ReportDisplayStyle1 extends ReportDisplay {
    public ReportDisplayStyle1(DataCollector dataCollector) {
        super(dataCollector);
    }

    @Override
    public void display() {
        System.out.println("Displaying report in style 1:");
        dataCollector.collectData();
    }
}

// 实现部分：数据采集接口
interface DataCollector {
    void collectData();
}

// 适配器类：读取Excel文件的适配器，适配Excel API
class ExcelFileCollector implements DataCollector {
    private ExcelAPI excelAPI;

    public ExcelFileCollector(ExcelAPI excelAPI) {
        this.excelAPI = excelAPI;
    }

    @Override
    public void collectData() {
        excelAPI.readExcel();
    }
}

// Excel API 模拟类
class ExcelAPI {
    public void readExcel() {
        System.out.println("Collecting data from Excel file using Excel API.");
    }
}

// 抽象类 MyElement，定义 eat() 抽象方法
public abstract class MyElement {
    public abstract void eat();
}

// Plate 类，包含 MyElement 对象的集合，并实现 eat() 方法
public class Plate extends MyElement {
    private List<MyElement> list = new ArrayList<>(); // 注意是私有列表
    public void add(MyElement element) { // 组合模式标准的添加元素
        list.add(element);
    }
    public void delete(MyElement element) {    // 删除元素
        list.remove(element);
    }
    // 实现 eat() 方法，调用每个元素的 eat()
    // 可以实现 eat() 盘子中的所有水果
    @Override
    public void eat() {
        for (MyElement element : list) {
            element.eat();
        }
    }
}

// Apple 类，具体实现 eat() 方法
public class Apple extends MyElement {
    @Override
    public void eat() {
        System.out.println("Eating an apple!");
    }
}
// Pear 类，具体实现 eat() 方法
public class Pear extends MyElement {
    @Override
    public void eat() {
        System.out.println("Eating a pear!");
    }
}

// 测试类 Client
public class Client {
    public static void main(String[] args) {
        // 创建 MyElement 对象
        MyElement obj1, obj2, obj3, obj4, obj5;
        Plate plate1, plate2, plate3;
        // 创建水果对象
        obj1 = new Apple();
        obj2 = new Pear();
        // 创建盘子 plate1 并添加水果
        plate1 = new Plate();
        plate1.add(obj1);
        plate1.add(obj2);
        // 创建更多水果对象
        obj3 = new Banana();
        obj4 = new Banana();
        // 创建盘子 plate2 并添加水果
        plate2 = new Plate();
        plate2.add(obj3);
        plate2.add(obj4);
        // 创建 plate3，它可以包含其他盘子和水果
        obj5 = new Apple();
        plate3 = new Plate();
        plate3.add(plate1);
        plate3.add(plate2);
        plate3.add(obj5);
        // 调用 eat() 方法，演示组合模式的效果
        System.out.println("Plate 1 contents:");
        plate1.eat();  // Plate 1 吃掉其包含的水果
        System.out.println("\nPlate 3 contents:");
        plate3.eat();  // Plate 3 吃掉 plate1, plate2 和一个 Apple
    }
}

// 定义基础接口 Transform
public interface Transform {
    public void move();
}

// Car 类，实现 Transform 接口，表示一辆车
public final class Car implements Transform {
    public Car() {
        System.out.println("变形金刚是一辆车！");
    }
    @Override
    public void move() {
        System.out.println("在陆地上移动！");
    }
}

// Changer 类，装饰器基类，持有一个 Transform 对象
public class Changer implements Transform {
    private Transform transform; // 私有变量
    public Changer(Transform transform) { // 通过构造函数改变 transform
        this.transform = transform;
    }
    @Override
    public void move() {
        transform.move();
    }
}

// Robot 类，继承 Changer，扩展了说话功能
public class Robot extends Changer {
    public Robot(Transform transform) {
        super(transform); // 调用父类的构造函数，改变父类的 transform，即改变其 move 函数
        System.out.println("变成机器人！");
    }

    public void say() {
        System.out.println("说话！");
    }
}

// Client 测试类
public class Client {
    public static void main(String[] args) {
        // 创建一个基础的 Car 对象
        Transform camaro = new Car();
        camaro.move(); // 在陆地移动
        System.out.println("-----------------------------");

        // 使用 Robot 装饰 Car 对象，添加说话功能
        Robot optimus = new Robot(camaro);
        optimus.move(); //还是 Car 的移动功能
        optimus.say(); // Robot 的说话功能
    }
}

public class Client {
    public static void main(String[] args) {
        Person p1, p2;
        p1 = new Person("张三", 5000, 1000, 10000);
        p2 = new Person("李四", 10000, 2000, 20000);
        Factory.addPerson("张三", p1);
        Factory.addPerson("李四", p2);
        Component e1, m1, personBusiness, personPayback, teamBusiness;
        String name;

        e1 = new Employee();
        name = p1.getName();
        personBusiness = new PersonBusiness(e1); // 张三是员工，装饰了一层 PersonPayback
        personPayback = new PersonPayback(personBusiness) // 再装饰一层 PersonPayback
        System.out.print(name);
        System.out.println(personPayback.getDes(name));
        System.out.println(personPayback.getBonus(name));

        m1 = new Manager();
        name = p2.getName();
        personBusiness = new PersonBusiness(m1); // 李四是员工，装饰一层 PersonPayback
        personPayback = new PersonPayback(personBusiness); // 再装饰一层
        teamBusiness = new TeamBusiness(personPayback);
        System.out.print(name);
        System.out.println(teamBusiness.getDes(name));
        System.out.println(teamBusiness.getBonus(name));
    }
}
/*
张三普通员工获得个人业务奖金获得个人回款奖金
151.0
李四经理获得个人业务奖金获得个人回款奖金获得团队业务奖金
502.0
*/

// Fan 类，表示风扇
public class Fan {
    public void on() {
        System.out.println("风扇打开！");
    }
    public void off() {
        System.out.println("风扇关闭！");
    }
}
// Light 类，表示灯光
public class Light {
    private String position;
    public Light(String position) {
        this.position = position;
    }
    public void on() {
        System.out.println(this.position + "灯打开！");
    }
    public void off() {
        System.out.println(this.position + "灯关闭！");
    }
}

// GeneralSwitchFacade 类，作为开关的外观模式
public class GeneralSwitchFacade {
    private Light[] lights = new Light[4]; // 用私有变量关联具体类
    private Fan fan;
    private AirConditioner ac;
    private Television tv;
    
    public GeneralSwitchFacade() { // 组合成一个开关
        lights[0] = new Light("左前");
		...
        fan = new Fan();
        ac = new AirConditioner();
        tv = new Television();
    }
    // 打开所有设备
    public void on() {
        for (Light light : lights) {
            light.on();
        }
        fan.on()；...
    }
    // 关闭所有设备
    public void off() {
        for (Light light : lights) {
            light.off();
        }
        fan.off(); ...
    }
}

// Client 测试类
public class Client {
    public static void main(String[] args) {
        GeneralSwitchFacade gsf = new GeneralSwitchFacade();
        gsf.on(); // 打开所有设备
        System.out.println("-----------------------");
        gsf.off(); // 关闭所有设备
    }
}