设计模式学习笔记(一)之工厂模式、单例模式

一、工厂模式

(1)简单工厂模式：

1 public interface IProduct {
2
3     public void saleProduct();
4
5 }

创建一个产品接口，有一个卖产品的方法。

1 public class ProductA implements IProduct{
2
3     public void saleProduct(){
4         System.out.println("汉堡");
5     }
6 }

产品A实现产品接口，卖汉堡。

1 public class ProductB implements IProduct {
2
3     @Override
4     public void saleProduct() {
5         // TODO Auto-generated method stub
6         System.out.println("薯条");
7     }
8
9 }

产品B实现产品接口，卖薯条。

 1 public class Creator {
 2
 3     public IProduct createFactory(int i){
 4         switch(i){
 5             case 1:
 6                 return new ProductA();
 7             case 2:
 8                 return new ProductB();
 9             default:
10                 return null;
11         }
12     }
13
14 }

创造者是简单工厂模式的核心：返回值类型是IProduct接口，通过测试类传来的形参确定返回哪个对象。

1 public class TestProduct {
2
3     public static void main(String[] args) {
4         Creator c=new Creator();
5         c.createFactory(2).saleProduct();
6     }
7 }

测试类：输出薯条。

(2)方法工厂模式：

(图片来自于网络)

1 public interface Light {
2
3     public void TurnOn();
4     public void TurnOff();
5 }

创建一个产品接口。

 1 public class TubeLight implements Light {
 2
 3     @Override
 4     public void TurnOn() {
 5         // TODO Auto-generated method stub
 6         System.out.println("rabbit1");
 7     }
 8
 9     @Override
10     public void TurnOff() {
11         // TODO Auto-generated method stub
12
13     }
14
15 }

 1 public class BulbLight implements Light {
 2
 3     @Override
 4     public void TurnOn() {
 5         // TODO Auto-generated method stub
 6         System.out.println("rabbit2");
 7     }
 8
 9     @Override
10     public void TurnOff() {
11         // TODO Auto-generated method stub
12
13     }
14
15 }

分别有两个产品类实现这个接口。

1 public interface Creator {
2
3     public Light factory();
4
5 }

创建工厂接口，返回值是产品接口。

1 public class TubeCreator implements Creator{
2
3     @Override
4     public Light factory() {
5         // TODO Auto-generated method stub
6         return new TubeLight();
7     }
8
9 }

1 public class BulbCreator implements Creator {
2
3     @Override
4     public Light factory() {
5         // TODO Auto-generated method stub
6         return new BulbLight();
7     }
8
9 }

工厂类实现工厂接口，返回与该工厂对应产品的对象。

 1 public class Client {
 2     public static void main(String[] args) {
 3
 4         Creator create=new BulbCreator();
 5         Light bulblight=create.factory();
 6         bulblight.TurnOn();
 7
 8         Creator create1=new TubeCreator();
 9         Light tubelight=create1.factory();
10         tubelight.TurnOn();
11     }
12
13
14 }

顾客来卖东西了：通过工厂类来生产产品。

(3)抽象工厂模式：

1 public abstract class AbstractProductA {
2
3     public abstract void show();
4 }

1 public abstract class AbstractProductB {
2     public abstract void show();
3 }

创建两个抽象产品A,B.

 1 public class ProductA extends AbstractProductA{
 2
 3     @Override
 4     public void show() {
 5         // TODO Auto-generated method stub
 6         System.out.println("A");
 7     }
 8
 9
10 }

1 public class ProductB extends AbstractProductB{
2
3     @Override
4     public void show() {
5         // TODO Auto-generated method stub
6         System.out.println("B");
7     }
8
9 }

两个具体的产品分别继承了它们。

1 public interface AbstractFactory {
2
3     public AbstractProductA createProductA();
4
5     public AbstractProductB createProductB();
6 }

抽象工厂里有两个方法，返回值分别是抽象产品A,抽象产品B.

 1 public class ConcreteFactory implements AbstractFactory{
 2
 3     @Override
 4     public ProductA createProductA() {
 5         // TODO Auto-generated method stub
 6         return new ProductA();
 7     }
 8
 9     @Override
10     public ProductB createProductB() {
11         // TODO Auto-generated method stub
12         return new ProductB();
13     }
14
15 }

