“黑马程序员”我所了解的设计模式

 

 android培训java培训期待与您交流!!!

 

本篇主要记录一些常见的设计模式，后续学习中会持续更新

目前我所了解的有单例设计模式，简单工厂设计模式，装饰设计模式。

设计模式是对前人经验和智慧的总结，了解并学会使用其中的几种 设计模式可以提高我们的工作效率，每一种设计模式都用于解决某种特定的问题，这样以后再碰到此类问题，我们可以不假思索的使用相应的设计模式解决。

软件设计有一个原则就是封装变化点，将程序中经常变化的部分封装起来可以降低类与类之间的耦合性

 

1,简单工厂设计模式

     

 示例代码段1：通过代码演示简单工厂通过参数创建对象的过程

以卖票为例

票的父类

class Ticket(){
}

学生票子类

class StudentTicket extends Ticket{

}

 赠票子类

class FreeTicket extends Ticket{

}

 创建子类对象的简单工厂类，要创建相应的子类对象，只要传入对象对应的参数类型就哦了

    class TicketFactory
    {
        public static Ticket CreateTicket(string type)
        {
            Ticket t= null;
            switch (type)
            {
                case "studentTicket":
                    t = new StudentTicket();
                    break;
                case "freeTicket":
                    t = new FreeTicket();
                    break;
                default:
                    t = new Ticket();
                    break;
            }
            return t;
        }
          }
}

 2.单例设计模式

 解决的问题：就是可以保证一个类在内存中的对象唯一性。

应用的场景：必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

如何保证对象唯一性呢？

1，不允许其他程序用new创建该类对象。
2，在该类创建一个本类实例。
3，对外提供一个方法让其他程序可以获取该对象。

解决步骤

1，私有化该类构造函数。
2，通过new在本类中创建一个本类对象。
3，定义一个公有的方法，将创建的对象返回。

单例设计模式之饿汉式。（多线程是安全的，优先选择）

 

 

class Single//类一加载，对象就已经存在了。
{
	private static Single s = new Single();

	private Single(){}

	public static Single getInstance()
	{
		return s;
	}
}

 单例设计模式之懒汉式。（线程是非安全的）

 

 

class Single2//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
			//延迟加载形式。 
{
	private static Single2 s = null;

	private Single2(){}

	public static Single2 getInstance()
	{
		if(s==null)
			s = new Single2();
		return s;
	}
}

  单例设计模式之懒汉式解决线程安全的问题

 

class Single
{
	private static Single s = null;

	private Single(){}

	public static Single getInstance()
	{	加入双重判断是为了解决效率问题。
		if(s==null)
		{
			加入同步为了解决多线程安全问题。
			synchronized(Single.class)		
			{
				if(s==null)
		
					s = new Single();
			}
		}
		return s;
	}
}

 3.装饰设计模式

 

        特点：进行功能的扩展增强

                  装饰类和被装饰类都必须所属同一个接口或者父类

        应用：对一组对象的功能进行增强时，就可以使用该模式进行问题的解决

        和继承的区别：相同点：装饰和继承都能实现一样的特点：进行功能的扩展增强。

                                  不同点：使用继承实现对功能的扩展，比如：Writer
                                                                                                                      |--TextWriter:用于操作文本
                                                                                                                               |--BufferTextWriter:加入了缓冲技术的操作文本的对象。
                                                                                                                      |--MediaWriter：用于操作媒体。
                                                                                                                               |--BufferMediaWriter

                                  如果这个体系进行功能的扩展，就会增加很多的流对象，这时就会发现只为提高功能而进行的继承，导致继承体系越来越臃肿，不够灵活。 
                                    使用装饰设计模式，将缓冲进行单独的封装，哪个对象需要缓冲就将哪个对象和缓冲关联
                                        class BufferWriter extends Writer{
                                                                 BufferWriter(Writer w)
                                                                  {
                                                                  }
                                                             }

                                        Writer
                                                |--TextWriter:用于操作文本
                                                |--MediaWriter：用于操作媒体。
                                                |--BufferWriter:用于提高效率。

可以看出装饰设计模式显得更加灵活