Java设计模式——工厂模式

来源：互联网发布：mac版pscc2017破解教程编辑：程序博客网时间：2024/05/17 16:44

工厂模式-单例及多例:http://www.cnblogs.com/shamgod/p/4586146.html

一、单例的作用是用于控制类的生成方式，而不让外部类任意new对象

1.Car.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.ArrayList;
import java.util.List;
 
public class Car {
 
    //私有化构造函数，防止被外部的类new
    private Car() {
    }
 
    private static Car car = new Car();                     //单例
    private static List<Car> cars = new ArrayList<Car>();   //多例，类似连接池
     
    public static Car getInstance() {
        return car;
    }
 
    public void run() {
        System.out.println("Car running...............");
    }
     
}

2.Test.java

1
2
3
4
5
6
7
8
9
10
11
public class Test {
     
    @org.junit.Test
    public void test() {
        Car car = Car.getInstance();
        car.run();
        Car car2 = Car.getInstance();
        System.out.println(car == car2);
        System.out.println(car.equals(car2));
    }
}

运行结果：

简单工厂--转自：http://www.cnblogs.com/shamgod/p/4586349.html

一、概述

1.目标：要控制任意类型交通工具的生产模式

2.目标有两层意思(1)任意类型 (2)生产模式，所以对应的，要这两个层面上抽象(Movable,VehicleFactory)，利用接口，实现多态

二、类结构

1.Interface Movable.java

2.Car.java

3.Plane.java

4.Interface VehicleFactory.java

5.CarFactory.java

6.PlaneFactory.java

三、代码

1.Movable.java

1
2
3
public interface Movable {
    void run();
}

2.Car.java

1
2
3
4
5
6
7
8
9
10
public class Car implements Movable {
 
    public Car() {
    }
 
    public void run() {
        System.out.println("Car running...............");
    }
     
}

3.Plane.java

1
2
3
4
5
6
7
8
public class Plane implements Movable {
 
    @Override
    public void run() {
        System.out.println("飞机飞翔中。。。。");
    }
 
}

4.VehicleFactory.java

1
2
3
public interface VehicleFactory {
    Movable create();
}

5.CarFactory.java

1
2
3
4
5
6
7
8
9
public class CarFactory implements VehicleFactory {
 
    private static Car car = new Car();
    @Override
    public Movable create() {
        return car;
    }
 
}

6.PlaneFactory.java

1
2
3
4
5
6
7
8
9
public class PlaneFactory implements VehicleFactory {
 
    private static Plane plane = new Plane();
    @Override
    public Movable create() {
        return plane;
    }
 
}

7.Test.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Test {
     
    @org.junit.Test
    public void test() {
        VehicleFactory factory = new CarFactory();
        Movable m1 = factory.create();
        m1.run();
         
        Movable m2 = factory.create();
        System.out.println(m1 == m2);
        System.out.println(m1.equals(m2));
         
        System.out.println("******************************");
         
        factory = new PlaneFactory();
        m1 = factory.create();
        m1.run();
         
        m2 = factory.create();
        System.out.println(m1 == m2);
        System.out.println(m1.equals(m2));
    }
}

8.测试结果

抽象工厂——http://www.cnblogs.com/shamgod/p/4586720.html

一、概述

1.抽象工厂：当情况是需要产生一系列产品，若需更换产品，则要求一系列产品一起换，且要控制一系列产品的产生过程，此时可考虑抽象工厂模式。例：小明装修屋子，把电视、冰箱都替换掉，他这次需要把电视、冰箱换成三星的，下次装修可能要换成海尔的。此时可设计抽象类Telveison及Fridge负责产生产品,抽象工厂AbstractFactory负责产生一系列产品

PS:抽象工厂与普通工厂各自的优缺点：

(1)普通工厂容易在产品维度进行扩展，但产生系列产品时不方便，且易造成工厂类泛滥

(2)抽象工厂增加新产品时，要修改AbstractFactory等多处地方

二、类结构

1.Televison.java

2.Fridge.java

3.SamsumgTelevison.java

4.SamsungFridge.java

5.HaierTevevison.java

6.HaierFridge.java

7.AbstractFactory.java

8.SamsungFactory.java

9.HaierFactory.java