java设计模式----工厂设计模式

　　 1.面向对象设计的基本原则

　　2.简单工厂模式

　　3.工厂方法模式

　　4.抽象工厂模式

　　工厂设计模式的核心本质：

　　1、实例化对象，用工厂方法代替new操作。

　　2、将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

一、面向对象设计的基本原则

　　1.OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。

　　2.DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程不要针对实现编程。

　　3.LoD（迪米特法则，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。

二、简单工厂模式

　　如果不使用工厂设计模式来创建对象，那么我们的程序将与多个类打交道。但是如果我们使用工厂设计模式的话，程序则不会与多个类有交集。

一下是不使用工厂设计模式类的关系图与Demo：

package com.demo.simpleFactory;
/**
 *动物接口
 */
public interface Animal {
    void sleep();
}

Alimal接口

 1 package com.demo.simpleFactory;
 2
 3 public class Cat implements Animal{
 4
 5     @Override
 6     public void sleep() {
 7         System.out.println("猫在睡觉");
 8     }
 9
10 }

Cat类

 1 package com.demo.simpleFactory;
 2
 3 public class Dog implements Animal{
 4
 5     @Override
 6     public void sleep() {
 7         System.out.println("狗在睡觉");
 8     }
 9
10 }

Dog类

 1 package com.demo.simpleFactory;
 2
 3 public class Client {
 4     public static void main(String[] args) {
 5         Animal a = new Dog();
 6         Animal a1 = new Cat();
 7         a.sleep();
 8         a1.sleep();
 9     }
10 }

Client使用者类

　　使用简单工厂模式则是创建一个工厂，使用者使用的时候只需要在工厂类中拿对象。

 1 package com.demo.simpleFactory;
 2
 3 /**
 4  * 工厂类
 5  * @author Administrator
 6  *
 7  */
 8 public class SimpleFactory {
 9     public static Animal createAnimal(String animal){
10         if("狗".equals(animal)){
11             return new Dog();
12         }else if("猫".equals(animal)){
13             return new Cat();
14         }else{
15             return null;
16         }
17     }
18 }

SimpleFactory简单工厂类

　　另一种写法：

 1 package com.demo.simpleFactory;
 2
 3 /**
 4  * 工厂类
 5  * @author Administrator
 6  *
 7  */
 8 public class SimpleFactory {
 9     public static Animal createDog(){
10             return new Dog();
11     }
12     public static Animal createCat(){
13         return new Cat();
14     }
15 }

SimpleFactory简单工厂类

　　使用者则可以通过如下方法创建对象：

package com.demo.simpleFactory;
/**
 * 使用者通过调用工厂创建对象
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        Animal a1 = SimpleFactory.createAnimal("狗");
        Animal a2 = SimpleFactory.createAnimal("猫");
        a1.sleep();
        a2.sleep();
    }
}

　　使用工厂模式创建对象的类依赖图如下：

三、工厂方法模式

　　在以上的工厂模式中，设计原理是违反面向对象基本原则的OCP原则的，我们需要将重新设计这个工厂方法模式。

以下是重新设计的工厂模式图解与Demo：

1 package com.demo.simpleFactory;
2 /**
3  * 工厂方法模式抽象类
4  * @author Administrator
5  *
6  */
7 public interface AnimalFactory {
8     Animal createAnimal();
9 }

工厂抽象类

 1 package com.demo.simpleFactory;
 2
 3
 4 public class CatFactory implements AnimalFactory{
 5
 6     @Override
 7     public Animal createAnimal() {
 8         return new Cat();
 9     }
10
11 }

Cat工厂

 1 package com.demo.simpleFactory;
 2
 3 public class Dog implements Animal{
 4
 5     @Override
 6     public void sleep() {
 7         System.out.println("狗在睡觉");
 8     }
 9
10 }

Dog工厂

 1 package com.demo.simpleFactory;
 2 /**
 3  * 使用者通过调用工厂创建对象
 4  * @author Administrator
 5  *
 6  */
 7 public class Client {
 8     public static void main(String[] args) {
 9         Animal cat = new CatFactory().createAnimal();
10         Animal dog = new DogFactory().createAnimal();
11         cat.sleep();
12         dog.sleep();
13     }
14 }

