创建型模式--工厂模式、抽象工厂、建筑者（一）

分手后的思念是犯贱 2022-04-24 01:58 211阅读 0赞

## 创建型模式涉及对象的实例化，特点是不让用户代码依赖于对象的创建或排列方式，避免用户直接使用new创建对象。 ##

## 设计模式的六大原则 ##

**开闭原则 :****对扩展开放，对修改关闭。(需要使用接口和抽象类)**

**里氏代换原则:****任何基类可以出现的地方，子类一定可以出现。(实现抽象化的具体步骤的规范，子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法)**

**依赖倒转原则:****针对接口编程，依赖于抽象而不依赖于具体。(降低依赖，降低耦合)**

**接口隔离原则:****使用多个隔离的接口，比使用单个接口要好。（很多功能接口，细化接口，接口中的方法尽量少）**

**迪米特法则:一个实体应当尽量少的与其他实体之间发生相互作用.**

**合成复用原则:****尽量使用合成/聚合的方式，而不是使用继承。**

**单一职责原则:****不要存在多于一个导致类变更的原因。(一个类、接口、方法只负责一项职责)**

**创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。**

**工厂模式好处：**可以降低程序的耦合性，为后期的维护修改提供了很大的便利。

**简单工厂模式:**根据外界给定的信息，决定究竟应该创建哪个具体类的对象。**(但是工厂的职责过重，而且当类型过多时不利于系统的扩展维护。)**

*  使用场景：负责创建的对象比较少。只关心传入参数类型，不关心对象逻辑。
 *  缺点：职责过重，新增加产品需要修改判断逻辑。违背开闭原则。
 *  使用例子：Calendar、Logger

public class BirdFactory {
    
        public Bird getBird(String type){
            if(type.equals("Parrot")){
                return new Parrot();
            }else if(type.equals("Ostrich")){
                return new Ostrich();
            }
            return null;
        }
    
        public static void main(String[] args) {
            BirdFactory birdFactory = new BirdFactory();
            Bird bird = birdFactory.getBird("Parrot");
            bird.call();
            bird.fly();
        }
    }

稍微优化（确定仍然明显）

public Bird getBirdClass(Class newClass){
            try {
                return (Bird)Class.forName(newClass.getName()).newInstance();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static void main(String[] args) {
            BirdFactory birdFactory = new BirdFactory();
            Bird bird = birdFactory.getBirdClass(Parrot.class);
            bird.call();
        }

**工厂方法模式：（**又称多态性工厂模式，将具体创建的工作交给子类去做**）**

*  适用场景：创建对象需要大量重复的代码。
 *  优点：加入新的产品符合开闭原则，提高可扩展性。
 *  缺点：类的个数过多，增加复杂度。增加了理解难度。
 *  实例：Collection->ArrayList

public static void main(String[] args) {
    		Car aodi = new AoDiFactory().createCar();
    		Car jili = new JiLiFactory().createCar();
    		aodi.run();
    		jili.run();
    	}

public class JiLiFactory implements CarFactory {
    
    	public Car createCar() {
    
    		return new JiLi();
    	}
    
    }
    public class AoDiFactory implements CarFactory {
    
    	public Car createCar() {
    	
    		return new AoDi();
    	}
    }

**抽象工厂模式：（**工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品。**）**

（感觉就是，多个工厂方法模式融合在了一起）

*     适用场景：应用层不依赖于具体创建、实现等细节。强调使用同一产品族，创建需要大量重复的代码。提供一个产品类的库，所有产品可以以相同接口出现。
 *  优点：具体代码在应用层隔离，无需关心创建细节。将一个系列产品统一在一起创建。
 *  缺点：规定了所有可能被创建的产品集合，扩展新的产品困难，需要修改抽象工程的接口。增加了抽象性和理解难度。

public static void main(String[] args) {
    		CarFactory carFactory=new JiLiFactory();
    		Engine engine=carFactory.createEngine();
    		engine.run();
    		engine.start();
    	}

public interface CarFactory {
    	// 创建发动机
    	Engine createEngine();
    	// 创建座椅
    	Chair createChair();
    }
    public class JiLiFactory implements CarFactory  {
    
    	public Engine createEngine() {
    	
    		return new EngineA();
    	}
    
    	public Chair createChair() {
    		
    		return new ChairA();
    	}
    
    }

class ChairA implements Chair{
    
    	public void run() {
    		System.out.println("可以自动加热!");
    	}
    	
    }
     class ChairB implements Chair{
    
    	public void run() {
    		System.out.println("不能加热!");
    	}
    	
    }

**工厂方法 ：用来生产同一等级结构中的固定产品。（支持拓展增加产品）   **

**抽象工厂 ：用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）**

### 建筑者模式 ###

*  定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
 *  适用场景：一个对象有非常复杂的内部结构（很多属性），想把复杂对象的创建和使用分离。
 *  优点：封装性好，创建和使用分离。扩展性好、建造类之间独立、一定程度上解耦。
 *  缺点：多余builder对象 产品内部发生变化，建造者都要修改，成本大。
 *  创建需要很多步奏时使用建造者模式，只需简单步奏时使用工厂模式。

public class GrayCat {
    
        private String name;
        private int age;
        private String kind;
        private String descript;
    
        public GrayCat(GrayCatBuilder catBuilder){
            this.name = catBuilder.name;
            this.age = catBuilder.age;
            this.kind = catBuilder.kind;
            this.descript = catBuilder.descript;
        }
    
        @Override
        public String toString() {
            return "GrayCat{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", kind='" + kind + '\'' +
                    ", descript='" + descript + '\'' +
                    '}';
        }
    
        public static GrayCatBuilder newBuilder(){
            return new GrayCatBuilder();
        }
    
        public static class GrayCatBuilder{
            private String name;
            private int age;
            private String kind;
            private String descript;
    
            public GrayCatBuilder setName(String name) {
                this.name = name;
                return this;
            }
    
            public GrayCatBuilder setAge(int age) {
                this.age = age;
                return this;
            }
    
            public GrayCatBuilder setKind(String kind) {
                this.kind = kind;
                return this;
            }
    
            public GrayCatBuilder setDescript(String descript) {
                this.descript = descript;
                return this;
            }
    
            public GrayCat build(){
                return new GrayCat(this);
            }
        }
    
        public static void main(String[] args) {
            GrayCat cat = GrayCat
                    .newBuilder()
                    .setAge(11)
                    .setDescript("可爱的灰猫")
                    .setKind("猫科")
                    .setName("马花花")
                    .build();
            System.out.println(cat.toString());
        }
    }

## ##