设计模式学习笔记(一)之工厂模式、单例模式

一、工厂模式

(1)简单工厂模式：

public interface IProduct {

    public void saleProduct();

}

创建一个产品接口，有一个卖产品的方法。

public class ProductA implements IProduct{

    public void saleProduct(){
        System.out.println("汉堡");
    }
}

产品A实现产品接口，卖汉堡。

public class ProductB implements IProduct {

    @Override
    public void saleProduct() {
        // TODO Auto-generated method stub
        System.out.println("薯条");
    }

}

产品B实现产品接口，卖薯条。

public class Creator {

    public IProduct createFactory(int i){
        switch(i){
            case 1:
                return new ProductA();
            case 2:
                return new ProductB();
            default:
                return null;
        }        
    }
    
}

创造者是简单工厂模式的核心：返回值类型是IProduct接口，通过测试类传来的形参确定返回哪个对象。

public class TestProduct {

    public static void main(String[] args) {
        Creator c=new Creator();
        c.createFactory(2).saleProduct();
    }
}

测试类：输出薯条。

(2)方法工厂模式：

(图片来自于网络)

public interface Light {

    public void TurnOn();
    public void TurnOff();
}

创建一个产品接口。

public class TubeLight implements Light {

    @Override
    public void TurnOn() {
        // TODO Auto-generated method stub
        System.out.println("rabbit1");
    }

    @Override
    public void TurnOff() {
        // TODO Auto-generated method stub

    }

}

public class BulbLight implements Light {

    @Override
    public void TurnOn() {
        // TODO Auto-generated method stub
        System.out.println("rabbit2");
    }

    @Override
    public void TurnOff() {
        // TODO Auto-generated method stub

    }

}

分别有两个产品类实现这个接口。

public interface Creator {

    public Light factory();
4     
5 }

创建工厂接口，返回值是产品接口。

public class TubeCreator implements Creator{

    @Override
    public Light factory() {
        // TODO Auto-generated method stub
        return new TubeLight();
    }

}

 

public class BulbCreator implements Creator {

    @Override
    public Light factory() {
        // TODO Auto-generated method stub
        return new BulbLight();
    }

}

工厂类实现工厂接口，返回与该工厂对应产品的对象。

public class Client {
    public static void main(String[] args) {
        
        Creator create=new BulbCreator();
        Light bulblight=create.factory();
        bulblight.TurnOn();
        
        Creator create1=new TubeCreator();
        Light tubelight=create1.factory();
        tubelight.TurnOn();
    }
    
    
}

顾客来卖东西了：通过工厂类来生产产品。

(3)抽象工厂模式：

public abstract class AbstractProductA {

    public abstract void show();
}

public abstract class AbstractProductB {
    public abstract void show();
}

创建两个抽象产品A,B.

public class ProductA extends AbstractProductA{

    @Override
    public void show() {
        // TODO Auto-generated method stub
        System.out.println("A");
    }

    
}

public class ProductB extends AbstractProductB{

    @Override
    public void show() {
        // TODO Auto-generated method stub
        System.out.println("B");
    }

}

两个具体的产品分别继承了它们。

public interface AbstractFactory {

    public AbstractProductA createProductA();
    
    public AbstractProductB createProductB();
}

抽象工厂里有两个方法，返回值分别是抽象产品A,抽象产品B.

public class ConcreteFactory implements AbstractFactory{

    @Override
    public ProductA createProductA() {
        // TODO Auto-generated method stub
        return new ProductA();
    }

    @Override
    public ProductB createProductB() {
        // TODO Auto-generated method stub
        return new ProductB();
    }

}

具体的工厂实现了抽象工厂接口。注意：这里的返回值类型不是AbstractProductA 和AbstractProductB。而是它们的儿子ProductA 和 ProductB。 

public class Test {

    public static void main(String[] args) {
        ConcreteFactory f1=new ConcreteFactory();
        ProductA a=f1.createProductA();
        a.show();
        
        ConcreteFactory f2=new ConcreteFactory();
        ProductB b=f2.createProductB();
        b.show();
    }
}

测试类：工厂生产产品。

 

二、单例模式的四种写法：

(1)

public class Single1 {
//不支持多线程
    private Single1(){
        
    }
    private static Single1 me;
    public static Single1 getInStance(){
        if(me==null){
            me=new Single1();
        }
        return me;
    }
    
}

 

(2)

public class Single2 {
//支持多线程，效率低。
    private Single2(){
        
    }
    private static Single2 me; 
    public static synchronized Single2 getInStance(){
        if(me==null){
            me=new Single2();
        }    
        return me;
    }
    
}

(3)

public class Single3 {

    private Single3(){
        
    }
    private static class SingletonHolder{
        private static final Single3 me=new Single3();
    } 
    
    public static final Single3 getInStance(){
        
        return SingletonHolder.me;
    }    
}

(4)

public class Single4 {

    private Single4(){
        
    }
    private volatile static Single4 me;
    
    public static Single4 getInStance(){
        if(me==null){
            synchronized(Single4.class){
                if(me==null){
                    me=new Single4();
                }
            }
        }
        return me;
    }
    
}

 

 本贴纯属个人的学习和理解，如有错误望各位大神指正。