【Java基础】【工厂设计模式】【代理设计模式】【单例设计模式】【多例设计模式】

面向工作编程

学了几个设计模式

• 工厂模式（Factory）

工厂模式包含以下几个组成结构

1. 接口定义

2. 子类

3. Factory子类，定义了一个static方法用于获取子类对象，之所以定义为static是因为Factory类不需要实例化

4. Factory用于获取子类对象

代码示例：

操作步骤：

1. 定义一个接口：目的是吃水果，不同的水果有不同的吃法，此处定义一个方法，具体实现由不同的子类完成

2. 定义第一个子类：实现接口的方法，为吃苹果

3. 定义第二个子类：实现接口的方法，为吃橘子

4. 定义Factory类：根据传入的字符串，返回子类对象

5. 定义测试主类：根据传入的第一个字符串，返回不同子类的eat()函数

代码：

interface IFruit {
	public void eat() ;
}

class Apple implements IFruit {
	public void eat() {
		System.out.println("吃苹果");
	}
}

class Orange implements IFruit {
	public void eat() {
		System.out.println("吃橘子");
	}
}

class Factory {
	//不需要factory产生实例化对象
	public static IFruit getInstance(String cmd) {
		if ("apple".equals(cmd)) {
			return new Apple();
		}
		if ("orange".equals(cmd)) {
			return new Orange();
		}
		return null;
	}
}

public class TestDemo {
	public static void main(String[] args) {
		if (args.length != 1) {
			System.exit(1);
		}
		IFruit fruit = Factory.getInstance(args[0]);
		fruit.eat();
	}
}

总结：

1. Factory的好处在于，每次改动子类的代码的时候，主方法（客户端）不需要改动任何东西

2. 现阶段要求记住结构

• 代理模式（Proxy）

代理模式的形式，一个接口定义实现目标功能，2个子类继承接口，1个实现真实的目标需求，另外一个实现辅助功能，

比如真实目的为吃饭（接口），第一个子类实现真实需求（吃饭），第二个子类实现辅助功能（准备菜品，收拾桌子）

第一个子类是核心实现，第二个子类就是代理子类

代码示例：

操作步骤：

1. 定义1个接口，核心目的为吃饭

2. 定义1个子类，覆写接口的吃饭方法，实现吃饭

3. 定义1个子类，覆写接口的吃饭方法，实现辅助功能（重点）

3.1 定义私有对象，为接口对象

3.2 定义构造函数，为3.1的对象赋值

3.3 定义辅助函数，比如准备碗筷，收拾餐桌

3.4 覆写接口方法

4. 定义1个Factory类，返回接口对象

5. 定义主方法，实现整个过程

代码如下：

interface ISubject {
	public void eat(); //核心目的是吃饭
}

class RealSubject implements ISubject {
	public void eat() {
		System.out.println("2. 开始吃饭");
	}
}

class ProxySubject implements ISubject {
	private ISubject subject; //实际上要操作的对象
	
	public ProxySubject(ISubject subject) {
		this.subject = subject;
	}
	public void prepare() {
		System.out.println("1. 准备饭菜和碗筷");
	}
	public void finish() {
		System.out.println("3. 收拾剩菜和碗筷");
	}
	public void eat() {
		this.prepare();
		this.subject.eat();
		this.finish();
	}
}

class Factory {
	public static ISubject getInstance() {
		return new ProxySubject(new RealSubject());
	}
}

public class TestDemo {
	public static void main(String args[]) {
		ISubject subject = Factory.getInstance();
		subject.eat();
	}
}

总结：

代理模式一般要和工厂模式结合使用。

• 单例设计模式

一个类只允许实例一个对象，就是实现单例设计

问题来源：

类的实例化由类完成，定义为：

private final static Singleton instance = new Singleton();

final：只要加载该类，就会自动创建1个共享对象

构造函数使用private定义

提供getter方法用于获取类中创建的对象

代码示例：

class Singleton {
	private final static Singleton instance = new Singleton();
	public static Singleton getInstance() {
		return instance ;
	}
	private Singleton() {}
	public void print() {
		System.out.println("Hello World");
	}
}
public class TestDemo {
	public static void main(String[] args) {
		Singleton s = null;
		s = Singleton.getInstance();
		s.print();
	}
}

总结：

单例设计的概念很重要，开发过程写的很少

• 多例设计模式

多例模式来源是，一个类的对象是有限个数的

比如1周只有7个对象天

性别只有2个对象，男或者女

代码结构：（以性别为例）

1. 定义2个常量，代表男性或者女生

2. 定义2个常量对象，代表不同性别实例

3. 定义1个私有的构造函数

4. 定义1个getter方法，根据传入的值返回男性或者女生对象，默认值为null

代码示例：

class Sex {
	public static final int FEMALE_CMD = 0 ;
	public static final int MALE_CMD = 1 ;
	private static final Sex MALE = new Sex("male") ;
	private static final Sex FEMALE = new Sex("female") ;
	
	private String title ;
	private Sex(String title) {
		this.title = title ;
	}
	
	public static Sex getInstance(int ch) {
		switch (ch) {
			case MALE_CMD:
			return MALE;
			case FEMALE_CMD:
			return FEMALE;
			default:
			return null;
		}
	}
	public String toString() {
		return this.title;
	}
}

public class TestDemo {
	public static void main(String[] args) {
		Sex a = Sex.getInstance(Sex.MALE_CMD);
		System.out.println(a);
	}
}

总结：

多例设计模式已经被枚举取代，此处只要了解结构即可。