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

    }

}

巴特西

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

最新文章

热门文章