- 浏览: 54095 次
- 性别:
- 来自: 湖北
文章分类
- 全部博客 (102)
- ibatis (4)
- spring (12)
- 数据库 (3)
- java (26)
- css (2)
- linux (1)
- hibernate (4)
- Maven (3)
- CMS (1)
- spring mvc (1)
- MyBati (1)
- WEB (1)
- 分布式 (2)
- webservice (2)
- 网络协议 (1)
- TCP (1)
- UDP协议 (1)
- sql优化原则 (1)
- android (1)
- hadoop (10)
- solr (2)
- Scala学习笔记--Actor和并发 (0)
- Spark (4)
- Scala (1)
- hbase (1)
- kafka (1)
- ICE (2)
- 机器学习算法 (2)
- Apache Ignite (1)
- python (1)
- tensorflow (2)
- openstack (1)
- 系统监控 (2)
- 大数据 (1)
- ogg (2)
- Oracle GoldenGate DDL 详细说明 使用手册(较早资料) (0)
- oracle (1)
最新评论
现给出一简单用例,模拟一火腿(Ham)生产工厂,工厂可以生产数种类型的Ham,那么在创建了一个工厂实例后,只需要告诉它请你生产何种Ham,它就会给你生产出来:
package test;
interface Ham { //定义接口,用于辅助实现工厂模式
void show();//由Ham工厂生产出的各种Ham将有show()的能力
}
public class FatoryModule {//工厂类,用于产品多种不同种类的Ham
public Ham getHam(String HamType) throws Exception{//工厂类对象生产Ham的动作
if (HamType.equals("HamA")) {
return new HamA();
}
else if (HamType.equals("HamB")) {
return new HamB();
}
else if (HamType.equals("HamC")) {
return new HamC();
}
else
throw new Exception();//如果该工厂收到生产某种Ham的指令但暂不支持,则抛出异常
}
public static void main(String[] args) {//测试代码
FatoryModule fatorymodule = new FatoryModule();
try {
Ham myHam = fatorymodule.getHam("HamB");//可以方便地创建各种类型的Ham,而程序结构和代码的修改量达到最小
myHam.show();
} catch (Exception ex) {
ex.printStackTrace();//应进一步处理异常
}
}
}
class HamA implements Ham { //工厂中生产的一种产品HamA
public void show() {
System.out.println("You got a HamA.");
}
}
class HamB implements Ham { //工厂生产的另一种产品HamB
public void show() {
System.out.println("You got a HamB.");
}
}
class HamC implements Ham { //工厂生产的第三种产品HamC
public void show() {
System.out.println("You got a HamC.");
}
}
通过程序的演示我得到了以下结论:
由于应用了工厂模式,我只需要告诉工厂对象给我生产一种什么样的Ham(即getHam()方法中的参数),便可以得到此类Ham,而不用写HamX hamX=new HamX(); 要是有数十种不同的Ham对象需要在程序的不同地方被创建,那么使用工厂模式代码将显得简单而统一,每个需要不同Ham的地方仅是getHam()的参数不同。否则程序一旦需要扩展和维护,数十处的new语句将让人头痛。而如果需要添加新的Ham类型,只需要在工厂类中添加即可。
单例模式--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
饿汉式
class Singleton {
private static Singleton instance=new Singleton();
private Singleton(){}
static Singleton getInstance() {
return instance;
}
}
懒汉式
class Singleton {
private static Singleton instance=null;
private Singleton(){}
static Singleton getInstance() {
if(instance==null)
instance=new Singleton();
return instance;
}
}
外观模式--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Java设计模式---外观模式(Facede)
package ding.study.designpatterns.facade;
/**
*
* @author daniel
* 子系统1
*/
public class SystemOne {
/**
* 子系统方法
*/
public void methodOne(){
System.out.println("子系统方法1");
}
}
package ding.study.designpatterns.facade;
/**
*
* @author daniel
* 子系统1
*/
public class SystemTwo {
/**
* 子系统方法
*/
public void methodTwo(){
System.out.println("子系统方法1");
}
}
package ding.study.designpatterns.facade;
public class SystemThree {
/**
* 子系统方法
*/
public void methodThree(){
System.out.println("子系统方法1");
}
}
package ding.study.designpatterns.facade;
public class SystemFour {
/**
* 子系统方法
*/
public void methodFour(){
System.out.println("子系统方法1");
}
}
package ding.study.designpatterns.facade;
/**
* 外观类
* @author daniel
*
*/
public class Facade {
private SystemOne one;
private SystemTwo two;
private SystemThree three;
private SystemFour four;
/**
* 构造函数初始化属性
*/
public Facade(){
one =new SystemOne();
two =new SystemTwo();
three=new SystemThree();
four=new SystemFour();
}
/**
* 1 2 4类的方法调用
*/
public void methodA(){
one.methodOne();
two.methodTwo();
four.methodFour();
}
/**
* 123类的方法调用
*/
public void methodB(){
one.methodOne();
two.methodTwo();
three.methodThree();
}
}
package ding.study.designpatterns.facade;
public class TestMain {
/**复杂的逻辑封装为一个简单的接口
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Facade facade=new Facade();
facade.methodA();
facade.methodB();
}
}
1. 代理模式
代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式一般涉及到三个角色:
抽象角色:声明真实对象和代理对象的共同接口;
代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装。
真实角色:代理角色所代表的真实对象,是我们最终要引用的对象。
以下以《Java与模式》中的示例为例:
抽象角色:
abstract public class Subject {
abstract public void request();
}
真实角色:实现了Subject的request()方法。
public class RealSubject extends Subject {
public RealSubject() { }
public void request() {
System.out.println( " From real subject. " );
}
}
代理角色:
public class ProxySubject extends Subject {
private RealSubject realSubject; // 以真实角色作为代理角色的属性
public ProxySubject() { }
public void request() { // 该方法封装了真实对象的request方法
preRequest();
if ( realSubject == null ) {
realSubject = new RealSubject();
}
realSubject.request(); // 此处执行真实对象的request方法
postRequest();
}
客户端调用:
Subject sub = new ProxySubject();
Sub.request();
由以上代码可以看出,客户实际需要调用的是RealSubject类的request()方法,现在用ProxySubject来代理 RealSubject类,同样达到目的,同时还封装了其他方法(preRequest(),postRequest()),可以处理一些其他问题。
另外,如果要按照上述的方法使用代理模式,那么真实角色必须是事先已经存在的,并将其作为代理对象的内部属性。但是实际使用时,一个真实角色必须对应一个 代理角色,如果大量使用会导致类的急剧膨胀;此外,如果事先并不知道真实角色,该如何使用代理呢?这个问题可以通过Java的动态代理类来解决。
----------------------------------------------------------------
单例模式:
//懒汉式单例类.在第一次调用的时候实例化
2 public class Singleton2 {
3 //私有的默认构造子
4 private Singleton2() {}
5 //注意,这里没有final
6 private static Singleton2 single=null;
7 //静态工厂方法
8 public synchronized static Singleton2 getInstance() {
9 if (single == null) {
10 single = new Singleton2();
11 }
12 return single;
13 }
14 }
//饿汉式单例类.在类初始化时,已经自行实例化
2 public class Singleton1 {
3 //私有的默认构造子
4 private Singleton1() {}
5 //已经自行实例化
6 private static final Singleton1 single = new Singleton1();
7 //静态工厂方法
8 public static Singleton1 getInstance() {
9 return single;
10 }
11 }
package test;
interface Ham { //定义接口,用于辅助实现工厂模式
void show();//由Ham工厂生产出的各种Ham将有show()的能力
}
public class FatoryModule {//工厂类,用于产品多种不同种类的Ham
public Ham getHam(String HamType) throws Exception{//工厂类对象生产Ham的动作
if (HamType.equals("HamA")) {
return new HamA();
}
else if (HamType.equals("HamB")) {
return new HamB();
}
else if (HamType.equals("HamC")) {
return new HamC();
}
else
throw new Exception();//如果该工厂收到生产某种Ham的指令但暂不支持,则抛出异常
}
public static void main(String[] args) {//测试代码
FatoryModule fatorymodule = new FatoryModule();
try {
Ham myHam = fatorymodule.getHam("HamB");//可以方便地创建各种类型的Ham,而程序结构和代码的修改量达到最小
myHam.show();
} catch (Exception ex) {
ex.printStackTrace();//应进一步处理异常
}
}
}
class HamA implements Ham { //工厂中生产的一种产品HamA
public void show() {
System.out.println("You got a HamA.");
}
}
class HamB implements Ham { //工厂生产的另一种产品HamB
public void show() {
System.out.println("You got a HamB.");
}
}
class HamC implements Ham { //工厂生产的第三种产品HamC
public void show() {
System.out.println("You got a HamC.");
}
}
通过程序的演示我得到了以下结论:
由于应用了工厂模式,我只需要告诉工厂对象给我生产一种什么样的Ham(即getHam()方法中的参数),便可以得到此类Ham,而不用写HamX hamX=new HamX(); 要是有数十种不同的Ham对象需要在程序的不同地方被创建,那么使用工厂模式代码将显得简单而统一,每个需要不同Ham的地方仅是getHam()的参数不同。否则程序一旦需要扩展和维护,数十处的new语句将让人头痛。而如果需要添加新的Ham类型,只需要在工厂类中添加即可。
单例模式--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
饿汉式
class Singleton {
private static Singleton instance=new Singleton();
private Singleton(){}
static Singleton getInstance() {
return instance;
}
}
懒汉式
class Singleton {
private static Singleton instance=null;
private Singleton(){}
static Singleton getInstance() {
if(instance==null)
instance=new Singleton();
return instance;
}
}
外观模式--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Java设计模式---外观模式(Facede)
package ding.study.designpatterns.facade;
/**
*
* @author daniel
* 子系统1
*/
public class SystemOne {
/**
* 子系统方法
*/
public void methodOne(){
System.out.println("子系统方法1");
}
}
package ding.study.designpatterns.facade;
/**
*
* @author daniel
* 子系统1
*/
public class SystemTwo {
/**
* 子系统方法
*/
public void methodTwo(){
System.out.println("子系统方法1");
}
}
package ding.study.designpatterns.facade;
public class SystemThree {
/**
* 子系统方法
*/
public void methodThree(){
System.out.println("子系统方法1");
}
}
package ding.study.designpatterns.facade;
public class SystemFour {
/**
* 子系统方法
*/
public void methodFour(){
System.out.println("子系统方法1");
}
}
package ding.study.designpatterns.facade;
/**
* 外观类
* @author daniel
*
*/
public class Facade {
private SystemOne one;
private SystemTwo two;
private SystemThree three;
private SystemFour four;
/**
* 构造函数初始化属性
*/
public Facade(){
one =new SystemOne();
two =new SystemTwo();
three=new SystemThree();
four=new SystemFour();
}
/**
* 1 2 4类的方法调用
*/
public void methodA(){
one.methodOne();
two.methodTwo();
four.methodFour();
}
/**
* 123类的方法调用
*/
public void methodB(){
one.methodOne();
two.methodTwo();
three.methodThree();
}
}
package ding.study.designpatterns.facade;
public class TestMain {
/**复杂的逻辑封装为一个简单的接口
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Facade facade=new Facade();
facade.methodA();
facade.methodB();
}
}
1. 代理模式
代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式一般涉及到三个角色:
抽象角色:声明真实对象和代理对象的共同接口;
代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装。
真实角色:代理角色所代表的真实对象,是我们最终要引用的对象。
以下以《Java与模式》中的示例为例:
抽象角色:
abstract public class Subject {
abstract public void request();
}
真实角色:实现了Subject的request()方法。
public class RealSubject extends Subject {
public RealSubject() { }
public void request() {
System.out.println( " From real subject. " );
}
}
代理角色:
public class ProxySubject extends Subject {
private RealSubject realSubject; // 以真实角色作为代理角色的属性
public ProxySubject() { }
public void request() { // 该方法封装了真实对象的request方法
preRequest();
if ( realSubject == null ) {
realSubject = new RealSubject();
}
realSubject.request(); // 此处执行真实对象的request方法
postRequest();
}
客户端调用:
Subject sub = new ProxySubject();
Sub.request();
由以上代码可以看出,客户实际需要调用的是RealSubject类的request()方法,现在用ProxySubject来代理 RealSubject类,同样达到目的,同时还封装了其他方法(preRequest(),postRequest()),可以处理一些其他问题。
另外,如果要按照上述的方法使用代理模式,那么真实角色必须是事先已经存在的,并将其作为代理对象的内部属性。但是实际使用时,一个真实角色必须对应一个 代理角色,如果大量使用会导致类的急剧膨胀;此外,如果事先并不知道真实角色,该如何使用代理呢?这个问题可以通过Java的动态代理类来解决。
----------------------------------------------------------------
单例模式:
//懒汉式单例类.在第一次调用的时候实例化
2 public class Singleton2 {
3 //私有的默认构造子
4 private Singleton2() {}
5 //注意,这里没有final
6 private static Singleton2 single=null;
7 //静态工厂方法
8 public synchronized static Singleton2 getInstance() {
9 if (single == null) {
10 single = new Singleton2();
11 }
12 return single;
13 }
14 }
//饿汉式单例类.在类初始化时,已经自行实例化
2 public class Singleton1 {
3 //私有的默认构造子
4 private Singleton1() {}
5 //已经自行实例化
6 private static final Singleton1 single = new Singleton1();
7 //静态工厂方法
8 public static Singleton1 getInstance() {
9 return single;
10 }
11 }
发表评论
-
jvm
2018-03-26 09:47 395http://www.cnblogs.com/moonands ... -
多线程
2015-11-11 16:05 349public class ThreadDemo3 { ... -
java之装饰设计模式和继承的简单区别
2015-10-29 16:24 807http://jiangnanlove.iteye.com/b ... -
java注解
2015-10-26 11:18 391Java自定义注解小结 作者:谢伟伦 学习java有两年之余了 ... -
字符串补零除0
2015-10-21 11:55 698//去零操作 String str = "0050 ... -
代理模式与装饰模式差别,适配器模式
2015-10-07 19:29 724http://blog.csdn.net/hitprince/ ... -
jsoup解析html
2015-03-31 11:17 827jsoup:解析HTML用法小结 原文 http://my ... -
license生成
2015-03-02 10:44 540package com.dameng.dmdp.utils; ... -
java 堆和栈
2014-11-27 15:18 5171.栈(stack)与堆(heap)都是J ... -
java内部类、静态内部类 小结
2014-11-26 14:12 5441)首先,用内部类是因 ... -
java 23种设计模式
2014-11-19 14:56 598http://zz563143188.iteye.com/bl ... -
Java调用webservice接口方法
2014-11-19 14:36 5191. Java调用webservice接口方法 webserv ... -
java基本类型
2014-11-05 14:05 703基本类型比较 -
java修饰符权限
2014-11-05 13:58 601(1)public:可以被所有其他类所访问。 (2)priv ... -
类型转换
2014-11-05 13:44 494short s1 = 1; s1 = s1 + 1;有错,s1 ... -
Sring x = new String("xyz")
2014-11-05 13:32 511只要是new,都是重新分配堆空间,如果不区分栈和堆,这里创建了 ... -
java内部类和静态内部类调用
2014-06-23 14:06 547内部类 public class Test { clas ... -
匿名内部类
2014-06-18 15:00 441匿名内部类也就是没有 ... -
类的加载周期
2014-06-16 12:47 369类什么时候被加载/类加载时机: 第一:生成该类对象的时候,会 ... -
内部类
2014-05-05 14:43 495http://www.cnblogs.com/mengdd/a ...
相关推荐
《Java模式速查手册》是一本专注于Java编程中设计模式的实用参考书籍,它结合了源码分析与工具应用,旨在帮助开发者深入理解和熟练运用各种设计模式。在Java开发领域,设计模式是解决常见问题的经验总结,是软件工程...
《JAVA模式培训教材》是专为公司内部设计的一份经典教程,旨在提供深入浅出的JAVA编程模式教学,相比市面上的通用电子书籍,它更注重实践性和针对性,以帮助学习者快速掌握JAVA编程的核心概念和最佳实践。...
Java模式源代码是Java编程领域中的重要学习资源,它涵盖了设计模式、编程实践以及最佳解决方案。这些模式来源于软件工程的实践经验,旨在解决常见的编程问题,提高代码的可读性、可维护性和复用性。本资源包含了一...
【标题】"OozinozDpij(java模式).rar" 提供的资源是一个包含Java编程模式的代码库。这个压缩包很可能是为了帮助开发者理解和应用在Java编程中的设计模式,这些模式是解决常见软件工程问题的成熟解决方案。 【描述...
"Java模式--含源码"这个资源显然旨在深入解析几种关键的设计模式,并通过实际的源代码来帮助开发者理解和应用这些模式。以下是关于Java工厂模式和单例模式的详尽解释,以及它们在实际开发中的应用。 **1. 工厂模式*...
java模式 详细讲解 想了解模式的人可以看看
下载我发布的Java模式.rar.001,Java模式.rar.002,Java模式.rar.003,Link.bat到文件夹下面.然后双击Link.bat即可合并三个文件未一个文件,最后使用winara打开
下载我发布的Java模式.rar.001,Java模式.rar.002,Java模式.rar.003,Link.bat到文件夹下面.然后双击Link.bat即可合并三个文件未一个文件,最后使用winara打开
下载我发布的Java模式.rar.001,Java模式.rar.002,Java模式.rar.003,Link.bat到文件夹下面.然后双击Link.bat即可合并三个文件未一个文件,最后使用winara打开
Java模式设计,对提高个人的编程意识有很大帮助。通过一个完整的java项目对经典著作design patterns一书介绍的23种设计模式进行了深入分析与讲解,实践性强,却又不失对模式本质的探讨。本书创造性地将这些模式分为5...
Java模式 Java语言的接口 抽象类 里氏代换原则 依赖倒转原则 接口隔离原则 合成/聚合复用原则 迪米特法则 简单的工厂 工厂的方法 抽象工程 单例(singleton) 原始模型 适配器 装饰 代理 门面模式 不变模式 策略模式 ...
下载我发布的Java模式.rar.001,Java模式.rar.002,Java模式.rar.003,Link.bat到文件夹下面.然后双击Link.bat即可合并三个文件未一个文件,最后使用winara打开
Java模式设计之多态模式多语言支持.doc
`java模式之单例模式.doc`可能会详细解析这些实现方式的优缺点,以及在实际项目中如何选择合适的实现策略。 在Java开发中,这两种设计模式经常被结合使用。例如,我们可以使用工厂模式来创建单例对象,使得获取单例...
JAVA与模式JAVA与模式JAVA与模式JAVA与模式
关于java23种模式的ppt课件 创建型模式、结构性模式和行为型模式
java与模式java与模式java与模式java与模式java与模式
JAVA模式电子宠物系统的开发.doc
Java模式PDF