【题目解析】Java设计模式部分

1、说一下你熟悉的设计模式？

• 单例模式：保证被创建一次，节省系统开销。
• 工厂模式：简单工厂、抽象工厂；解耦代码。
• 模板方法模式：定义了一个算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以在不改变算法结构的情况下，重新定义算法的步骤。

2、简单工厂和抽象工厂有什么区别？

• 简单工厂：用来生产同一等级结构中的任意产品，对于增加新的产品，无能为力。
• 工厂方法：用来生产同一等级结构中的固定产品，支持增加任意产品。
• 抽象工厂：用来生产不同产品族的全部产品，对于增加新的产品，无能为力；支持增加产品族。

3、单例模式

//饿汉式单例设计模式
class Singleton{
	// 在类的内部可以访问私有结构，所以可以在类的内部产生实例化对象
	private final static Singleton INSTANCE = new Singleton() ;
	private Singleton() { // private声明构造
	}
	public static Singleton getInstance() {
		return INSTANCE ;
	}
	public void print() {
		System.out.println("Hello World");
	}
}
public class SingletonTest {
	public static void main(String[] args) {
		Singleton singleton = null ; // 声明对象
		singleton = Singleton.getInstance() ;
		singleton.print();
	}
}


//懒汉式单例
class Singleton{
	private static Singleton instance ;
	private Singleton() { // private声明构造
	}
	public static Singleton getInstance() {
		if (instance==null) { // 表示此时还没有实例化
			instance = new Singleton() ;
		}
		return instance ;
	}
	public void print() {
		System.out.println("Hello World");
	}
}
public class SingletonTest {
	public static void main(String[] args) {
		Singleton singleton = null ; // 声明对象
		singleton = Singleton.getInstance() ;
		singleton.print();
	}
}

4、工厂模式

//工厂设计模式
interface IFruit { // 定义一个描述吃水果的操作
	public void eat() ; // 吃水果
}
class Factory {
	// 此时Factory产生实例化对象没有意义，对外提供工具方法
	public static IFruit getInstance(String className){
		if ("apple".equals(className)) {
			return new Apple() ;
		}
		if ("watermelon".equals(className)) {
			return new Watermelon() ;
		}
		return null ;
	}
}
class Apple implements IFruit {
	public void eat() {
		System.out.println("吃苹果前需要洗");
	}
}
class Watermelon implements IFruit {
	public void eat() {
		System.out.println("吃西瓜前需要切");
	}
}
public class Test{
	public static void main(String[] args) {
		if (args.length==0) { // 没有传递参数
			System.out.println("没有传递参数，程序退出") ;
			System.exit(1) ; // 退出程序
		}
		IFruit fruit = Factory.getInstance(args[0]) ;
		fruit.eat() ;
	}
}

5、代理模式

//代理设计模式

interface ISubject {
	public void buyComputer() ; // 核心功能是买电脑
}
class RealSubject implements ISubject {
	public void buyComputer() {
		System.out.println("买一台外星人电脑") ;
	}
}
class ProxySubject implements ISubject {
	private ISubject subject ; // 真正的操作业务
	public ProxySubject(ISubject subject) {
		this.subject = subject ;
	}
	public void produceComputer() {
		System.out.println("1.生产外星人电脑") ;
	}
	public void afterSale() {
		System.out.println("3.外星人电脑售后团队") ;
	}
	public void buyComputer() {
		this.produceComputer() ; // 真实操作前的准备
		this.subject.buyComputer() ; // 调用真实业务
		this.afterSale() ; // 操作后的收尾
	}
}
class Factory {
	public static ISubject getInstance(){
		return new ProxySubject(new RealSubject()) ;
	}
}
public class Test{
	public static void main(String[] args) {
		ISubject subject = Factory.getInstance() ;
		subject.buyComputer() ;
	}
}