java几种常用设计模式简单示例

1.单例设计模式

所谓单例设计模式简单说就是无论程序如何运行，采用单例设计模式的类（Singleton类）永远只会有一个实例化对象产生。具体实现步骤如下：

(1) 将采用单例设计模式的类的构造方法私有化（采用private修饰）。

(2) 在其内部产生该类的实例化对象，并将其封装成private static类型。

(3) 定义一个静态方法返回该类的实例。

示例代码如下：

[java] view plaincopy

  1. class Singleton {
  2. private static Singleton instance = new Singleton();// 在内部产生本类的实例化对象
  3. public static Singleton getInstance() { // 通过静态方法返回instance对象
  4. return instance;
  5. }
  6. private Singleton() { // 将构造方法封装为私有化
  7. }
  8. public void print() {
  9. System.out.println("Hello World!!!");
  10. }
  11. }
  12. public class SingletonDemo {
  13. public static void main(String args[]) {
  14. Singleton s1 = null; // 声明对象
  15. Singleton s2 = null; // 声明对象
  16. Singleton s3 = null; // 声明对象
  17. s1 = Singleton.getInstance(); // 取得实例化对象
  18. s2 = Singleton.getInstance(); // 取得实例化对象
  19. s3 = Singleton.getInstance(); // 取得实例化对象
  20. s1.print(); // 调用方法
  21. s2.print(); // 调用方法
  22. s3.print(); // 调用方法
  23. }
  24. }

单例模式的实现

[java] view plaincopy

  1. /**
  2. *
  3. * 单例模式的实现：饿汉式,线程安全 但效率比较低
  4. */
  5. public class SingletonTest {
  6. private SingletonTest() {
  7. }
  8. private static final SingletonTest instance = new SingletonTest();
  9. public static SingletonTest getInstancei() {
  10. return instance;
  11. }
  12. }

[java] view plaincopy

  1. /**
  2. * 单例模式的实现：懒汉式,非线程安全
  3. *
  4. */
  5. public class SingletonTest {
  6. private SingletonTest() {
  7. }
  8. private static SingletonTest instance;
  9. public static SingletonTest getInstance() {
  10. if (instance == null)
  11. instance = new SingletonTest();
  12. return instance;
  13. }
  14. }

[java] view plaincopy

  1. /**
  2. * 线程安全，但是效率非常低
  3. * @author vanceinfo
  4. *
  5. */
  6. public class SingletonTest {
  7. private SingletonTest() {
  8. }
  9. private static SingletonTest instance;
  10. public static synchronized SingletonTest getInstance() {
  11. if (instance == null)
  12. instance = new SingletonTest();
  13. return instance;
  14. }
  15. }

[java] view plaincopy

  1. /**
  2. * 线程安全  并且效率高
  3. *
  4. */
  5. public class SingletonTest {
  6. private static SingletonTest instance;
  7. private SingletonTest() {
  8. }
  9. public static SingletonTest getIstance() {
  10. if (instance == null) {
  11. synchronized (SingletonTest.class) {
  12. if (instance == null) {
  13. instance = new SingletonTest();
  14. }
  15. }
  16. }
  17. return instance;
  18. }
  19. }

2.工厂设计模式

程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。

示例代码如下：

[java] view plaincopy

  1. interface Animal { // 定义一个动物的接口
  2. public void say(); // 说话方法
  3. }
  4. class Cat implements Animal { // 定义子类Cat
  5. @Override
  6. public void say() { // 覆写say()方法
  7. System.out.println("我是猫咪，喵呜！");
  8. }
  9. }
  10. class Dog implements Animal { // 定义子类Dog
  11. @Override
  12. public void say() { // 覆写say()方法
  13. System.out.println("我是小狗，汪汪！");
  14. }
  15. }
  16. class Factory { // 定义工厂类
  17. public static Animal getInstance(String className) {
  18. Animal a = null; // 定义接口对象
  19. if ("Cat".equals(className)) { // 判断是哪个子类的标记
  20. a = new Cat(); // 通过Cat子类实例化接口
  21. }
  22. if ("Dog".equals(className)) { // 判断是哪个子类的标记
  23. a = new Dog(); // 通过Dog子类实例化接口
  24. }
  25. return a;
  26. }
  27. }
  28. public class FactoryDemo {
  29. public static void main(String[] args) {
  30. Animal a = null; // 定义接口对象
  31. a = Factory.getInstance(args[0]); // 通过工厂获取实例
  32. if (a != null) { // 判断对象是否为空
  33. a.say(); // 调用方法
  34. }
  35. }
  36. }

 3.代理设计模式

指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

示例代码如下：

