Java学习笔记——设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。

单例模式(Singleton Pattern)

饿汉式

public class Singleton {
	// 私有静态成员，只能在类的内部访问，并且是类变量，只有一个（单例）
    private static Singleton instance = new Singleton();
    // privat构造器，使得不能在类外部创建该对象
    private Singleton (){}  
    public static Singleton getInstance() {  
        return instance;  
    }  
}

懒汉式

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static Singleton getInstance() {
    	// 如果类的实例未创建，则创建实例，否则直接返回实例
	    if (instance == null) {  
	        instance = new Singleton();  
	    }  
	    return instance;  
    }
}

单例模式的几种实现方式#java，简单易懂

模板方法(TemplateMethod)模式

抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

abstract class Template{
	public final void getTime(){
		long start = System.currentTimeMillis();
		code();
		long end = System.currentTimeMillis();
		System.out.println("执行时间是："+(end - start));
	}
	public abstract void code();
}

class SubTemplate extends Template{
	public void code(){
		for(int i = 0; i < 10000; i++){
			System.out.println(i);
		}
	}
}

工厂方法(FactoryMethod)模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。

public class TestFactoryMethod {
	public static void main(String[] args) {
		IWorkFactory iWorkFactory = new StudentWorkFactory();
		iWorkFactory.getWork().doWork();
		
		IWorkFactory iWorkFactory2 = new TeacherWorkFactory();
		iWorkFactory2.getWork().doWork();
	}
}

interface IWorkFactory{
	Work getWork();
}

class StudentWorkFactory implements IWorkFactory{

	@Override
	public Work getWork() {
		return new StudentWork();
	}
	
}

class TeacherWorkFactory implements IWorkFactory{

	@Override
	public Work getWork() {
		return new TeacherWork();
	}
	
}

interface Work{
	void doWork();
}

class StudentWork implements Work{
	@Override
	public void doWork() {
		System.out.println("学生做作业");
	}
}

class TeacherWork implements Work{
	@Override
	public void doWork() {
		System.out.println("老师批改作业");
	}
}

代理模式(Proxy)

为其他对象提供一种代理以控制对这个对象的访问。

// 接口的应用：代理模式
public class TestProxy {
	public static void main(String[] args) {
		Object obj = new ProxyObject();
		obj.action();
	}
}

interface Object{
	void action();
}

// 代理类
class ProxyObject implements Object{
	Object obj;

	public ProxyObject() {
		System.out.println("代理类创建成功");
		obj = new ObjectImpl();
	}
	
	@Override
	public void action() {
		System.out.println("代理类开始执行");
		obj.action();
		System.out.println("代理类执行结束");
	}
}

// 被代理类
class ObjectImpl implements Object{
	@Override
	public void action() {
		System.out.println("=====被代理类开始执行=====");
		System.out.println("=====具体的操作=====");
		System.out.println("=====被代理类执行完毕=====");
	}
}

个人总结：代理类与被代理类都实现同一个接口，且代理类与被代理类是关联关系，即被代理类以属性的方式出现在代理类中。