8Java设计模式（持续更新）

1.单例模式（Singleton pattern）：

单例模式的实现方式是，一个类能返回对象的一个引用（永远是同一个）和一个得到该惟一实例的方法（必须是静态方法）。

饿汉式:

public class SingleTon {
public static SingleTon singleTon = new SingleTon();
private SingleTon(){
    
}
public static SingleTon getInstance(){
    return singleTon;
}
}

懒汉式：

public class SingleTon {
    public static SingleTon singleTon ;
    private SingleTon(){

    }
    public static SingleTon getInstance(){
        if(singleTon==null) singleTon = new SingleTon();
        return singleTon;
    }
}

2.工厂模式（Factory pattern）：

工厂一般是一个用来建立其余对象的对象。工厂模式根据不一样的参数来实现不一样的分配方案和建立对象。

工厂模式一般分为：

• 普通工厂模式
• 多个工厂方法模式
• 静态工厂方法模式

public class FactoryTest {
    public static void main(String[] args) {
        //普通工厂模式，有可能由于传入参数有误，形成建立对象失败。
        ProductFactory factory = new ProductFactory();
        Product p1 = factory.createProduct("product1");
        p1.A();//product1 calls A
        p1.B();//product1 calls B
        //多个工厂模式，缺点是须要建立工厂对象
        MultiProductFactory factory1 = new MultiProductFactory();
        Product2 p2 = factory1.createProduct2();
        p2.A();//product2 calls A
        p2.B();//product2 calls B
        //静态工厂模式，能够直接经过类方法得到对象实例
        Product1 p3 = StaticProductFactory.createProduct1();
        p3.A();//product1 calls A
        p3.B();//product1 calls B

    }

}
interface Product{
    void A();
    void B();
}
class Product1 implements Product{

    @Override
    public void A() {
        System.out.println("product1 calls A");
    }

    @Override
    public void B() {
        System.out.println("product1 calls B");
    }
}
class Product2 implements Product{

    @Override
    public void A() {
        System.out.println("product2 calls A");
    }

    @Override
    public void B() {
        System.out.println("product2 calls B");
    }
}
class ProductFactory{
    public Product createProduct(String casename){
        if(casename.equals("product1"))
            return new Product1();
       else if(casename.equals("product2"))
            return new Product2();
       else return null;
    }
}
class MultiProductFactory{
    public Product1 createProduct1(){
        return new Product1();
    }
    public Product2 createProduct2(){
        return new Product2();
    }
}
class StaticProductFactory{
    public static Product1 createProduct1(){
        return new Product1();
    }
    public static Product2 createProduct2(){
        return new Product2();
    }
}

 3.模板方法设计模式：

抽象类体现的是一种模板方法设计模式，抽象类中具备抽象方法，这些抽象方法让子类实现一些必要功能，还具备普通方法，这些方法提升了代码的复用性。子类再继承抽象类的基础上进行拓展，整体上保持抽象类的行为模式。

解决了让肯定功能在抽象类中实现，把不肯定的功能暴露给子类去实现。

public class TemplateTest {
    public static void main(String[] args) {
        Template temp = new SubTemplate();
        temp.getTime();//724毫秒
    }
}
abstract class  Template{
    public  void getTime(){
        long startTime= System.currentTimeMillis();
        code();
        System.out.println((System.currentTimeMillis()-startTime)+"毫秒");
    }
    public abstract  void code();
}
class SubTemplate extends Template{

    @Override
    public void code() {
        for(int i=0;i<100000;i++)
            System.out.println(i);
    }
}