- 浏览: 51344 次
- 性别:
- 来自: 湖北
文章分类
- 全部博客 (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 369http://www.cnblogs.com/moonands ... -
多线程
2015-11-11 16:05 312public class ThreadDemo3 { ... -
java之装饰设计模式和继承的简单区别
2015-10-29 16:24 781http://jiangnanlove.iteye.com/b ... -
java注解
2015-10-26 11:18 370Java自定义注解小结 作者:谢伟伦 学习java有两年之余了 ... -
字符串补零除0
2015-10-21 11:55 660//去零操作 String str = "0050 ... -
代理模式与装饰模式差别,适配器模式
2015-10-07 19:29 703http://blog.csdn.net/hitprince/ ... -
jsoup解析html
2015-03-31 11:17 798jsoup:解析HTML用法小结 原文 http://my ... -
license生成
2015-03-02 10:44 509package com.dameng.dmdp.utils; ... -
java 堆和栈
2014-11-27 15:18 4991.栈(stack)与堆(heap)都是J ... -
java内部类、静态内部类 小结
2014-11-26 14:12 5191)首先,用内部类是因 ... -
java 23种设计模式
2014-11-19 14:56 569http://zz563143188.iteye.com/bl ... -
Java调用webservice接口方法
2014-11-19 14:36 4861. Java调用webservice接口方法 webserv ... -
java基本类型
2014-11-05 14:05 676基本类型比较 -
java修饰符权限
2014-11-05 13:58 573(1)public:可以被所有其他类所访问。 (2)priv ... -
类型转换
2014-11-05 13:44 475short s1 = 1; s1 = s1 + 1;有错,s1 ... -
Sring x = new String("xyz")
2014-11-05 13:32 482只要是new,都是重新分配堆空间,如果不区分栈和堆,这里创建了 ... -
java内部类和静态内部类调用
2014-06-23 14:06 519内部类 public class Test { clas ... -
匿名内部类
2014-06-18 15:00 410匿名内部类也就是没有 ... -
类的加载周期
2014-06-16 12:47 344类什么时候被加载/类加载时机: 第一:生成该类对象的时候,会 ... -
内部类
2014-05-05 14:43 469http://www.cnblogs.com/mengdd/a ...
相关推荐
java模式java模式
JAVA模式笔记,JAVA模式的读书笔记,JAVA模式的读书笔记。
Java技术丛书:Java模式,进阶必备
java模式一直是初学者的难题,原因并不是这东西多么深,只是没有合适的案例,本案例非常适合初学者掌握java模式的思想.总结了所有的java模式.
java模式 java深度历险 给大家带来了一本我认为很不错的书,你可以在里边了解许多关于java开发的模式,等等,很有用~~~~
java模式之单例模式.doc
java模式--模板模式实例代码,请参考我的博客:http://blog.csdn.net/yayun0516
JAVA模式与设计概念总结,绝对详细;JAVA模式与设计概念总结,绝对详细;
java 模式 设计 代理模式 ,动态代理跟反射机制的内容相关
Java模式匹配demo
java模式 详细讲解 想了解模式的人可以看看
java模式设计的经典练习和说明,包括常用的23种模式,如工厂模式
25种java模式代码参考手册,里面是图形界面,对有一点的经验的开发者不错
由于原著都是以C++为例, 以Java 为例的设计模式 基本又都以图形应用为例,而我们更关心Java 在中间件等服务器方面的应用,因此,本站 所有实例都是非图形应用,并且顺带剖析Jive 论坛系统.同时为降低理解难度,尽量避 免...
下载我发布的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的选手!!!!
一个有关JAVA模式设计的很好例子,包括代码实现和代码