设计模式:解决某一类问题最行之有效的方法。
java中23种设计模式,仅总结了4中设计模式:单例设计模式、模板方法设计模式、装设设计模式和享元设计模式。
单例设计模式:解决一个类在内存只存在一个对象,想要保证对象唯一。
1,为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2,还为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象。
3,为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
这三部怎么用代码体现呢?
1,将构造函数私有化。
2,在类中创建一个本类对象。
3,提供一个方法可以获取到该对象。
单例设计模式中,有两种设计方法,一种是饿汉式,这种方式一般在自己类中就创建出对象,然后向外提供。另一种是懒汉式,这种方式是在方法被调用时才进行初始化,也叫做对象的延时加载。
饿汉式:
class Single
{
private Single(){}; //私有化构造函数
private static Single s = new Single(); //自己创造对象
public static Single getInstance()//对外提供对象的方法
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single s1 = Single t. getInstance();
Single s2 = Single. getInstance();
}
}
懒汉式:
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;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single s1 = Single t. getInstance();
Single s2 = Single. getInstance();
}
}
模板方法设计模式:在定义功能时,功能的一部分是确定的,但是有一部分是不确定,而确定的部分在使用不确定的部分,那么这时就将不确定的部分暴露出去。由该类的子类去完成。代码如下:
abstract class GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis();
runcode();
long end = System.currentTimeMillis();
System.out.println("毫秒:"+(end-start));
}
public abstract void runcode(); //创建一个抽象方法,使子类来确定其具体的实现方法
}
class SubTime extends GetTime //继承父类,来决定实现具体的方法
{
public void runcode()
{
for(int x=0; x<4000; x++)
{
System.out.print(x);
}
}
}
class TemplateDemo
{
public static void main(String[] args)
{
SubTime gt = new SubTime();
gt.getTime();
}
}
这种模式实际上就是通过子类复写父类的方法来完成的。
装饰类设计模式:当想要对已有的对象进行功能增强时,可以定义类,将已有对象传入,基于已有的功能,并提供加强功能。那么自定义的该类称为装饰类。装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能,提供更强的功能。装饰模式比继承要灵活。避免了继承体系臃肿。而且降低了类于类之间的关系。装饰类因为增强已有对象,具备的功能和已有的是相同的,只不过提供了更强功能。所以装饰类和被装饰类通常是都属于一个体系中的。
class Person
{
public void chifan()
{
System.out.println("吃饭");
}
}
class SuperPerson
{
private Person p ;
SuperPerson(Person p)
{
this.p = p;
}
public void superChifan()
{
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
System.out.println("来一根");
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person();
SuperPerson sp = new SuperPerson(p);
sp.superChifan();
}
}
享元模式:也叫做Flyweight。避免大量拥有相同内容的小类的开销(如耗费内存),使大家共享一个类(元类).
为什么使用?
面向对象语言的原则就是一切都是对象,但是如果真正使用起来,有时对象数可能显得很庞大,比如,字处理软件,如果以每个文字都作为一个对象,几千个字,对象数就是几千,无疑耗费内存,那么我们还是要"求同存异",找出这些对象群的共同点,设计一个元类,封装可以被共享的类,另外,还有一些特性是取决于应用(context), 是不可共享的,这也Flyweight中两个重要概念内部状态intrinsic 和外部状态extrinsic之分. 说白点,就是先捏一个的原始模型,然后随着不同场合和环境,再产生各具特征的具体模型,很显然,在这里需要产生不同的新对象,所以Flyweight 模式中常出现Factory模式.Flyweight 的内部状态是用来共享的,Flyweight factory 负责维护一个Flyweight pool( 模式池)来存放内部状态的对象. Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应用场合很多:如你要从一个数据库中读取一系列字符串,这些字符串中有许多是重复的,那么我们可以将这些字符串储存在Flyweight池(pool)中.
比如:
Integer a=3;
Integer b-3;
a和b其实是一个对象,也就是说a==b;在内存中,Integer类的对象,只要在1个字节内的数据都共用对象,也就是在(-128--127)内公用对象。