六大设计模式详解-优快云博客

1.单例模式

饿汉式:

public class Single{

	private Single() {}
	
	private static Singles = new Single();
	
	public static Single getInstance() {
		return s;
	}
}

懒汉式:

public class Single {

	private Single() {
	}
	
	private static Single t = null;
	
	public  static SinglegetInstance() {
		if (t == null) {
			synchronized (Single.class) {
				if (t == null) {
					t = new Single();
				}
			}
		}
		return t;
	}
}

2.工厂模式

简单⼯⼚模式：

创建抽象产品类

public abstract class Computer {
 /**
 *产品的抽象⽅法，由具体的产品类去实现
 */
 public abstract void start();
}

创建具体产品类

public class LenovoComputer extends Computer{
 @Override
 public void start() {
 	System.out.println("联想电脑启动");
}

public class HpComputer extends Computer{
 @Override
 public void start() {
 	System.out.println("惠普电脑启动");
 }
}

创建⼯⼚类

public class ComputerFactory {
 public static Computer createComputer(String type){
	 Computer mComputer=null;
	 switch (type) {
	 case "lenovo":
	 mComputer=new LenovoComputer();
	 break;
	 case "hp":
	 mComputer=new HpComputer();
	 break;
	 }
	 return mComputer;
 }
}

调⽤

public class CreatComputer {
public static void main(String[]args){
 	ComputerFactory.createComputer("hp").start();
 }
}

工厂模式一:

public class AnimalTest {
	public static void main(String[] args) {
	
		Animal a = AnimalFactory.createAnimal(Dog.class);
		a.eat();
		
		a = AnimalFactory.createAnimal(Cow.class);
		a.eat();
		
		a = AnimalFactory.createAnimal(Chiken.class);
		a.eat();
		
		
	}
}

public abstract class Animal {
	public abstract void eat();
}

public class AnimalFactory {

	private AnimalFactory() {
	}

	public static Animal createAnimal(String type) {
		if ("dog".equals(type)) {
			return new Dog();
		} else if ("cat".equals(type)) {
			return new Cat();
		} else if("cow".equals(type)){
			return new Cow();
		}else{
			return null;
		}
	}
	
	
	public static <T> T createAnimal(Class<T> type){
		try {
			T instance = type.newInstance();//Cat.class.newInstance();
			return instance;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
}

public class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}

}
...略

工厂模式二:

/*
 * 多态的思想。
 */
public class AnimalTest {
	public static void main(String[] args) {
		// 使用狗工厂
		AnimalFactory af = new DogFactory();
		Animal a = af.createAnimal();
		a.eat();

		af = new CatFactory();
		a = af.createAnimal();
		a.eat();

		af = new PigFactory();
		a = af.createAnimal();
		a.eat();
	}
}

public abstract class Animal {
	public abstract void eat();
}

public abstract class AnimalFactory {
	public abstract Animal createAnimal();
}

public class DogFactory extends AnimalFactory {

	@Override
	public Animal createAnimal() {
		return new Dog();
	}

}

public class CatFactory extends AnimalFactory {

	@Override
	public Animal createAnimal() {
		return new Cat();
	}

}

public class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}

}

...略

3.装饰模式

public class PhoneTest {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.call();
		System.out.println("--------------");

		p = new ColorPhone();
		p.call();
		System.out.println("--------------");
		
		p = new GuangGaoPhone();
		p.call();
		System.out.println("--------------");
		
		p = new ColorGuangGaoPhone();
		p.call();
	}
}

public class Phone {
	public void call() {
		System.out.println("用手机打电话");
	}
}

public class ColorPhone extends Phone {
	public void call() {
		System.out.println("播放彩铃");
		// System.out.println("用手机打电话");
		super.call();
	}
}
public class GuangGaoPhone extends Phone {
	@Override
	public void call() {
		super.call();
		System.out.println("播放广告");
	}
}

public class ColorGuangGaoPhone extends ColorPhone {
	@Override
	public void call() {
		super.call();
		System.out.println("播放广告");
	}
}

4.模板模式

public class PrintTest {
	public static void main(String[] args) {
		PrintTemplet pt = new PrintDemo1();
		pt.print();
		
		pt = new PrintDemo2();
		pt.print();
	}
}

/*
 * 定义了一个打印的模板类
 */
public abstract class PrintTemplet {

	public void print() {
		printHead();
		printBody();
		printBottom();
	}

	public abstract void printHead();

	public abstract void printBody();

	public abstract void printBottom();
}

public class PrintDemo1 extends PrintTemplet {