Client使用者

四、抽象工厂模式

　　抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

　　作用：用来生产不同产品族的全部产品，不能增加新的产品，但支持产品族。

　　抽象工厂模式的简单实现：

软件包结构如下：

package com.demo.abstractFactory.spare;
/**
 * 引擎接口
 * @author Administrator
 *
 */
public interface Engine {
    void run();
}

Engine接口

package com.demo.abstractFactory.spare;
/**
 * 座椅接口
 * @author Administrator
 *
 */
public interface Seat {
    void feel();
}

Seat接口

package com.demo.abstractFactory.spare;
/**
 * 轮胎接口
 * @author Administrator
 *
 */
public interface Tyre {
    void quality();
}

Tyre接口

package com.demo.abstractFactory.factory;

import com.demo.abstractFactory.spare.Engine;
import com.demo.abstractFactory.spare.Seat;
import com.demo.abstractFactory.spare.Tyre;
/**
 * 汽车工厂
 * @author Administrator
 *
 */
public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

CarFactory接口

package com.demo.abstractFactory.product;

import com.demo.abstractFactory.spare.Engine;

public class LowEngine implements Engine{

    @Override
    public void run() {
        System.out.println("汽车跑得慢");
    }

}
 package com.demo.abstractFactory.product;

import com.demo.abstractFactory.spare.Seat;

public class LowSeat implements Seat{

    @Override
    public void feel() {
        System.out.println("座椅没按摩功能");
    }

}
package com.demo.abstractFactory.product;

import com.demo.abstractFactory.spare.Tyre;

public class LowTyre implements Tyre{

    @Override
    public void quality() {
        System.out.println("轮胎易磨损");
    }

}
package com.demo.abstractFactory.product;

import com.demo.abstractFactory.spare.Engine;

public class LuxuryEngine implements Engine{

    @Override
    public void run() {
        System.out.println("汽车跑得快");
    }

}
package com.demo.abstractFactory.product;

import com.demo.abstractFactory.spare.Seat;

public class LuxurySeat implements Seat{

    @Override
    public void feel() {
        System.out.println("座椅有按摩功能");
    }

}
package com.demo.abstractFactory.product;

import com.demo.abstractFactory.spare.Tyre;

public class LuxuryTyre implements Tyre{

    @Override
    public void quality() {
        System.out.println("轮胎耐磨损");
    }

}

产品实现类

package com.demo.abstractFactory.factory;

import com.demo.abstractFactory.product.LuxuryEngine;
import com.demo.abstractFactory.product.LuxurySeat;
import com.demo.abstractFactory.product.LuxuryTyre;
import com.demo.abstractFactory.spare.Engine;
import com.demo.abstractFactory.spare.Seat;
import com.demo.abstractFactory.spare.Tyre;

public class LuxuryCarFactory implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }

}

高级工厂类

package com.demo.abstractFactory.factory;

import com.demo.abstractFactory.product.LowEngine;
import com.demo.abstractFactory.product.LowSeat;
import com.demo.abstractFactory.product.LowTyre;
import com.demo.abstractFactory.spare.Engine;
import com.demo.abstractFactory.spare.Seat;
import com.demo.abstractFactory.spare.Tyre;

public class LowCarFactory implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }

}

低级工厂类

package com.demo.abstractFactory;

import com.demo.abstractFactory.factory.CarFactory;
import com.demo.abstractFactory.factory.LowCarFactory;
import com.demo.abstractFactory.factory.LuxuryCarFactory;

public class Client {
    public static void main(String[] args) {
        CarFactory lowCarFactory = new LowCarFactory();
        CarFactory luxuryCarFactory = new LuxuryCarFactory();
        lowCarFactory.createEngine().run();
        lowCarFactory.createSeat().feel();
        luxuryCarFactory.createTyre().quality();
    }
}

客户端实现类

原文地址：https://www.cnblogs.com/bananafish/p/9947504.html

