黑马程序员-Java的设计模式
2015-11-19 09:59
603 查看
-----------android培训、java培训、java学习型技术博客、期待与您交流!------------
Java中设计模式的初步学习
一、设计模式(范式):
解决某一类问题的最行之有效的方法。
(1)从高效合理开发的思想考虑; (2)框架:复杂的设计模式;
(3)java中已经总结了23中设计模式;
二、单例设计模式:解决一个类在内存只存在一个对象。
当在不同的地方想操作同一个对象时,这种单子的设计模式相当的棒。
例如:不同的两个类A和B,都要操作配置文件,就可以利用单子的C类的设计模式实现。
1、对象唯一性:
(1)为了避免其他程序过多建立该类的对象,禁止其他程序建立该类对象;
(2)为了让其他程序可以访问该类的对象,在本类中,自定义一个对象;
(3)为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
2、单例模式的实现
(1)将构造函数私有化;
(2)在类中创建一个本类对象;
(3)提供一个方法可以获取到对象。
(4)对事物用类正常描述,当需要将该事物保证在内存中唯一使,
就将以上的三步加上即可。
3、饿汉式和懒汉式
虽然对象的的创建时间不一样,但是,都是为了要使用这个唯一的
对象,所以差别不是特别大。
但是,懒汉式在判断创建对象时,不是原子操作,容易引起两个程序
同时调用时,创建不同的对象,所以一般使用饿汉式。
/*懒汉式:延迟加载,对象是方法被调用时才初始化;
SingleMode类进内存,对象还没有存在,只有调用
getImstance()方法时,才在堆中建立对象。
*/
class SingleMode {
private int num;
private SingleMode(){}
private static SingleMode sm = null;
public static SingleMode getInstance()
{
if(sm == null)//A和B两个线程同时调用时,容易产生问题,创建不同的对象
sm = new SingleMode();
return sm;
}
/*
public static synchronized SingleMode getInstance() //每次判断,效率比较低
{
if(sm == null)
sm = new SingleMode();
return sm;
}
*/
/*
public static synchronized SingleMode getInstance()
{
-->C线程执行到这里
if(sm == null){
-->B线执行到这里,因为锁,停在了这里
synchronized (SingleMode.class){ //减少了读锁的次数
if(sm == null)//防止B进来后,判断出现错误
-->A线程停在了这里
sm = new SingleMode();
}
}
return sm;
}
*/
public void setNum(int num){
this.num = num;
}
public int getNum(){
return num;
}
}
public class SingleModeDemo2{
public static void main(String[] args){
SingleMode s1 = SingleMode.getInstance();
SingleMode s2 = SingleMode.getInstance();
s1.setNum(30);
System.out.println(s2.getNum());
System.out.println(s1==s2);
}
}
4、通过继承简化单例模式
三、抽象工厂模式
为了解决工厂方法模式中,如果想要拓展程序功能,就必须对工厂类直接进行
修改,这个违反了闭包原则的问题.
利用工厂类接口实现创建多个不同功能的工厂类,当需要增加一个功能时,
只需要做一个实现类和基于工厂类接口的实现的工厂类,就可以在不改变原有代码
的基础上,实现功能拓展。
四、模板方法模式
在定义功能时,功能的一部分是确定的,但是有一部分是不确定的,而确定的部分在使用不确定的部分,
那么就将不确定的部分划分出去,有该类的子类去完成。
总结,其他继承、组合和装饰器等也是一种设计合理类,可以使你对项目的扩展更佳
容易和合理,通过重构从整体上重新优化项目内整体的结构;还有其他常用的设计模式,
如工厂方法模式等等,应用这些都可以使用的开发更佳的高效和合理。
五、参考
1、Java开发中的23种设计模式详解(转) http://blog.csdn.net/tansuozhey/article/details/50116047;
2、《设计模式:可复用面向对象软件的基础》 Erich Gamma、Richard Helm、Ralph Johnson和JohnVlissides著。
Java中设计模式的初步学习
一、设计模式(范式):
解决某一类问题的最行之有效的方法。
(1)从高效合理开发的思想考虑; (2)框架:复杂的设计模式;
(3)java中已经总结了23中设计模式;
二、单例设计模式:解决一个类在内存只存在一个对象。
当在不同的地方想操作同一个对象时,这种单子的设计模式相当的棒。
例如:不同的两个类A和B,都要操作配置文件,就可以利用单子的C类的设计模式实现。
1、对象唯一性:
(1)为了避免其他程序过多建立该类的对象,禁止其他程序建立该类对象;
(2)为了让其他程序可以访问该类的对象,在本类中,自定义一个对象;
(3)为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
2、单例模式的实现
(1)将构造函数私有化;
(2)在类中创建一个本类对象;
(3)提供一个方法可以获取到对象。
(4)对事物用类正常描述,当需要将该事物保证在内存中唯一使,
就将以上的三步加上即可。
3、饿汉式和懒汉式
虽然对象的的创建时间不一样,但是,都是为了要使用这个唯一的
对象,所以差别不是特别大。
但是,懒汉式在判断创建对象时,不是原子操作,容易引起两个程序
同时调用时,创建不同的对象,所以一般使用饿汉式。
/*饿汉式:先初始化对象; SingleMode一进内存,就已经创建好了方法区中sm指向的 堆内存中对象; */ class SingleMode { private int num; private SingleMode(){} private static SingleMode sm = new SingleMode(); public static SingleMode getInstance() { return sm; } public void setNum(int num){ this.num = num; } public int getNum(){ return num; } } public class SingleModeDemo{ public static void main(String[] args){ SingleMode s1 = SingleMode.getInstance(); SingleMode s2 = SingleMode.getInstance(); s1.setNum(30); System.out.println(s2.getNum()); System.out.println(s1==s2); } }
/*懒汉式:延迟加载,对象是方法被调用时才初始化;
SingleMode类进内存,对象还没有存在,只有调用
getImstance()方法时,才在堆中建立对象。
*/
class SingleMode {
private int num;
private SingleMode(){}
private static SingleMode sm = null;
public static SingleMode getInstance()
{
if(sm == null)//A和B两个线程同时调用时,容易产生问题,创建不同的对象
sm = new SingleMode();
return sm;
}
/*
public static synchronized SingleMode getInstance() //每次判断,效率比较低
{
if(sm == null)
sm = new SingleMode();
return sm;
}
*/
/*
public static synchronized SingleMode getInstance()
{
-->C线程执行到这里
if(sm == null){
-->B线执行到这里,因为锁,停在了这里
synchronized (SingleMode.class){ //减少了读锁的次数
if(sm == null)//防止B进来后,判断出现错误
-->A线程停在了这里
sm = new SingleMode();
}
}
return sm;
}
*/
public void setNum(int num){
this.num = num;
}
public int getNum(){
return num;
}
}
public class SingleModeDemo2{
public static void main(String[] args){
SingleMode s1 = SingleMode.getInstance();
SingleMode s2 = SingleMode.getInstance();
s1.setNum(30);
System.out.println(s2.getNum());
System.out.println(s1==s2);
}
}
4、通过继承简化单例模式
class Student { private int age; private String name; public Student(){ System.out.println("Student construtor() 1"); } public Student(String name ,int age){ System.out.println("Student construtor() 2"); this.name = name; this.age = age; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } public void setName(String name){ this.name = name; } public String getName(){ return name; } public static void main(String[] args) { System.out.println("Hello World!"); } } class SpecialStudent extends Student{ private SpecialStudent(){ super("li",30); } private static SpecialStudent ss = new SpecialStudent(); public static SpecialStudent getInstance(){ return ss; } } public class SingleModeDemo3{ public static void main(String[] args){ SpecialStudent s1 = SpecialStudent.getInstance(); SpecialStudent s2 = SpecialStudent.getInstance(); //s1.setAge(20); System.out.println(s2.getAge()); } }
三、抽象工厂模式
为了解决工厂方法模式中,如果想要拓展程序功能,就必须对工厂类直接进行
修改,这个违反了闭包原则的问题.
利用工厂类接口实现创建多个不同功能的工厂类,当需要增加一个功能时,
只需要做一个实现类和基于工厂类接口的实现的工厂类,就可以在不改变原有代码
的基础上,实现功能拓展。
//抽象工厂模式 public interface Sender { public void Send(); } //两个实现类: public class MailSender implements Sender { @Override public void Send() { System.out.println("this is mailsender!"); } } public class SmsSender implements Sender { @Override public void Send() { System.out.println("this is sms sender!"); } } //新的功能实现类 public class WeChatSender implements Sender { @Override public void Send() { System.out.println("this is wechat sender!"); } } //在提供一个接口: public interface Provider { public Sender produce(); } //两个工厂类: public class SendMailFactory implements Provider { @Override public Sender produce(){ return new MailSender(); } } public class SendSmsFactory implements Provider{ @Override public Sender produce() { return new SmsSender(); } } //新的功能的实现类的工厂类 public class SendWeChatFactory implements Provider{ @Override public Sender produce() { return new WeChatSender(); } } //测试类: public class AbstractFactroyModeTest { public static void main(String[] args) { Provider provider = new SendWeChatFactory(); Sender sender = provider.produce(); sender.Send(); } }
四、模板方法模式
在定义功能时,功能的一部分是确定的,但是有一部分是不确定的,而确定的部分在使用不确定的部分,
那么就将不确定的部分划分出去,有该类的子类去完成。
/* 需求:获取一段程序运行的时间。 思路:获取程序开始和结束的时间并相减即可。 当前时间获取:System.currentTimeMillis(); */ abstract class RunTimeCount{ //模板方法 public final long getTime(){ long startTime = System.currentTimeMillis(); runCode(); long endTime = System.currentTimeMillis(); return (endTime-startTime); } //不确定的功能处理成一个方法 public abstract void runCode(); } class CodeRun extends RunTimeCount{ public void runCode(){ for(int i=0;i<1000;i++){ System.out.print(i+" "); } System.out.println(); } } public class TemplateDemo { public static void main(String[] args) { CodeRun cr = new CodeRun(); long rt = cr.getTime(); System.out.println("runtie = "+rt); } }
总结,其他继承、组合和装饰器等也是一种设计合理类,可以使你对项目的扩展更佳
容易和合理,通过重构从整体上重新优化项目内整体的结构;还有其他常用的设计模式,
如工厂方法模式等等,应用这些都可以使用的开发更佳的高效和合理。
五、参考
1、Java开发中的23种设计模式详解(转) http://blog.csdn.net/tansuozhey/article/details/50116047;
2、《设计模式:可复用面向对象软件的基础》 Erich Gamma、Richard Helm、Ralph Johnson和JohnVlissides著。
相关文章推荐
- java对世界各个时区(TimeZone)的通用转换处理方法(转载)
- java-注解annotation
- java-模拟tomcat服务器
- java-用HttpURLConnection发送Http请求.
- java-WEB中的监听器Lisener
- Android IPC进程间通讯机制
- Android Native 绘图方法
- Android java 与 javascript互访(相互调用)的方法例子
- 介绍一款信息管理系统的开源框架---jeecg
- 聚类算法之kmeans算法java版本
- java实现 PageRank算法
- PropertyChangeListener简单理解
- 插入排序
- 冒泡排序
- 堆排序
- 快速排序
- 二叉查找树