java几种常用设计模式简单示例
2018-02-26 16:21
651 查看
1.单例设计模式 所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。具体实现步骤如下： (1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。 (2) 在其内部产生该类的实例化对象，并将其封装成private static类型。 (3) 定义一个静态方法返回该类的实例。 示例代码如下： Java代码
class Singleton {
private static Singleton instance = new Singleton();// 在内部产生本类的实例化对象
public static Singleton getInstance() { // 通过静态方法返回instance对象
return instance;
}
private Singleton() { // 将构造方法封装为私有化
}
public void print() {
System.out.println("Hello World!!!");
}
}
public class SingletonDemo {
public static void main(String args[]) {
Singleton s1 = null; // 声明对象
Singleton s2 = null; // 声明对象
Singleton s3 = null; // 声明对象
s1 = Singleton.getInstance(); // 取得实例化对象
s2 = Singleton.getInstance(); // 取得实例化对象
s3 = Singleton.getInstance(); // 取得实例化对象
s1.print(); // 调用方法
s2.print(); // 调用方法
s3.print(); // 调用方法
}
}
一、单例模式的介绍
Singleton是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点
二、单例模式的实现
实现的方式有如下四种：
Java代码
/**
*
* 单例模式的实现：饿汉式,线程安全 但效率比较低
*/
public class SingletonTest {
private SingletonTest() {
}
private static final SingletonTest instance = new SingletonTest();
public static SingletonTest getInstancei() {
return instance;
}
}
[java] view plain copy/**
*
* 单例模式的实现：饿汉式,线程安全 但效率比较低
*/
public class SingletonTest {
private SingletonTest() {
}
private static final SingletonTest instance = new SingletonTest();
public static SingletonTest getInstancei() {
return instance;
}
}
Java代码
/**
* 单例模式的实现：饱汉式,非线程安全
*
*/
public class SingletonTest {
private SingletonTest() {
}
private static SingletonTest instance;
public static SingletonTest getInstance() {
if (instance == null)
instance = new SingletonTest();
return instance;
}
}
[java] view plain copy/**
* 单例模式的实现：饱汉式,非线程安全
*
*/
public class SingletonTest {
private SingletonTest() {
}
private static SingletonTest instance;
public static SingletonTest getInstance() {
if (instance == null)
instance = new SingletonTest();
return instance;
}
}
Java代码
/**
* 线程安全，但是效率非常低
* @author vanceinfo
*
*/
public class SingletonTest {
private SingletonTest() {
}
private static SingletonTest instance;
public static synchronized SingletonTest getInstance() {
if (instance == null)
instance = new SingletonTest();
return instance;
}
}
[java] view plain copy/**
* 线程安全，但是效率非常低
* @author vanceinfo
*
*/
public class SingletonTest {
private SingletonTest() {
}
private static SingletonTest instance;
public static synchronized SingletonTest getInstance() {
if (instance == null)
instance = new SingletonTest();
return instance;
}
}
Java代码
/**
* 线程安全 并且效率高
*
*/
public class SingletonTest {
private static SingletonTest instance;
private SingletonTest() {
}
public static SingletonTest getIstance() {
if (instance == null) {
synchronized (SingletonTest.class) {
if (instance == null) {
instance = new SingletonTest();
}
}
}
return instance;
}
}
2.工厂设计模式 程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。 示例代码如下：Java代码
interface Animal { // 定义一个动物的接口
public void say(); // 说话方法
}
class Cat implements Animal { // 定义子类Cat
@Override
public void say() { // 覆写say()方法
System.out.println("我是猫咪，喵呜！");
}
}
class Dog implements Animal { // 定义子类Dog
@Override
public void say() { // 覆写say()方法
System.out.println("我是小狗，汪汪！");
}
}
class Factory { // 定义工厂类
public static Animal getInstance(String className) {
Animal a = null; // 定义接口对象
if ("Cat".equals(className)) { // 判断是哪个子类的标记
a = new Cat(); // 通过Cat子类实例化接口
}
if ("Dog".equals(className)) { // 判断是哪个子类的标记
a = new Dog(); // 通过Dog子类实例化接口
}
return a;
}
}
public class FactoryDemo {
public static void main(String[] args) {
Animal a = null; // 定义接口对象
a = Factory.getInstance(args[0]); // 通过工厂获取实例
if (a != null) { // 判断对象是否为空
a.say(); // 调用方法
}
}
}
[java] view plain copyinterface Animal { // 定义一个动物的接口
public void say(); // 说话方法
}
class Cat implements Animal { // 定义子类Cat
@Override
public void say() { // 覆写say()方法
System.out.println("我是猫咪，喵呜！");
}
}
class Dog implements Animal { // 定义子类Dog
@Override
public void say() { // 覆写say()方法
System.out.println("我是小狗，汪汪！");
}
}
class Factory { // 定义工厂类
public static Animal getInstance(String className) {
Animal a = null; // 定义接口对象
if ("Cat".equals(className)) { // 判断是哪个子类的标记
a = new Cat(); // 通过Cat子类实例化接口
}
if ("Dog".equals(className)) { // 判断是哪个子类的标记
a = new Dog(); // 通过Dog子类实例化接口
}
return a;
}
}
public class FactoryDemo {
public static void main(String[] args) {
Animal a = null; // 定义接口对象
a = Factory.getInstance(args[0]); // 通过工厂获取实例
if (a != null) { // 判断对象是否为空
a.say(); // 调用方法
}
}
}
3.代理设计模式 指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。 示例代码如下：Java代码
interface Network { // 定义Network接口
public void browse(); // 定义浏览的抽象方法
}
class Real implements Network { // 真实的上网操作
public void browse() { // 覆写抽象方法
System.out.println("上网浏览信息！");
}
}
class Proxy implements Network { // 代理上网
private Network network;
public Proxy(Network network) {// 设置代理的真实操作
this.network = network; // 设置代理的子类
}
public void check() { // 身份验证操作
System.out.println("检查用户是否合法！");
}
public void browse() {
this.check(); // 调用具体的代理业务操作
this.network.browse(); // 调用真实的上网操作
}
}
public class ProxyDemo {
public static void main(String args[]) {
Network net = null; // 定义接口对象
net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作
net.browse(); // 调用代理的上网操作
}
}
[java] view plain copyinterface Network { // 定义Network接口
public void browse(); // 定义浏览的抽象方法
}
class Real implements Network { // 真实的上网操作
public void browse() { // 覆写抽象方法
System.out.println("上网浏览信息！");
}
}
class Proxy implements Network { // 代理上网
private Network network;
public Proxy(Network network) {// 设置代理的真实操作
this.network = network; // 设置代理的子类
}
public void check() { // 身份验证操作
System.out.println("检查用户是否合法！");
}
public void browse() {
this.check(); // 调用具体的代理业务操作
this.network.browse(); // 调用真实的上网操作
}
}
public class ProxyDemo {
public static void main(String args[]) {
Network net = null; // 定义接口对象
net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作
net.browse(); // 调用代理的上网操作
}
}
4.观察者设计模式 所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。 java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。 示例代码如下：Java代码
import java.util.Observable;
import java.util.Observer;
class House extends Observable {
private float price;
public void setPrice(float price) {
this.setChanged();// 设置变化点
this.notifyObservers(price);// 通知所有观察者价格改变
this.price = price;
}
public float getPrice() {
return this.price;
}
public House(float price) {
this.price = price;
}
public String toString() {
return "房子价格为: " + this.price;
}
}
class HousePriceObserver implements Observer {
private String name;
public HousePriceObserver(String name) {
super();
this.name = name;
}
@Override
public void update(Observable o, Object arg) {// 只要改变了 observable 对象就调用此方法
if (arg instanceof Float) {
System.out.println(this.name + "观察的价格更改为:"
+ ((Float) arg).floatValue());
}
}
}
public class ObserDeom {
public static void main(String[] args) {
House h = new House(1000000);
HousePriceObserver hpo1 = new HousePriceObserver("购房者A");
HousePriceObserver hpo2 = new HousePriceObserver("购房者B");
HousePriceObserver hpo3 = new HousePriceObserver("购房者C");
h.addObserver(hpo1);// 给房子注册观察者
h.addObserver(hpo2);// 给房子注册观察者
h.addObserver(hpo3);// 给房子注册观察者
System.out.println(h);// 输出房子价格
// 修改房子价格，会触发update(Observable o, Object arg)方法通知购房者新的房价信息
h.setPrice(2222222);//
System.out.println(h);// 再次输出房子价格
}
}
[java] view plain copyimport java.util.Observable;
import java.util.Observer;
class House extends Observable {
private float price;
public void setPrice(float price) {
this.setChanged();// 设置变化点
this.notifyObservers(price);// 通知所有观察者价格改变
this.price = price;
}
public float getPrice() {
return this.price;
}
public House(float price) {
this.price = price;
}
public String toString() {
return "房子价格为: " + this.price;
}
}
class HousePriceObserver implements Observer {
private String name;
public HousePriceObserver(String name) {
super();
this.name = name;
}
@Override
public void update(Observable o, Object arg) {// 只要改变了 observable 对象就调用此方法
if (arg instanceof Float) {
System.out.println(this.name + "观察的价格更改为:"
+ ((Float) arg).floatValue());
}
}
}
public class ObserDeom {
public static void main(String[] args) {
House h = new House(1000000);
HousePriceObserver hpo1 = new HousePriceObserver("购房者A");
HousePriceObserver hpo2 = new HousePriceObserver("购房者B");
HousePriceObserver hpo3 = new HousePriceObserver("购房者C");
h.addObserver(hpo1);// 给房子注册观察者
h.addObserver(hpo2);// 给房子注册观察者
h.addObserver(hpo3);// 给房子注册观察者
System.out.println(h);// 输出房子价格
// 修改房子价格，会触发update(Observable o, Object arg)方法通知购房者新的房价信息
h.setPrice(2222222);//
System.out.println(h);// 再次输出房子价格
}
}
5.适配器模式 如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类。 示例代码如下：Java代码
interface Window {// 定义Window窗口接口，表示窗口操作
public void open();// 窗口打开
public void close();// 窗口关闭
public void iconified();// 窗口最小化
public void deiconified();// 窗口恢复
public void activated();// 窗口活动
}
// 定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空
abstract class WindowAdapter implements Window {
public void open() {
};// 窗口打开
public void close() {
};// 窗口关闭
public void iconified() {
};// 窗口最小化
public void deiconified() {
};// 窗口恢复
public void activated() {
};// 窗口活动
}
// 子类继承WindowAdapter抽象类，选择性实现需要的方法
class WindowImpl extends WindowAdapter {
public void open() {
System.out.println("窗口打开");// 实现open()方法
}
public void close() {
System.out.println("窗口关闭");// 实现close()方法
}
}
public class AdapterDemo {
public static void main(String args[]) {
Window win = new WindowImpl(); // 实现接口对象
// 调用方法
win.open();
win.close();
}
}
[java] view plain copyinterface Window {// 定义Window窗口接口，表示窗口操作
public void open();// 窗口打开
public void close();// 窗口关闭
public void iconified();// 窗口最小化
public void deiconified();// 窗口恢复
public void activated();// 窗口活动
}
// 定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空
abstract class WindowAdapter implements Window {
public void open() {
};// 窗口打开
public void close() {
};// 窗口关闭
public void iconified() {
};// 窗口最小化
public void deiconified() {
};// 窗口恢复
public void activated() {
};// 窗口活动
}
// 子类继承WindowAdapter抽象类，选择性实现需要的方法
class WindowImpl extends WindowAdapter {
public void open() {
System.out.println("窗口打开");// 实现open()方法
}
public void close() {
System.out.println("窗口关闭");// 实现close()方法
}
}
public class AdapterDemo {
public static void main(String args[]) {
Window win = new WindowImpl(); // 实现接口对象
// 调用方法
win.open();
win.close();
}
}
----------------------------------------------------------------初学水平有限，错误之处难免，览者勿讽！参考资料：java开发实战经典。 ------------------------------------------------------------------------------------ PART A：前言平常我们都在敲代码，为了要实现一些我们希望看到的功能，敲一大堆一大堆。往往就会忽略了这样的一个问题。你会问敲代码就让我们老老实实的敲代码吧，为什么要那么麻烦的去考虑那么多？当然了现在这样一说你肯定会回答我们肯定不可能就一心只会死头死脑的无脑敲代码啊。是吧？那么我们还要考虑一些什么事情呢？这么跟大家说吧，我们现在敲代码做项目就像做房子，现在我们做的事情是，一块一块的不断的垒砖块，无脑垒。而不管他垒的好不好看美不美观，也不管他消耗的砖块是否太多。是不是？再打个比方，从小学起我们就开始拿着笔写作文。刚刚开始那个时候，还记得自己是怎么写作文的么？是不是照着课本写？又或者就是写一些流水账似的东西？记得那个时候能够记两笔流水账已经能够让自己激动不已了是吧？呵呵。那你还记得是从什么时候开始，老师开始给你讲文章的结构文章的排篇布局，开始给你介绍各种诸如开门见山等等的文章写法的？今天就让我们回到那个时候。接下来我们开始接触一些比较常用的java设计模式。 PART B： B-1工厂模式你可以从网上找到许许多多关于这个（java设计模式）的文档与资料，如果你下载过看过不止四五份你就会发现，虽然他们的说法都有自己的一套，但是总是有千人一面的地方。而我要告诉你的是，这一面，就是你所需要的东西了。对于工厂模式而言，每个人都会有自己的体会与看法。就比如有的人说他是将代码按照其功能模块化了，也有人说他就是一个分配机制，好比把不同的工作交给不同的人去做一样，将对象的功能的实现交给一些特制的类去完成，等等等等。只要是接触过的人，就可以说出一种他的立场上看到的工厂模式。但是在这里我要告诉你的是，工厂模式他的关键是：将创建对象和使用对象分开。在这样的一个过程中不仅仅达到了理清编写者自己思路的作用，也使得代码脉络更加清晰明朗，简洁易懂。不知道大家还记不记得曾经讲哈夫曼树的时候那棵充斥我们一个多礼拜的哈夫曼树？我想说，现在这棵树是没了，但是重新出现了一座庞大的工厂……在这个工厂里边分工明确权责分明，他的每一个子工厂都只负责生产某一种特别的产品，而每一种产品也对应着每一个子工厂的生产线。现在只要想编写一个程序，就不知道绝的先考虑将它“工厂化”，将它的每一个步骤每一个功能先大卸八块的区分清楚，然后才开始代码的实际编写工作……好了，闲话就不多说了，下面我们就通过实例来讲讲什么是创建对象和使用对象分开。（例）比如我想造一辆宝马车并让它跑起来，以前我们都是写一个宝马车的类然后直接在这个类里边实例化一个他的对象，完了以后紧接着在下边写宝马车的跑的方法，是吧？但是工厂模式不这么做，工厂模式怎么做呢？请看下面的步骤：1.写一个车的接口，并在里边定义一个车的go()方法：
class Singleton {
private static Singleton instance = new Singleton();// 在内部产生本类的实例化对象
public static Singleton getInstance() { // 通过静态方法返回instance对象
return instance;
}
private Singleton() { // 将构造方法封装为私有化
}
public void print() {
System.out.println("Hello World!!!");
}
}
public class SingletonDemo {
public static void main(String args[]) {
Singleton s1 = null; // 声明对象
Singleton s2 = null; // 声明对象
Singleton s3 = null; // 声明对象
s1 = Singleton.getInstance(); // 取得实例化对象
s2 = Singleton.getInstance(); // 取得实例化对象
s3 = Singleton.getInstance(); // 取得实例化对象
s1.print(); // 调用方法
s2.print(); // 调用方法
s3.print(); // 调用方法
}
}
一、单例模式的介绍
Singleton是一种创建型模式，指某个类采用Singleton模式，则在这个类被创建后，只可能产生一个实例供外部访问，并且提供一个全局的访问点
二、单例模式的实现
实现的方式有如下四种：
Java代码
/**
*
* 单例模式的实现：饿汉式,线程安全 但效率比较低
*/
public class SingletonTest {
private SingletonTest() {
}
private static final SingletonTest instance = new SingletonTest();
public static SingletonTest getInstancei() {
return instance;
}
}
[java] view plain copy/**
*
* 单例模式的实现：饿汉式,线程安全 但效率比较低
*/
public class SingletonTest {
private SingletonTest() {
}
private static final SingletonTest instance = new SingletonTest();
public static SingletonTest getInstancei() {
return instance;
}
}
Java代码
/**
* 单例模式的实现：饱汉式,非线程安全
*
*/
public class SingletonTest {
private SingletonTest() {
}
private static SingletonTest instance;
public static SingletonTest getInstance() {
if (instance == null)
instance = new SingletonTest();
return instance;
}
}
[java] view plain copy/**
* 单例模式的实现：饱汉式,非线程安全
*
*/
public class SingletonTest {
private SingletonTest() {
}
private static SingletonTest instance;
public static SingletonTest getInstance() {
if (instance == null)
instance = new SingletonTest();
return instance;
}
}
Java代码
/**
* 线程安全，但是效率非常低
* @author vanceinfo
*
*/
public class SingletonTest {
private SingletonTest() {
}
private static SingletonTest instance;
public static synchronized SingletonTest getInstance() {
if (instance == null)
instance = new SingletonTest();
return instance;
}
}
[java] view plain copy/**
* 线程安全，但是效率非常低
* @author vanceinfo
*
*/
public class SingletonTest {
private SingletonTest() {
}
private static SingletonTest instance;
public static synchronized SingletonTest getInstance() {
if (instance == null)
instance = new SingletonTest();
return instance;
}
}
Java代码
/**
* 线程安全 并且效率高
*
*/
public class SingletonTest {
private static SingletonTest instance;
private SingletonTest() {
}
public static SingletonTest getIstance() {
if (instance == null) {
synchronized (SingletonTest.class) {
if (instance == null) {
instance = new SingletonTest();
}
}
}
return instance;
}
}
2.工厂设计模式 程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。 示例代码如下：Java代码
interface Animal { // 定义一个动物的接口
public void say(); // 说话方法
}
class Cat implements Animal { // 定义子类Cat
@Override
public void say() { // 覆写say()方法
System.out.println("我是猫咪，喵呜！");
}
}
class Dog implements Animal { // 定义子类Dog
@Override
public void say() { // 覆写say()方法
System.out.println("我是小狗，汪汪！");
}
}
class Factory { // 定义工厂类
public static Animal getInstance(String className) {
Animal a = null; // 定义接口对象
if ("Cat".equals(className)) { // 判断是哪个子类的标记
a = new Cat(); // 通过Cat子类实例化接口
}
if ("Dog".equals(className)) { // 判断是哪个子类的标记
a = new Dog(); // 通过Dog子类实例化接口
}
return a;
}
}
public class FactoryDemo {
public static void main(String[] args) {
Animal a = null; // 定义接口对象
a = Factory.getInstance(args[0]); // 通过工厂获取实例
if (a != null) { // 判断对象是否为空
a.say(); // 调用方法
}
}
}
[java] view plain copyinterface Animal { // 定义一个动物的接口
public void say(); // 说话方法
}
class Cat implements Animal { // 定义子类Cat
@Override
public void say() { // 覆写say()方法
System.out.println("我是猫咪，喵呜！");
}
}
class Dog implements Animal { // 定义子类Dog
@Override
public void say() { // 覆写say()方法
System.out.println("我是小狗，汪汪！");
}
}
class Factory { // 定义工厂类
public static Animal getInstance(String className) {
Animal a = null; // 定义接口对象
if ("Cat".equals(className)) { // 判断是哪个子类的标记
a = new Cat(); // 通过Cat子类实例化接口
}
if ("Dog".equals(className)) { // 判断是哪个子类的标记
a = new Dog(); // 通过Dog子类实例化接口
}
return a;
}
}
public class FactoryDemo {
public static void main(String[] args) {
Animal a = null; // 定义接口对象
a = Factory.getInstance(args[0]); // 通过工厂获取实例
if (a != null) { // 判断对象是否为空
a.say(); // 调用方法
}
}
}
3.代理设计模式 指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。 示例代码如下：Java代码
interface Network { // 定义Network接口
public void browse(); // 定义浏览的抽象方法
}
class Real implements Network { // 真实的上网操作
public void browse() { // 覆写抽象方法
System.out.println("上网浏览信息！");
}
}
class Proxy implements Network { // 代理上网
private Network network;
public Proxy(Network network) {// 设置代理的真实操作
this.network = network; // 设置代理的子类
}
public void check() { // 身份验证操作
System.out.println("检查用户是否合法！");
}
public void browse() {
this.check(); // 调用具体的代理业务操作
this.network.browse(); // 调用真实的上网操作
}
}
public class ProxyDemo {
public static void main(String args[]) {
Network net = null; // 定义接口对象
net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作
net.browse(); // 调用代理的上网操作
}
}
[java] view plain copyinterface Network { // 定义Network接口
public void browse(); // 定义浏览的抽象方法
}
class Real implements Network { // 真实的上网操作
public void browse() { // 覆写抽象方法
System.out.println("上网浏览信息！");
}
}
class Proxy implements Network { // 代理上网
private Network network;
public Proxy(Network network) {// 设置代理的真实操作
this.network = network; // 设置代理的子类
}
public void check() { // 身份验证操作
System.out.println("检查用户是否合法！");
}
public void browse() {
this.check(); // 调用具体的代理业务操作
this.network.browse(); // 调用真实的上网操作
}
}
public class ProxyDemo {
public static void main(String args[]) {
Network net = null; // 定义接口对象
net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作
net.browse(); // 调用代理的上网操作
}
}
4.观察者设计模式 所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。 java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。 示例代码如下：Java代码
import java.util.Observable;
import java.util.Observer;
class House extends Observable {
private float price;
public void setPrice(float price) {
this.setChanged();// 设置变化点
this.notifyObservers(price);// 通知所有观察者价格改变
this.price = price;
}
public float getPrice() {
return this.price;
}
public House(float price) {
this.price = price;
}
public String toString() {
return "房子价格为: " + this.price;
}
}
class HousePriceObserver implements Observer {
private String name;
public HousePriceObserver(String name) {
super();
this.name = name;
}
@Override
public void update(Observable o, Object arg) {// 只要改变了 observable 对象就调用此方法
if (arg instanceof Float) {
System.out.println(this.name + "观察的价格更改为:"
+ ((Float) arg).floatValue());
}
}
}
public class ObserDeom {
public static void main(String[] args) {
House h = new House(1000000);
HousePriceObserver hpo1 = new HousePriceObserver("购房者A");
HousePriceObserver hpo2 = new HousePriceObserver("购房者B");
HousePriceObserver hpo3 = new HousePriceObserver("购房者C");
h.addObserver(hpo1);// 给房子注册观察者
h.addObserver(hpo2);// 给房子注册观察者
h.addObserver(hpo3);// 给房子注册观察者
System.out.println(h);// 输出房子价格
// 修改房子价格，会触发update(Observable o, Object arg)方法通知购房者新的房价信息
h.setPrice(2222222);//
System.out.println(h);// 再次输出房子价格
}
}
[java] view plain copyimport java.util.Observable;
import java.util.Observer;
class House extends Observable {
private float price;
public void setPrice(float price) {
this.setChanged();// 设置变化点
this.notifyObservers(price);// 通知所有观察者价格改变
this.price = price;
}
public float getPrice() {
return this.price;
}
public House(float price) {
this.price = price;
}
public String toString() {
return "房子价格为: " + this.price;
}
}
class HousePriceObserver implements Observer {
private String name;
public HousePriceObserver(String name) {
super();
this.name = name;
}
@Override
public void update(Observable o, Object arg) {// 只要改变了 observable 对象就调用此方法
if (arg instanceof Float) {
System.out.println(this.name + "观察的价格更改为:"
+ ((Float) arg).floatValue());
}
}
}
public class ObserDeom {
public static void main(String[] args) {
House h = new House(1000000);
HousePriceObserver hpo1 = new HousePriceObserver("购房者A");
HousePriceObserver hpo2 = new HousePriceObserver("购房者B");
HousePriceObserver hpo3 = new HousePriceObserver("购房者C");
h.addObserver(hpo1);// 给房子注册观察者
h.addObserver(hpo2);// 给房子注册观察者
h.addObserver(hpo3);// 给房子注册观察者
System.out.println(h);// 输出房子价格
// 修改房子价格，会触发update(Observable o, Object arg)方法通知购房者新的房价信息
h.setPrice(2222222);//
System.out.println(h);// 再次输出房子价格
}
}
5.适配器模式 如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类。 示例代码如下：Java代码
interface Window {// 定义Window窗口接口，表示窗口操作
public void open();// 窗口打开
public void close();// 窗口关闭
public void iconified();// 窗口最小化
public void deiconified();// 窗口恢复
public void activated();// 窗口活动
}
// 定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空
abstract class WindowAdapter implements Window {
public void open() {
};// 窗口打开
public void close() {
};// 窗口关闭
public void iconified() {
};// 窗口最小化
public void deiconified() {
};// 窗口恢复
public void activated() {
};// 窗口活动
}
// 子类继承WindowAdapter抽象类，选择性实现需要的方法
class WindowImpl extends WindowAdapter {
public void open() {
System.out.println("窗口打开");// 实现open()方法
}
public void close() {
System.out.println("窗口关闭");// 实现close()方法
}
}
public class AdapterDemo {
public static void main(String args[]) {
Window win = new WindowImpl(); // 实现接口对象
// 调用方法
win.open();
win.close();
}
}
[java] view plain copyinterface Window {// 定义Window窗口接口，表示窗口操作
public void open();// 窗口打开
public void close();// 窗口关闭
public void iconified();// 窗口最小化
public void deiconified();// 窗口恢复
public void activated();// 窗口活动
}
// 定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空
abstract class WindowAdapter implements Window {
public void open() {
};// 窗口打开
public void close() {
};// 窗口关闭
public void iconified() {
};// 窗口最小化
public void deiconified() {
};// 窗口恢复
public void activated() {
};// 窗口活动
}
// 子类继承WindowAdapter抽象类，选择性实现需要的方法
class WindowImpl extends WindowAdapter {
public void open() {
System.out.println("窗口打开");// 实现open()方法
}
public void close() {
System.out.println("窗口关闭");// 实现close()方法
}
}
public class AdapterDemo {
public static void main(String args[]) {
Window win = new WindowImpl(); // 实现接口对象
// 调用方法
win.open();
win.close();
}
}
----------------------------------------------------------------初学水平有限，错误之处难免，览者勿讽！参考资料：java开发实战经典。 ------------------------------------------------------------------------------------ PART A：前言平常我们都在敲代码，为了要实现一些我们希望看到的功能，敲一大堆一大堆。往往就会忽略了这样的一个问题。你会问敲代码就让我们老老实实的敲代码吧，为什么要那么麻烦的去考虑那么多？当然了现在这样一说你肯定会回答我们肯定不可能就一心只会死头死脑的无脑敲代码啊。是吧？那么我们还要考虑一些什么事情呢？这么跟大家说吧，我们现在敲代码做项目就像做房子，现在我们做的事情是，一块一块的不断的垒砖块，无脑垒。而不管他垒的好不好看美不美观，也不管他消耗的砖块是否太多。是不是？再打个比方，从小学起我们就开始拿着笔写作文。刚刚开始那个时候，还记得自己是怎么写作文的么？是不是照着课本写？又或者就是写一些流水账似的东西？记得那个时候能够记两笔流水账已经能够让自己激动不已了是吧？呵呵。那你还记得是从什么时候开始，老师开始给你讲文章的结构文章的排篇布局，开始给你介绍各种诸如开门见山等等的文章写法的？今天就让我们回到那个时候。接下来我们开始接触一些比较常用的java设计模式。 PART B： B-1工厂模式你可以从网上找到许许多多关于这个（java设计模式）的文档与资料，如果你下载过看过不止四五份你就会发现，虽然他们的说法都有自己的一套，但是总是有千人一面的地方。而我要告诉你的是，这一面，就是你所需要的东西了。对于工厂模式而言，每个人都会有自己的体会与看法。就比如有的人说他是将代码按照其功能模块化了，也有人说他就是一个分配机制，好比把不同的工作交给不同的人去做一样，将对象的功能的实现交给一些特制的类去完成，等等等等。只要是接触过的人，就可以说出一种他的立场上看到的工厂模式。但是在这里我要告诉你的是，工厂模式他的关键是：将创建对象和使用对象分开。在这样的一个过程中不仅仅达到了理清编写者自己思路的作用，也使得代码脉络更加清晰明朗，简洁易懂。不知道大家还记不记得曾经讲哈夫曼树的时候那棵充斥我们一个多礼拜的哈夫曼树？我想说，现在这棵树是没了，但是重新出现了一座庞大的工厂……在这个工厂里边分工明确权责分明，他的每一个子工厂都只负责生产某一种特别的产品，而每一种产品也对应着每一个子工厂的生产线。现在只要想编写一个程序，就不知道绝的先考虑将它“工厂化”，将它的每一个步骤每一个功能先大卸八块的区分清楚，然后才开始代码的实际编写工作……好了，闲话就不多说了，下面我们就通过实例来讲讲什么是创建对象和使用对象分开。（例）比如我想造一辆宝马车并让它跑起来，以前我们都是写一个宝马车的类然后直接在这个类里边实例化一个他的对象，完了以后紧接着在下边写宝马车的跑的方法，是吧？但是工厂模式不这么做，工厂模式怎么做呢？请看下面的步骤：1.写一个车的接口，并在里边定义一个车的go()方法：
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java几种常用设计模式简单示例
- java中几种常用的设计模式及其实现
- 由浅入深，带你玩转几种常用java设计模式
- C++简单实现几种常用的设计模式
- Java的几种常用设计模式
- Java常用的几种设计模式
- Java常用的几种设计模式
- java 常用十种设计模式示例归纳 | 已打包请带走