设计模式简单举例

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();
 }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值