Java中常见的集中设计模式

Java中常见的几种设计模式

单例模式

​ 饿汉式、懒汉式、枚举

public class Hungry{
	// 构造器私有
		private Hungry(){
		
		}
		
		private final static Hungry HUNGRY = new Hungry();
		public static Hungry getInstance(){
			return HUNGRY;
		}
}

public class LazyMan{
    // 构造器私有化
	private LazyMan(){
	
	}
	private volatile static LazyMan lazyman;
	
    // 双重检测dcl模式
	public static LazyMan getInstance(){
        if(lazyman==null){
            synchronized(LazyMan.class){
                if(lazyMan == null){
                    LazyMan lazyman = new LazyMan();
                	// 因为new对象操作本身不是一个原子性操作:
					/**
					1.分配内存空间
					2.执行构造方法，初始化对象
					3.将对象指向这个空间
					**/
                }
            }
        }
		return LazyMan;
    }
}

单例不安全，存在反射，使用枚举类

public enum EnumSingle{
	// 默认私有无参构造
    Instance;
    
    public EnumSingle getInstance(){
        return Instance;
    }
    
    EnumSingle instance1 = EnumSingle.Instance;
    EnumSingle instance2 = EnumSingle.Instance;
}

工厂模式

简单工厂模式：一个抽象的接口，多个抽象接口的实现类，一个工厂类，用来实例化抽象的接口

// 抽象产品类
abstract class phone{
	public void play();
    public void stop();
}

// 具体实现类
class Huawei implements phone(){
	public void play(){
        sys("玩华为手机");
    }
    public void stop(){
        sys("华为关机");
    }
}

class Xiaomi implements phone(){
	public void play(){
        sys("玩小米手机");
    }
    public void stop(){
        sys("小米关机");
    }
}

// 工厂类
class Factory{
    public static phone getPhone(String type){
        Phone phone = null;
        if("Huawei".equals(type)){
            phone = new Huawei();
        }
        if("Xiaomi".equals(type)){
            phone = new Xiaomi();
        }
        return phone;
    }
}

// 简单测试
class Test{
    public static void main(String[] args){
        Phone p = Factory.getPhone("Huawei");
        if(p!=null){
            p.play();
            p.stop();
        }else{
            sys("你的手机造不出来力")
        }
    }
}

工厂方式：针对一个产品等级结构，一个抽象产品类，可以派生出多个具体产品类，每个具体工厂类只能创建一个具体产品类的实例

抽象工程模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类

​ 面向的是产品族，是工厂的工厂类，每个具体工厂类可以创建多个具体产品类的实例

// 抽象工厂类
abstract class AbstractFactory{
	public abstract Phone createPhone();
    public abstract Wifi createWifi();
    public abstract Car createCar();
}

// 具体工厂类，其中Phone，Wifi，Car是抽象类
public class DefaultFactory extends AbstractFactory{
    @Override
    public Phone createPhone(){
        return new Huawei();
    }
    @Override
    public Car createCar(){
        return new Benz();
    }
    ...
}

public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Phone p = f.createPhone();
        p.play();
        Car c = f.createCar();
        c.run();
        ...
    }
}

观察者模式

对象之间一对多的依赖关系，一个对象状态发生改变的时候，所以依赖与它的对象都将得到通知并自动更新。例如安卓的Listener就使用到了这一设计模式，只要用户对手机进行操作，对应的listener就会收到被通知，做出响应处理。

装饰者模式

对已有的业务逻辑进一步的封装，使其增加额外的功能