设计模式简单举例

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();
 }
}