设计模式 (后续慢慢补充)

设计模式：解决某一类问题最有效的方式


（一）单例设计模式

解决的是一个类只有一个对象的问题

1.构造函数私有化

2.在类中创建自身类型的对象
3.把对象提供进去，通过定义一个public的静态函数返回该对象


饿汉式：
private static final Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
懒汉式：
private static final Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
return s = new Single();
return s;
}


（二）模板设计模式
在实现一个功能时，功能的一部分是确定的，另一部分是不确定的，
      确定的部分还会用到不确定的不部分，那么久把不确定的部分暴露出去，
          让子类去完成。
 例：计算一个程序的运行时间
1.获取程序的开始和结束时间是确定的，然后相减
2.被计算运行时间的程序是不确定的
class  Test
{
public static void main(String[] args) 
{
testTool test = new testTool();
test.getTime();
}
}
abstract class MyTool
{
public final void getTime()  //必须是final
{
long strTime = System.currentTimeMillis();
function();
long endTime = System.currentTimeMillis();
System.out.println("运行时间是："+(endTime-strTime));
}
public abstract void function() //抽象方法
} 
class testTool extends MyTool
{
public void function()
{
System.out.println("hello world");
}
}


（三）装饰设计模式
基于已经存在的功能，提供增强的功能
例：IO流中的缓冲流
    对于输入输出流提高效率，不可能在其每个子类下面都写一个为提高效率的子类
        既然都是提高效率，所以就把这个功能提取出来封装到一个类中，谁需要被调高效率
       就把谁作为参数传递给该类的构造方法
  class BufferedReader
  {
private Reader re;
public BufferedReader(Reader re)
{
this.re = re;
}
  }
装饰设计模式的好处：
1.装饰设计模式使原有继承体系变简单了
2.因为是在原有功能提高增强的功能，所以这个类还是属于原有体系




（四）工厂设计模式
对大量实现了相同接口的类或继承了相同父类的子类进行实例化
1.简单工厂模式
class Factory
{
public interface produce(String ss)
{
if("a".equals(ss))
return new A();
else if("b".equals(ss))
retrun new B();
return null;
}
}
2.多个方法工厂模式
class Factory
{
public A getInstance1()
{
return new A();
}
public B getInstance2()
{
return new B();
}
}
3.静态工厂模式（常用）
class Factory
{
public static A getInstance1()
{
return new A();
}
public static B getInstance2()
{
return new B();
}
}
4.抽象工厂模式
Interface factory
{
public interface inter();
}
class FacA implements factory
{
public interface inter()
{
return new A();
}
}
class FacB implements factory
{
public interface inter()
{
return new B();
}
}