	@Override
	public void printHead() {
		System.out.println("采用第一种方案打印头");
	}

	@Override
	public void printBody() {
		System.out.println("采用第一种方案打印中间");
	}

	@Override
	public void printBottom() {
		System.out.println("采用第一种方案打印尾");
	}

}

public class PrintDemo2 extends PrintTemplet {
	@Override
	public void printHead() {
		System.out.println("采用第二种方案打印头");
	}

	@Override
	public void printBody() {
		System.out.println("采用第二种方案打印中间");
	}

	@Override
	public void printBottom() {
		System.out.println("采用第二种方案打印尾");
	}
}

5.Builder构建者模式

直⽩来说，就是使⽤多个简单的对象⼀步⼀步构建成⼀个复杂的对象


public static void main(String[]args){
	 ComputerBuilder computerBuilder=new ComputerBuilder();
	 computerBuilder.installDisplayer("显万器");
	 computerBuilder.installMainUnit("主机");
	 computerBuilder.installKeybord("键盘");
	 computerBuilder.installMouse("⿏标");
	 Computer computer=computerBuilder.Builder();
	 System.out.println(computer);
 }

定义computer

public class Computer {
    private String displayer;
    private String mainUnit;
    private String mouse;
    private String keyboard;

    public String getDisplayer() {
        return displayer;
    }

    public void setDisplayer(String displayer) {
        this.displayer = displayer;
    }

    public String getMainUnit() {
        return mainUnit;
    }

    public void setMainUnit(String mainUnit) {
        this.mainUnit = mainUnit;
    }

    public String getMouse() {
        return mouse;
    }

    public void setMouse(String mouse) {
        this.mouse = mouse;
    }

    public String getKeyboard() {
        return keyboard;
    }

    public void setKeyboard(String keyboard) {
        this.keyboard = keyboard;
    }

    @Override
    public String toString() {
        return "Computer{" + "displayer='" + displayer + '\'' + ", mainUnit='"
                + mainUnit + '\'' + ", mouse='" + mouse + '\'' + ", keyboard='" + keyboard +
                '\'' + '}';
    }
}

ComputerBuilder

public static class ComputerBuilder {
    private ComputerBuilder target = new ComputerBuilder();
    public Builder installDisplayer(String displayer) {
        target.setDisplayer(displayer);
        return this;
    }
    public Builder installMainUnit(String mainUnit) {
        target.setMainUnit(mainUnit);
        return this;
    }
    public Builder installMouse(String mouse) {
        target.setMouse(mouse);
        return this;
    }
    public Builder installKeybord(String keyboard) {
        target.setKeyboard(keyboard);
        return this;
    }
    public ComputerBuilder build() {
        return target;
    }
}

6.代理模式

 /**
 * 抽象类⼈
 */
public interface Person {
 	void doSomething();
}

 /**
 * 创建⼀个名为Bob的⼈的实现类
 */
public class Bob implements Person {
 public void doSomething() {
 	System.out.println("Bob doing something!");
 }
}

/**
* JDK动态代理
* 需实现 InvocationHandler 接⼝ */
public class JDKDynamicProxy implements InvocationHandler {
	 //被代理的对象
	 Person target;
	 // JDKDynamicProxy 构造函数
	 public JDKDynamicProxy(Person person) { 
	 	this.target = person;
	 }
	 //获取代理对象
	 public Person getTarget() { 
	 	return (Person)Proxy.newProxylnstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(), this);
	 }
	 //动态代理invoke⽅法
	 public Person invoke(Object proxy, Method method, Object[] args) throws Throwable {
		 //被代理⽅法前执⾏
		 System.out.println("JDKDynamicProxy do something before!");
		 //执⾏被代理的⽅法
		 Person result = (Person) method.invoke(target, args);
		 //被代理⽅法后执⾏
		 System.out.println("JDKDynamicProxy do something after!"); 
		return result;
 }

/**
* JDK动态代理测试
*/
public class JDKDynamicTest {
 public static void main(String[] args) {
	 System.out.println("不使⽤代理类，调⽤doSomething⽅法。");
	 //不使⽤代理类
	 Person person = new Bob();
	 // 调⽤ doSomething ⽅法
	 person.doSomething();
	 System.out.println("分割线-----------");
	 System.out.println("使⽤代理类，调⽤doSomething⽅法。");
	 //获取代理类
	 Person proxyPerson = new JDKDynamicProxy(new Bob()).getTarget();
	 // 调⽤ doSomething ⽅法 proxyPerson.doSomething();
 }
}