JAVA-----23种设计模式之-----工厂模式

最新推荐文章于 2024-07-11 19:47:25 发布

HNU的小萌

最新推荐文章于 2024-07-11 19:47:25 发布

阅读量197

点赞数 2

文章标签：设计模式 java

本文链接：https://blog.csdn.net/weixin_45761055/article/details/115558912

版权

1.23种模式简介

创建型模式：
– 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。
结构型模式：
–适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
行为型模式：
– 模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

2.工厂模式

2.1工厂模式：
实现了创建者和调用者的分离。
     – 详细分类：
              • 简单工厂模式: 用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
              • 工厂方法模式:用来生产同一等级结构中的固定产品。（支持增加任意产品）
              • 抽象工厂模式:用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
2.2核心本质：
    – 实例化对象，用工厂方法代替new操作。
    – 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

3.简单工厂模式

要点：
– 简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法,通过接收的参数的不同来返回不同的对象实例。
– 对于增加新产品无能为力！不修改代码的话，是无法扩展的。

public class CarFactory {
		public static Car createCar(String type){
			Car c = null;
			if("奥迪".equals(type)){
				c  = new Audi();
			}else if("奔驰".equals(type)){
				c = new Benz();
			}
			return c;
		}
}
public class CarFactory {
	public static Car createAudi(){
		return new Audi();
	}
	public static Car createBenz(){
		return new Benz();
	}
}

4.工厂方法模式

要点：工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

题目：创建一个Cycle接口及其Unicycle、Bicycle和Tricycle实现。对每种类型的Cycle都创建相应的工厂，然后编写代码使用这些工厂。工厂产生的对象能够被管理，可以输出当前产生的对象总数。
代码：

package homework.home2;

import java.util.Random;

/**
 * @ClassName: Client
 * @Description: TODO
 * @Author a fish who is lonely
 * @Date: 2021/4/9 15:21
 * @QQ号：1929618793
 * @Version 1.0
 */

public class Client {
    public static void main(String[] args) {

        Random r = new Random();
        UnicycleFactory unicycleFactory = new UnicycleFactory();
        BicycleFactory bicycleFactory = new BicycleFactory();
        TricycleFactory tricycleFactory = new TricycleFactory();
        //随机产生不同的对象一定的数量，直接new也行，方式不一样
        for (int i = 0; i <100; i++) {
            int random=r.nextInt(100);
            switch (random%3){
                case 0:unicycleFactory.createCycle();break;
                case 1:bicycleFactory.createCycle();break;
                case 2:tricycleFactory.createCycle();break;
                default:
            }
        }
        try {
            //反射获取三个类的对象
            Unicycle unicycle = Unicycle.class.getDeclaredConstructor().newInstance();
            Bicycle bicycle = Bicycle.class.getDeclaredConstructor().newInstance();
            Tricycle tricycle = Tricycle.class.getDeclaredConstructor().newInstance();
            unicycle.count() ;
            bicycle.count() ;
            tricycle.count() ;
            //总共的对象数量为103个
            System.out.println("合计各个Cycle对象的数量为:" + (Unicycle.getCountUnicycle() + Bicycle.getCountBicycle() + Tricycle.getCountTricycle()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

interface Cycle{
    void count();
}
class Unicycle implements Cycle{
   private  static int countUnicycle=0;
   public Unicycle(){
       countUnicycle++;
   }
    @Override
    public void count() {
        System.out.println("Unicycle对象当前数量："+countUnicycle);
    }

    public static int getCountUnicycle() {
        return countUnicycle;
    }
}
class Bicycle implements  Cycle{
    private  static int countBicycle=0;
    public Bicycle() {
        countBicycle++;
    }

    @Override
    public void count() {
        System.out.println("Bicycle对象当前数量："+countBicycle);
    }

    public static int getCountBicycle() {
        return countBicycle;
    }
}
class Tricycle implements  Cycle{
    private  static int countTricycle=0;

    public Tricycle() {
        countTricycle++;
    }

    @Override
    public void count() {
        System.out.println("Tricycle对象当前数量："+countTricycle);
    }

    public static int getCountTricycle() {
        return countTricycle;
    }
}


interface  CycleFactory{
    Cycle createCycle();
}

class  UnicycleFactory implements  CycleFactory{
    @Override
    public Cycle createCycle() {
        return  new Unicycle();
    }
}
class  BicycleFactory implements  CycleFactory{
    @Override
    public Cycle createCycle() {
        return  new Bicycle();
    }
}
class  TricycleFactory implements  CycleFactory{
    @Override
    public Cycle createCycle() {
        return  new Tricycle();
    }
}