设计模式

单例

Runtime 类封装了 Java 运行时的环境。 每一个 java 程序实际上都是启动了一个 JVM 进程， 那么每个 JVM 进程都是对应这一个 Runtime 实例。

public class Singleton {
 
    private static Singleton singleton;
 
    private Singleton() {
    }
 
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

 

工厂方法

工厂设计模式是一种创建型模式，建立一个工厂来创建对象。把创建的过程封装到工厂里。

//抽象产品类
abstruct class BMW()
{
    public BMW();
}



// 具体产品类 宝马1系,2系
pubblic class BMW100 extends BMW
{
    public BMW100()
    {
        System.out.println("this is BMW100");
    }
}
pubblic class BMW200 extends BMW
{
    public BMW200()
    {
        System.out.println("this is BMW200");
    }
}



//抽象工厂角色
interface Factory
{
    BMW createBMW();
}


//具体工厂角色
public class FactoryBMW1 implements FactoryBMW{  

    @Override  
    public BMW100 createBMW() {  
        return new BMW100();  
    }  

}  
public class FactoryBMW2 implements FactoryBMW {  
    @Override  
    public BMW200 createBMW() {  

        return new BMW200();  
    }  
}   //分为100的工厂和200的工厂(省略了两个工厂)。都实现了工厂的接口

抽象工厂

抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个接口或者抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

//抽象产品类1 发动机以及型号    
public interface Engine {    

}    
//抽象产品类2 空调以及型号    
public interface Aircondition {    

}


//具体产品类
public class EngineA extends Engine{    
    public EngineA(){    
        System.out.println("制造-->EngineA");    
    }    
}    
public class EngineB extends Engine{    
    public EngineB(){    
        System.out.println("制造-->EngineB");    
    }    
}  

public class AirconditionA extends Aircondition{    
    public AirconditionA(){    
        System.out.println("制造-->AirconditionA");    
    }    
}    
public class AirconditionB extends Aircondition{    
    public AirconditionB(){    
        System.out.println("制造-->AirconditionB");    
    }    
}


//抽象工厂    
public interface AbstractFactory {    
    //制造发动机  
    public Engine createEngine();  
    //制造空调   
    public Aircondition createAircondition();   
} 




//具体工厂类  
public class 奔驰工厂 implements AbstractFactory{    

    @Override    
    public Engine createEngine() {      
        return new EngineA();    
    }    
    @Override    
    public Aircondition createAircondition() {    
        return new AirconditionA();    
    }    
}    
//为宝马车生产配件
public class 宝马工厂 implements AbstractFactory {    

     @Override    
    public Engine createEngine() {      
        return new EngineB();    
    }    
    @Override    
    public Aircondition createAircondition() {    
        return new AirconditionB();    
    }    
}

策略

与多态有着同样的思想，让算法move的变化独立于使用算法的客户

1.可以优化类结构,当类的某种功能有多种实现时,可以在类中定义策略接口,将真正的功能实现委托给具体的策略实现类。这样避免了类膨胀,也能更好的进行扩展和维护。

2.避免使用多重条件判断导致的硬编码和扩展性差的问题

3.可以使具体的算法实现自由切换,增强程序设计的弹性

public abstract class Car {

    //汽车品牌
    private String brand;

    public Car(String brand) {
        this.brand = brand;
    }

    public Car(String brand, MoveStrategy strategy) {
        this.brand = brand;
        this.moveStrategy=strategy;
    }

    //汽车的运行策略:使用汽油运行,使用电能运行等等
    private MoveStrategy moveStrategy;

    //运行方法
    public void move() {
        System.out.print(brand);
        moveStrategy.move();
    }

    public void setMoveStrategy(MoveStrategy moveStrategy) {
        this.moveStrategy = moveStrategy;
    }
}





public class GasolineMoveStrategy implements MoveStrategy{

    @Override
    public void move() {
        System.out.println(" Use Gasoline Move!");
    }
}





public class ElectricityMoveStrategy implements MoveStrategy {
    @Override
    public void move() {
        System.out.println(" Use Electricity Move!");
    }
}



public class TeslaCar extends Car {

    public TeslaCar(String brand) {
        super(brand,new ElectricityMoveStrategy());
    }
}



public class Client {

    public static void main(String[] args) {

        TeslaCar car = new TeslaCar("Tesla");

        car.move();

        car.setMoveStrategy(new GasolineMoveStrategy());

        car.move();
    }
}

 

观察者

对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并做出相应处理。

public static void main(String[] args){
    FileObserver observer = new FileObserver();
    FileListener listener = new FileListener();
    FileMonitor monitor = new FileMonitor(observer);
    observer.addListener(listener);
    monitor.start();
}

class FileMonitor{
    public void run() {
    while (running) {
      observer.checkAndNotify();
      if (!running) {
        break;
      }
      try {
        Thread.sleep(interval);
      }
    }
  }
}

class FileObserver {
    public static void checkAndNotify(){
        if(fileChanged) {
            listener.onFileChanged();
        }
    }
}

class FileListener {
    public static void onFileChanged(){
          Runtime.getRuntime().exec("kill 1");
    }
}

装饰者

对已有的业务逻辑进一步的封装，使其增加额外的功能，如java中的IO流就使用了装饰者模式，用户在使用的时候，可以任意组装，达到自己想要的效果。 

public class Food {
 
    private String food_name;
 
    public Food() {
    }
 
    public Food(String food_name) {
        this.food_name = food_name;
    }
 
    public String make() {
        return food_name;
    };
}

//面包类
public class Bread extends Food {
 
    private Food basic_food;
 
    public Bread(Food basic_food) {
        this.basic_food = basic_food;
    }
 
    public String make() {
        return basic_food.make()+"+面包";
    }
}
 
//奶油类
public class Cream extends Food {
 
    private Food basic_food;
 
    public Cream(Food basic_food) {
        this.basic_food = basic_food;
    }
 
    public String make() {
        return basic_food.make()+"+奶油";
    }
}
 
//蔬菜类
public class Vegetable extends Food {
 
    private Food basic_food;
 
    public Vegetable(Food basic_food) {
        this.basic_food = basic_food;
    }
 
    public String make() {
        return basic_food.make()+"+蔬菜";
    }
 
}

public class Test {
    public static void main(String[] args) {
        Food food = new Bread(new Vegetable(new Cream(new Food("香肠"))));
        System.out.println(food.make());
    }
}//输出香肠+奶油+蔬菜+面包