Singleton Pattern 和 Factory Pattern 的学习

最新推荐文章于 2024-07-17 13:40:39 发布

原创最新推荐文章于 2024-07-17 13:40:39 发布 · 326 阅读

0 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

1 篇文章

订阅专栏

Singleton Pattren 单例设计模式

单例设计模式通过将构造函数私有化，只允许创建唯一的一个实例对象，且无法自行创建其他实例对象，只能通过类提供的方法来访问类的实例对象

单例类的创建

class Singleton
{
    //构造函数私有化，不允许从类的外部创建其他的实例对象
    private Singleton(){}
    //创建这个类的实例对象
    private static Singleton demo = new Singleton();
    //用于返回这个类的唯一的一个实例对象demo
    public static Singleton getdemo(){
        return demo;
    }
    public void show(){
        System.out.println("demo");
    }
}

单例类的使用

public class Singletondemo
{
    public static void main(String args[]){
        //通过调用Singleton的类方法getdemo（）
        //a和b 指向Singleton类的同一个实例对象
        Singleton a = Singleton.getdemo();
        Singleton b = Singleton.getdemo();
        a.show();
        b.show();
        //如果a和b指向同一个实例对象，打印same
        if(a == b) 
            System.out.println("same");
    }
}

运行结果

demo
demo
same

a和b 指向了同一个实例对象

注意事项

1.单例类的构造函数为私有，不能从外部访问创建类的其他实例对象
2.因为构造函数私有，子类不能调用单例类的构造函数，所以单例类不能派生出子类

Factory Pattern 工厂设计模式

简单工厂模式

简单工厂模式又称为静态工厂方法模式，建立一个工厂类，通过不同的参数，构建并返回不同的产品（实例对象）

创建产品父类或者产品构造接口

abstract class product//可以用接口代替
{
    abstract void show();
}

创建具体的产品类

class productA extends product//继承上面的产品类
{
    public productA(){}
    //覆盖父类的show方法（或者是接口的方法）
    public void show(){
        System.out.println("This is A");
    }
}
class productB extends product//继承上面的产品类
{
    public productB(){}
    //覆盖父类的show方法（或者是接口的方法）
    public void show(){
        System.out.println("this is B");
    }
}

创建简单工厂类

class Factory
{
    //用于返回产品的方法，通过不同的参数，返回不同的产品
    public product getproduct(String s){
        if(s == "A")
            return new productA();
        else if(s == "B")
            return new productB();
        return null;
    }
}

简单工厂类使用实例

public class Factorydemo
{
    public static void main(String args[])
    {
        Factory factorydemo = new Factory();
        //通过工厂创建A产品
        product productdemo1 =  factorydemo.getproduct("A");
        //通过工厂创建B产品
        product productdemo2 =  factorydemo.getproduct("B");
        //调用A产品的方法
        productdemo1.show();
        //调用B产品的方法
        productdemo2.show();
    }
}

运行结果

This is A
this is B

工厂方法设计模式

工厂方法设计模式，更像是简单工厂设计模式中再细分下去，A产品对应A厂，B产品对应B厂，用户想要获取A产品，只需通过A厂直接获取即可，B产品同理

创建产品父类或者产品构造接口

abstract class product
{
    abstract void show();
}

创建工厂父类或者产品构造接口

abstract class factory
{
    abstract  product getproduct(); //返回产品
}

具体产品类

//继承产品父类的产品A 
class productA extends product
{
    public void show(){                  //方法覆盖
        System.out.println("this is A");
    }
}
//继承产品父类的产品B
class productB extends product
{
    public void show(){                  //方法覆盖
        System.out.println("this is B");
    }
}

具体工厂类

//继承工厂父类的工厂A
class factoryA extends factory
{
    public product getproduct(){            //方法覆盖
        return new productA();
    }
}
//继承工厂父类的工厂B
class factoryB extends factory
{
    public product getproduct(){            //方法覆盖
        return new productB();
    }
}

工厂方法实例使用

public class factoryABdemo
{
    public static void main(String args[]){
        //工厂A的实例
        factory factorydemo1 = new factoryA(); 
        //工厂B的实例
        factory factorydemo2 = new factoryB();
        //通过工厂A获取产品A
        product productdemo1 = factorydemo1.getproduct();
        //通过工厂A获取产品B
        product productdemo2 = factorydemo2.getproduct();
        //调用产品A的方法
        productdemo1.show();
        //调用产品B的方法
        productdemo2.show();

}

运行结果

this is A
this is B

小结

工厂方法设计模式中，用户不用知道对象的创建逻辑，只需调用对应的工厂的接口方法即可，扩展也很简单，只需要继承工厂父类，增加新的工厂类就可以了

抽象工厂设计模式

抽象工厂设计模式中，工厂不像工厂方法设计模式中的工厂，一个工厂只有一个产品，而是工厂有几条不同的产品线。就好比宝马牌汽车厂中又生产汽车和自行车，而奔驰牌汽车厂也生产汽车和自行车，不同的牌子的产品对应不同的工厂，而一个牌子的不同产品对应工厂内不同的生产线。

构建汽车和自行车父类

abstract class car
{
    abstract void show();
}
abstract class bike
{
    abstract void show();
}

构建工厂父类

abstract class factory
{
    //获取不同产品生产线的产品的方法
    abstract car getcar();
    abstract bike getbike();
}

构建具体的汽车和自行车类

class carBWM extends car
{
    public void show(){
        System.out.println("BWMcar");
    }
}
class bikeBWM extends bike
{
    public void show(){
        System.out.println("BWMbike");
    }

}
class carBenz extends car
{
    public void show(){
        System.out.println("Benzcar");
    }
}
class bikeBenz extends bike
{
    public void show(){
        System.out.println("Benzbike");
    }

}

构建具体的工厂类

//奔驰汽车厂
class factoryBenz extends factory
{
    //方法覆盖
    public car getcar(){
        return new carBenz();
    }
    public bike getbike(){
        return new bikeBenz();
    }
}
//宝马汽车厂
class factoryBWM extends factory
{
    //方法覆盖
    public car getcar(){
        return new carBWM();
    }
    public bike getbike(){
        return new bikeBWM();
    }
}

抽象工厂设计模式实例

public class carbikeFactory
{
    public static void main(String args[]){
        //构建宝马汽车厂的实例
        factory bwmfactory = new factoryBWM();
        //构建奔驰汽车厂的实例
        factory benzfactory = new factoryBenz();
        //获取奔驰自行车产品
        bike bikeBenz1 = benzfactory.getbike();
        //获取宝马自行车产品
        bike bikeBWM1 = bwmfactory.getbike();
        //获取宝马汽车产品
        car carBWM1 = bwmfactory.getcar();
        //获取奔驰汽车产品
        car carBenz1 = benzfactory.getcar();
        bikeBenz1.show();
        bikeBWM1.show();
        carBenz1.show();
        carBWM1.show();
    }
}