[java] view plaincopy

  1. interface Network { // 定义Network接口
  2. public void browse(); // 定义浏览的抽象方法
  3. }
  4. class Real implements Network { // 真实的上网操作
  5. public void browse() { // 覆写抽象方法
  6. System.out.println("上网浏览信息！");
  7. }
  8. }
  9. class Proxy implements Network { // 代理上网
  10. private Network network;
  11. public Proxy(Network network) {// 设置代理的真实操作
  12. this.network = network; // 设置代理的子类
  13. }
  14. public void check() { // 身份验证操作
  15. System.out.println("检查用户是否合法！");
  16. }
  17. public void browse() {
  18. this.check(); // 调用具体的代理业务操作
  19. this.network.browse(); // 调用真实的上网操作
  20. }
  21. }
  22. public class ProxyDemo {
  23. public static void main(String args[]) {
  24. Network net = null; // 定义接口对象
  25. net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作
  26. net.browse(); // 调用代理的上网操作
  27. }
  28. }

4.观察者设计模式

所谓观察者模式，举个例子现在许多购房者都密切观察者房价的变化，当房价变化时，所有购房者都能观察到，以上的购房者属于观察者，这便是观察者模式。

java中可以借助Observable类和Observer接口轻松实现以上功能。当然此种模式的实现也不仅仅局限于采用这两个类。

示例代码如下：

[java] view plaincopy

  1. import java.util.Observable;
  2. import java.util.Observer;
  3. class House extends Observable {
  4. private float price;
  5. public void setPrice(float price) {
  6. this.setChanged();// 设置变化点
  7. this.notifyObservers(price);// 通知所有观察者价格改变
  8. this.price = price;
  9. }
  10. public float getPrice() {
  11. return this.price;
  12. }
  13. public House(float price) {
  14. this.price = price;
  15. }
  16. public String toString() {
  17. return "房子价格为: " + this.price;
  18. }
  19. }
  20. class HousePriceObserver implements Observer {
  21. private String name;
  22. public HousePriceObserver(String name) {
  23. super();
  24. this.name = name;
  25. }
  26. @Override
  27. public void update(Observable o, Object arg) {// 只要改变了 observable 对象就调用此方法
  28. if (arg instanceof Float) {
  29. System.out.println(this.name + "观察的价格更改为:"
  30. + ((Float) arg).floatValue());
  31. }
  32. }
  33. }
  34. public class ObserDeom {
  35. public static void main(String[] args) {
  36. House h = new House(1000000);
  37. HousePriceObserver hpo1 = new HousePriceObserver("购房者A");
  38. HousePriceObserver hpo2 = new HousePriceObserver("购房者B");
  39. HousePriceObserver hpo3 = new HousePriceObserver("购房者C");
  40. h.addObserver(hpo1);// 给房子注册观察者
  41. h.addObserver(hpo2);// 给房子注册观察者
  42. h.addObserver(hpo3);// 给房子注册观察者
  43. System.out.println(h);// 输出房子价格
  44. // 修改房子价格，会触发update(Observable o, Object arg)方法通知购房者新的房价信息
  45. h.setPrice(2222222);//
  46. System.out.println(h);// 再次输出房子价格
  47. }
  48. }

 5.适配器模式

如果一个类要实现一个具有很多抽象方法的接口，但是本身只需要实现接口中的部分方法便可以达成目的，所以此时就需要一个中间的过渡类，但此过渡类又不希望直接使用，所以将此类定义为抽象类最为合适，再让以后的子类直接继承该抽象类便可选择性的覆写所需要的方法，而此抽象类便是适配器类。

示例代码如下：

[java] view plaincopy

  1. interface Window {// 定义Window窗口接口，表示窗口操作
  2. public void open();// 窗口打开
  3. public void close();// 窗口关闭
  4. public void iconified();// 窗口最小化
  5. public void deiconified();// 窗口恢复
  6. public void activated();// 窗口活动
  7. }
  8. // 定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空
  9. abstract class WindowAdapter implements Window {
  10. public void open() {
  11. };// 窗口打开
  12. public void close() {
  13. };// 窗口关闭
  14. public void iconified() {
  15. };// 窗口最小化
  16. public void deiconified() {
  17. };// 窗口恢复
  18. public void activated() {
  19. };// 窗口活动
  20. }
  21. // 子类继承WindowAdapter抽象类，选择性实现需要的方法
  22. class WindowImpl extends WindowAdapter {
  23. public void open() {
  24. System.out.println("窗口打开");// 实现open()方法
  25. }
  26. public void close() {
  27. System.out.println("窗口关闭");// 实现close()方法
  28. }
  29. }
  30. public class AdapterDemo {
  31. public static void main(String args[]) {
  32. Window win = new WindowImpl(); // 实现接口对象
  33. // 调用方法
  34. win.open();
  35. win.close();
  36. }
  37. }

