小码农

趣味编程-面向每个人的创意编程

java常用的设计模式:1、单例模式;2、工厂模式;3、建造(Builder)模式;4、观察者模式;5、适配器(Adapter)模式;6、代理模式;7、装饰模式。

Num1:单例模式

基本概念:保证一个类仅有一个实例,并提供一个访问它的全局访问点。

常见写法:

饿汉式

1

2

3

4

5

6

7

8

public class Singleton{

    private static Singleton singleton = new Singleton();

    private Singleton(){

    }

    public static Singleton getInstance(){

        return singleton;

    }

}

调用

1

Singleton.getInstance().method();

懒汉式

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public class Singleton { 

    /* 持有私有静态实例,防止被引用,此处赋值为null,目的是实现延迟加载 */

    private static Singleton instance = null

  

    /* 私有构造方法,防止被实例化 */

    private Singleton() {} 

  

    /* 1:懒汉式,静态工程方法,创建实例 */

    public static Singleton getInstance() { 

        if (instance == null) { 

            instance = new Singleton(); 

        

        return instance; 

    

protected void method() { 

        System.out.println("SingletonInner"); 

    }

}

调用:

1

Singleton.getInstance().method();

优点:延迟加载(需要的时候才去加载),适合单线程操作
缺点: 线程不安全,在多线程中很容易出现不同步的情况,如在数据库对象进行的频繁读写操作时。

双重线程检查模式

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

public class SingletonInner { 

    private static volatile SingletonInner sInst = null// <<< 这里添加了 volatile 

    /**

     * 私有的构造函数

     */

    private SingletonInner() {} 

  

    public static SingletonInner getInstance() { 

        if (inst == null) {            synchronized (SingletonInner.class) {if (inst == null) {

                    sInst = new SingletonInner();

                }

            }

        }        return sInst; 

    }    protected void method() { 

        System.out.println("SingletonInner"); 

    

}

调用:

1

Singleton.getInstance().method();

优点:线程安全,支持延时加载,调用效率高
缺点: 写法复杂,不简洁

内部类的实现

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

public class SingletonInner { 

    /**

     * 内部类实现单例模式

     * 延迟加载,减少内存开销  

     */

    private static class SingletonHolder { 

        private static SingletonInner instance = new SingletonInner(); 

    

  

    /**

     * 私有的构造函数

     */

    private SingletonInner() {} 

  

    public static SingletonInner getInstance() { 

        return SingletonHolder.instance; 

    

  

    protected void method() { 

        System.out.println("SingletonInner"); 

    

}

调用:

1

Singleton.getInstance().method();

优点:延迟加载,线程安全(java中class加载时互斥的),也减少了内存消耗,推荐使用内部类方式。

Num2:工厂模式

基本概念:为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的。

分为三类:

  • 简单工厂模式Simple Factory:不利于产生系列产品;
  • 工厂方法模式Factory Method:又称为多形性工厂;
  • 抽象工厂模式Abstract Factory:又称为工具箱,产生产品族,但不利于产生新的产品;

这三种模式从上到下逐步抽象,并且更具一般性。GOF在《设计模式》一书中将工厂模式分为两类:工厂方法模式(Factory Method)与抽象工厂模式(Abstract Factory)。将简单工厂模式(Simple Factory)看为工厂方法模式的一种特例,两者归为一类。

简单工厂模式

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单:定义一个用于创建对象的接口。

在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定那一个产品类应当被实例化, 如同一个交通警察站在来往的车辆流中,决定放行那一个方向的车辆向那一个方向流动一样。

先来看看它的组成:

  • 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
  • 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
  • 具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

示例代码:

1

2

3

4

5

6

7

8

public class Factory{ //getClass 产生Sample 一般可使用动态类装载装入类。

    public static Sample creator(int which){

        if (which==1)

            return new SampleA();

        else if (which==2)

            return new SampleB();

    }

}

还有一种目前比较流行的规范是把静态工厂方法命名为valueOf或者getInstance

valueOf:该方法返回的实例与它的参数具有同样的值,例如:

1

Integer a=Integer.valueOf(100); //返回取值为100的Integer对象

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

public class Complex {

    private final float re;

    private final float im;

    private Complex(float re, float im){

        this.re = re;

        this.im = im;

    }

    public static Complex valueOf(float re, float im){

        return new Complex(re, im);

    }

    public static Complex valueOfPolar(float r, float theta){

        return new Complex((float)(r * Math.cos(theta)), (float)(r * Math.sin(theta)));

    }

}

从上面代码可以看出,valueOf()方法能执行类型转换操作,在本例中,把int类型的基本数据转换为Integer对象。

getInstance:返回的实例与参数匹配,例如:

1

Calendar cal=Calendar.getInstance(Locale.CHINA); //返回符合中国标准的日历

工厂方法模式

工厂方法模式是简单工厂模式的进一步抽象化和推广,工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。
来看下它的组成:

  • 抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
  • 具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象
  • 抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
  • 具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说,这样便分担了对象承受的压力;而且这样使得结构变得灵活 起来——当有新的产品(即暴发户的汽车)产生时,只要按照抽象产品角色、抽象工厂角色提供的合同来生成,那么就可以被客户使用,而不必去修改任何已有的代 码。可以看出工厂角色的结构也是符合开闭原则的!

示例代码:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

//抽象产品角色

public interface Moveable {

    void run();

}

//具体产品角色

public class Plane implements Moveable {

    @Override

    public void run() {

        System.out.println("plane....");

    }

}

//具体产品角色

public class Broom implements Moveable {

    @Override

    public void run() {

        System.out.println("broom.....");

    }

}

//抽象工厂

public abstract class VehicleFactory {

    abstract Moveable create();

}

//具体工厂

public class PlaneFactory extends VehicleFactory{

    public Moveable create() {

        return new Plane();

    }

}

//具体工厂

public class BroomFactory extends VehicleFactory{

    public Moveable create() {

        return new Broom();

    }

}

//测试类

public class Test {

    public static void main(String[] args) {

        VehicleFactory factory = new BroomFactory();

        Moveable m = factory.create();

        m.run();

    }

}

可以看出工厂方法的加入,使得对象的数量成倍增长。当产品种类非常多时,会出现大量的与之对应的工厂对象,这不是我们所希望的。因为如果不能避免这种情 况,可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类:即对于产品树上类似的种类(一般是树的叶子中互为兄弟的)使用简单工厂模式来实 现。

简单工厂和工厂方法模式的比较

工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。
反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。

抽象工厂模式

示例代码:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

//抽象工厂类

public abstract class AbstractFactory {

    public abstract Vehicle createVehicle();

    public abstract Weapon createWeapon();

    public abstract Food createFood();

}

//具体工厂类,其中Food,Vehicle,Weapon是抽象类,

public class DefaultFactory extends AbstractFactory{

    @Override

    public Food createFood() {

        return new Apple();

    }

    @Override

    public Vehicle createVehicle() {

        return new Car();

    }

    @Override

    public Weapon createWeapon() {

        return new AK47();

    }

}

//测试类

public class Test {

    public static void main(String[] args) {

        AbstractFactory f = new DefaultFactory();

        Vehicle v = f.createVehicle();

        v.run();

        Weapon w = f.createWeapon();

        w.shoot();

        Food a = f.createFood();

        a.printName();

    }

}

在抽象工厂模式中,抽象产品 (AbstractProduct) 可能是一个或多个,从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下,抽象工厂模式实际上退化到工厂方法模式。

发表评论