时间： 2024-10-05 06:12:05

java设计模式----工厂设计模式的相关文章

php设计模式-工厂设计模式

概念: 工厂设计模式提供获取某个对象的新实例的一个接口,同时使调用代码避免确定实际实例化基类步骤. 很多高级模式都是依赖于工厂模式. 原文地址:https://www.cnblogs.com/sjhsszl/p/8729217.html

工厂设计设计模式的分类: 工厂模式在<Java与模式>中分为三类: 1)简单工厂模式(Simple Factory):不利于产生系列产品: 2)工厂方法模式(Factory Method):又称为多形性工厂: 3)抽象工厂模式(Abstract Factory):又称为工具箱,产生产品族,但不利于产生新的产品: 这三种模式从上到下逐步抽象,并且更具一般性. GOF在<设计模式>一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract F

java--面向对象--设计模式--工厂模式

今天第一次接触Java的工厂设计模式,我可是闻名已久啊. 看下面: Java代码 interface Fruit { public void eat(); } class Apple implements Fruit { public void eat() { System.out.println("吃苹果"); } } class Orange implements Fruit { public void eat() { System.out.println("吃桔子&

接口和工厂设计模式

接口又是怎么一回事呢 ?接口就是一组规范 ,是在定义一种标准 .这说起来真的挺别扭的 ,我是这么理解的 ,当我们的抽象类全是抽象方法时 ,我们就可以定义接口了 ,那为什么不能继续用抽象类来表示而要定义一个接口呢 ?由于 Java 本身有单继承的局限 ,而接口是可以多实现的 .所以我就额外定义一个 interface 来表示哪些全是抽象方法的类 .相比于抽象类 ,我们可以感受出 Java 设计的初衷 ,抽象类是作为模板使用 ,对部分方法进行抽象 ,而接口更多的是对行为或是方法的抽象 . 那接口用什

设计模式Java之工厂方法。

1,工厂方法: 使用一个工厂的方法来创建产品. 1 package WHP; 2 //产品依赖于抽象 3 public interface IRunable { 4 public void Run(); 5 } 1 package WHP; 2 //具体实现 3 public class Car implements IRunable { 4 public void Run(){ 5 System.out.println("Car running."); 6 } 7 } 1 packa

Java 工厂设计模式

//使用new关键字创建对象的缺点是耦合度太高,工厂设计模式利用Java的反射机制来实例化对象降低了这种耦合度 package cn.buaa; import java.util.Date; interface Fruit{ public void eat(); } class Apple implements Fruit{ @Override public void eat() { System.out.println("吃苹果"); } } class Orang

JAVA学习笔记-----设计模式之工厂模式

1.设计模式---------->工厂模式: Sender.java package me.ele.mytest; public interface Sender { public void send(); } 2.MailSend package me.ele.mytest; public class MailSend implements Sender { @Override public void send() { System.out.pr

Java代码实现设计模式之工厂模式

工厂设计模式:为了解耦合,把对象的创建者与对象的使用者分开. 生活中:批量生产产品 Java中:批量生产对象分工: 把生产(创建)对象与使用对象分开了,解耦合 1.简单工厂模式优点:代码比较简洁缺点:如果增加新的产品类型,需要修改工厂类违反了面向对象的一个开发原则:对扩展开放,对修改关闭 2.工厂方法模式 (1)为了生产对象与使用对象分开 (2)如果增加新产品,就不需要修改原来的工厂类优点:遵循了增加新产品,不修改原来的类的原则, 缺点:类太多了示例:简单工厂模式 class Sim

java设计模式之工厂设计模式（Factory）

设计模式根据使用类型可以分为三种:1. 创建模式: Factory (工厂模式). Singleton (单态). Builder ( (建造者模式). Prototype ( (原型模式).工厂方法模式. 2. 结构模式: Flyweight ( (共享模式). Bridge ( (桥模式). Decorator ( (装饰模式). Composite ( (组合模式). Adapter (适配器模式). Proxy ( (代理模式). Facade ( (外观模式). 3. 行为模式: It