具体的工厂实现了抽象工厂接口。注意：这里的返回值类型不是AbstractProductA 和AbstractProductB。而是它们的儿子ProductA 和 ProductB。

 1 public class Test {
 2
 3     public static void main(String[] args) {
 4         ConcreteFactory f1=new ConcreteFactory();
 5         ProductA a=f1.createProductA();
 6         a.show();
 7
 8         ConcreteFactory f2=new ConcreteFactory();
 9         ProductB b=f2.createProductB();
10         b.show();
11     }
12 }

测试类：工厂生产产品。

二、单例模式的四种写法：

(1)

 1 public class Single1 {
 2 //不支持多线程
 3     private Single1(){
 4
 5     }
 6     private static Single1 me;
 7     public static Single1 getInStance(){
 8         if(me==null){
 9             me=new Single1();
10         }
11         return me;
12     }
13
14 }

(2)

 1 public class Single2 {
 2 //支持多线程，效率低。
 3     private Single2(){
 4
 5     }
 6     private static Single2 me;
 7     public static synchronized Single2 getInStance(){
 8         if(me==null){
 9             me=new Single2();
10         }
11         return me;
12     }
13
14 }

(3)

 1 public class Single3 {
 2
 3     private Single3(){
 4
 5     }
 6     private static class SingletonHolder{
 7         private static final Single3 me=new Single3();
 8     }
 9
10     public static final Single3 getInStance(){
11
12         return SingletonHolder.me;
13     }
14 }

(4)

 1 public class Single4 {
 2
 3     private Single4(){
 4
 5     }
 6     private volatile static Single4 me;
 7
 8     public static Single4 getInStance(){
 9         if(me==null){
10             synchronized(Single4.class){
11                 if(me==null){
12                     me=new Single4();
13                 }
14             }
15         }
16         return me;
17     }
18
19 }

本贴纯属个人的学习和理解，如有错误望各位大神指正。

转载于:https://www.cnblogs.com/CZDblog/p/5532553.html

设计模式学习笔记(一)之工厂模式、单例模式相关推荐

大化设计模式学习笔记（简单工厂模式）
实质:生产具有相同逻辑的构造器类,也就是由一个工厂对象决定创建出哪一种产品类的实例案例:计算器 demo见https://github.com/mrjdrs/sign-model.git
设计模式学习笔记——享元(Flyweight)模式
设计模式学习笔记--享元(Flyweight)模式 @(设计模式)[设计模式, 享元模式, flyweight] 设计模式学习笔记享元Flyweight模式基本介绍享元案例类图实现代码 Big ...
设计模式学习笔记——单例(Singleton)模式
设计模式学习笔记--单例(Singleton)模式 @(设计模式)[设计模式, 单例模式, Singleton, 懒汉式, 饿汉式] 设计模式学习笔记单例Singleton模式基本介绍单例案例类 ...
设计模式学习笔记——中介者(Mediator)模式
设计模式学习笔记--中介者(Mediator)模式 @(设计模式)[设计模式, 中介者模式, Mediator] 设计模式学习笔记中介者Mediator模式基本介绍中介者案例类图实现代码 Me ...
设计模式学习笔记--享元(Flyweight)模式
写在模式学习之前什么是设计模式:在我们进行程序设计时,逐渐形成了一些典型问题和问题的解决方案,这就是软件模式:每一个模式描述了一个在我们程序设计中经常发生的问题,以及该问题的解决方案:当我们碰到模式 ...
设计模式学习笔记--Flyweight享元模式
Flyweight模式也叫享元模式,是由GoF提出的23种设计模式中的一种.Flyweight模式是构造型模式之一,它通过与其他类似对象共享数据来减小内存占用,所以叫享元. 此模式解决的是由于大量 ...
设计模式学习笔记--Mediator 中介者模式
我们知道面向对象应用程序是由一组为了提供某种服务而彼此交互的对象组成.当彼此引用的对象数量比较少时,此时对象之间就为直接交互(点对点).而当对象的数量增加时,这种直接交互会导致对象之间复杂的.混乱的引 ...
C#设计模式学习笔记：(4)建造者模式
本笔记摘抄自:https://www.cnblogs.com/PatrickLiu/p/7614630.html,记录一下学习过程以备后续查用.一.引言在现实生活中,我们经常会遇到一些构成比较复杂的物 ...
设计模式学习---（2）工厂模式
工厂模式工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 在工厂模式中,我们在创建对象时不会对客户端 ...

设计模式学习笔记(一)之工厂模式、单例模式

设计模式学习笔记(一)之工厂模式、单例模式相关推荐

最新文章

热门文章