设计模式:解决某一类问题最有效的方式
(一)单例设计模式
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();
}
}
(一)单例设计模式
解决的是一个类只有一个对象的问题
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();
}
}