单例模式和工厂模式

单例模式：

实现思路：将构造方法私有化  声明本类类型的静态私有属性   提供共有静态方法获取 本类对象 

 饿汉模式：

class xxx{
    private xxx(){}
    static xxx x=new xxx();
    public static xxx getxxx(){
        return x;
    }
}

懒汉模式：

class xxx{
    private xxx(){}
    static xxx x = null;
    public static xxx getxxx(){
        if(x!=null) return x;
        return new xxx();
    }
}

优点：

•  减少对内存的开销  特别是频繁的创建和销毁对象
• 避免对内存的过多占用   

缺点：

• 没有抽象层继承和扩展很难
• 违背了的单一执行原则  一个类只关注内部关系 忽略了外部关系
• 不适用与变化对象（既需要对对象的属性进行修改的类型）
• 滥用单例会出现一些负面问题，如为节省资源将数据库连接池对象设计为单例，可能会导致共享连接池对象对程序过多而出现连接池溢出。如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这样将导致对象状态丢失。

工厂模式：

简单工厂

代码：

//产品接口

public interface ProduceInterface {
    void say();
}

//产品类——1
public class ProduceClass_1 implements  ProduceInterface {
    @Override
    public void say() {
        System.out.println("1111111111111111111111111111");
    }
}
//产品类——2
public class ProduceClass_2 implements  ProduceInterface {
    @Override
    public void say() {
        System.out.println("22222222222222222222");
    }
}

//工厂类
public class Factoty_1 {
    public static ProduceInterface getProduce(String name){
        switch (name){
            case "1":return new ProduceClass_1();
            case "2":return new ProduceClass_2();
            case "3":return new ProduceClass_3();
            default:return null;
        }

    }
}


//测试代码
public class Test_1 {
    public static void main(String[] args) {
        ProduceInterface produce = Factoty_1.getProduce("2");
        produce.say();
    }
}

 

优点：通过工厂对产品进行加工和生产   对细节进行隐藏 

缺点：如果需要生产新的产品 需要修改源码  代码耦合度高  不符合开闭原则 

 

工厂方法：

代码：

沿用上面的产品类




//工厂借口
public interface FactoryInterface {
    public  ProduceInterface createProduce();
}
//工厂类——1

public class FactoryClass_1 implements FactoryInterface {
    @Override
    public ProduceInterface createProduce() {
        return new ProduceClass_1();
    }
}

//工厂类-2
public class FactoryClass_2 implements FactoryInterface {
    @Override
    public ProduceInterface createProduce() {
        return new ProduceClass_2();
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        FactoryClass_1 factoryClass_1 = new FactoryClass_1();
        ProduceInterface produce = factoryClass_1.createProduce();
        produce.say();

    }
}

 

优点（和简单工厂比改善的地方）：可扩展性变好了  需要增加产品时 不需要修改源码  只需要通过实现工厂接口去添加工厂类 符合设计原则中的开闭原则  同时又保持了对对象创建过程的封装

缺点：增加一种产品就需要增加一种工厂 增加了开发时间成本

抽象工厂

代码：  

//产品接口
public interface ElectricKettle {
    public void function();
}
//具体产品类----1
 public class ElectricKettleClass_1 implements ElectricKettle{
    @Override
    public void function() {
        System.out.println("美的电水壶");
    }
}
//具体产品类-------2
public class ElectricKettleClass_2 implements ElectricKettle{
    @Override
    public void function() {
        System.out.println("海尔电水壶");
    }
}
//抽象工厂接口
public interface FactoryInterfacer {
    public ElectricLamp  createLamp();
    public ElectricKettle  createKettle();
    public refrigerator  createRefrigerator();
}
//具体工厂--------1
package com.briup.base.factory._3;

public class _1Factory implements  FactoryInterfacer{

    @Override
    public ElectricLamp createLamp() {
        System.out.println("美的台灯  美的一批");

        return new ElectricLampClass_1();
    }

    @Override
    public ElectricKettle createKettle() {
        System.out.println("美的电水壶  美的一批");
        return new ElectricKettleClass_1();
    }

    @Override
    public refrigerator createRefrigerator() {
        System.out.println("美的冰箱  美的一批");
        return new refrigeratorClass_1();
    }
}


//具体工厂----------2
package com.briup.base.factory._3;

public class _2Factory implements  FactoryInterfacer{

    @Override
    public ElectricLamp createLamp() {
        System.out.println("海尔台灯  好用的一批");

        return new ElectricLampClass_2();
    }

    @Override
    public ElectricKettle createKettle() {
        System.out.println("海尔电水壶  好用的一批");
        return new ElectricKettleClass_2();
    }

    @Override
    public refrigerator createRefrigerator() {
        System.out.println("海尔冰箱  好用的一批");
        return new refrigeratorClass_2();
    }
}


//客户端代码
package com.briup.base.factory._3;

public class Client {
    public static void main(String[] args) {
        _1Factory factory1 = new _1Factory();
        _2Factory factory2 = new _2Factory();
        factory1.createLamp();
        factory2.createLamp();

    }
}

 

优点：和工厂方法相比 减少了工厂类的个数  出现类产品组的概念    同一个工厂类中生产的产品属于一个产品组 （同一品牌下               的不同商品）

缺点：接口中的方法变多了  接口的隔离性自然也就变低了  实现接口后必须重写其中的所有方法 接口变得笨重 增加了类与类间            耦合度