http://blog.csdn.net/haoxingfeng/article/details/9191619

时间： 2024-10-13 00:58:49

java几种常用设计模式简单示例的相关文章

Java几种常用的实现排序方法

import java.util.Random; public class NumberSort{ /** * 私有构造方法,禁止实例化 */ private NumberSort(){ super(); } /** * 冒泡排序 * 比较相邻的元素.如果第一个比第二个大,就叫唤他们两个位置. * 对每一组相邻的元素作同样的工作,从开始的第一对到结束后的最后一对,这样剩下的最后一个应该是最大的数. * 针对所有元素重复以上操作,除了最后一个. * 持续对越来越少的数进行以上的操作,直到没有任何一

Java研究之学习设计模式-简单工厂模式详解

 简介: 从设计模式的类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一.简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例. 类图: 从UML类图中,可以看出,简单工厂模式的意思,就是把一个类内部,需要生成的部分,提取出来,变为一个工厂,通过工厂来new对象. 假设我们要吃苹果了,我们可以在代码中new一个苹果出来:当我们需要吃香蕉了,我们在代码中new一个香蕉出来.这种做法你会不会觉得麻烦

java学习之三种常用设计模式

一.适配器设计模式 简单来说,就是通过一个间接类来选择性的来覆写一个接口 interface Window{ public void open() ; // 打开窗口 public void close() ; // 关闭窗口 public void icon() ; // 最小化 public void unicon() ; // 最大化 } abstract class WindowAdapter implements Window{ public void open(){} public

常用设计模式 简单实例

1.单例设计模式 所谓单例设计模式简单说就是无论程序如何运行,采用单例设计模式的类(Singleton类)永远只会有一个实例化对象产生.具体实现步骤如下: (1) 将采用单例设计模式的类的构造方法私有化(采用private修饰). (2) 在其内部产生该类的实例化对象,并将其封装成private static类型. (3) 定义一个静态方法返回该类的实例. 示例代码如下: Java代码   class Singleton { private static Singleton instance =

PHP V5 的五种常用设计模式

设计模式 一书将设计模式引入软件社区,该书的作者是 Erich Gamma.Richard Helm.Ralph Johnson 和 John Vlissides Design(俗称 "四人帮").所介绍的设计模式背后的核心概念非常简单.经过多年的软件开发实践,Gamma 等人发现了某些具有固定设计的模式,就像建筑师设计房子和建筑物一样,可以为浴室的位置或厨房的构造方式开发模板.使用这些模板或者说设计模式 意味着可以更快地设计更好的建筑物.同样的概念也适用于软件. 设计模式不仅代表着更

23种常用设计模式的UML类图

本文UML类图参考<Head First 设计模式>(源码)与<设计模式:可复用面向对象软件的基础>(源码)两书中介绍的设计模式与UML图. 整理常用设计模式的类图,一方面是为了练习UML,另一方面可以重新思考设计模式.当然,整理完成后可以作为一份手册供今后翻阅. 绘图工具:Visual Studio 2015 一.创建型 Factory Method(工厂方法) 定义:定义了一个创建对象的接口,但由子类决定要实例化的类是哪一个.工厂方法让类把实例化推迟到子类. 类图: Abstr

java 几种常见的简单设计模式

前言: 设计模式(Design pattern)是一套被反复使用.多数人知晓的.经过分类编目的.代码设计经验的总结.用于解决特定环境下.重复出现的特定问题的解决方案.使用设计模式是为了可重用代码.让代码更容易被他人理解.保证代码可靠性. 毫无疑问,设计模式于己于他人于系统都是多赢的,设计模式使代码编制真正工程化,设计模式是软件工程的基石,如同大厦的一块块砖石一样.项目中合理的运用设计模式可以完美的解决很多问题,每种模式在现在中都有相应的原理来与之对应,每一个模式描述了一个在我们周围不断重复发生的

Java中几种常用设计模式

一:抽象工厂模式 工厂模式指的是,围绕一个超级工厂创建其他工厂.该超级工厂又称为其他工厂的工厂.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式.在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类.每个生成的工厂都能按照工厂模式提供对象. 1 /** 2 * 绘画接口 3 */ 4 public interface Color{ 5 //填充颜色 6 void fill(); 7 } 8 9 10 11 /** 12 * 形状接口 13 */ 14 pub

java swing几种常用容器简单实现

一:分隔面板 JSplitPanel 代码: import javax.swing.JFrame ; import javax.swing.JButton ; import javax.swing.JLabel ; import javax.swing.JPanel ; import javax.swing.JSplitPane ; import java.awt.Container ; class Tester { public static void main(String args[])