Java中几种常用设计模式

一：抽象工厂模式　

　　工厂模式指的是，围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

  1 /**
  2  * 绘画接口
  3  */
  4 public interface Color{
  5     //填充颜色
  6     void fill();
  7 }
  8
  9
 10
 11 /**
 12  * 形状接口
 13  */
 14 public interface Shape{
 15     //绘画形状
 16     void draw();
 17 }
 18
 19
 20
 21 public class GreenColor implements Color{//Color的实现类
 22     public void fill(){
 23         System.out.println("绿色---");
 24     }
 25 }
 26 public class RedColor implements Color{//Color的实现类
 27     public void fill(){
 28         System.out.println("红色---");
 29     }
 30 }
 31
 32
 33
 34
 35 public class TriangleShape implements Shape{//Shape的实现类
 36     public void draw(){
 37         System.out.println("三角形---");
 38     }
 39 }
 40 public class CircleShape implements Shape{//Shape的实现类
 41     public void draw(){
 42         System.out.println("圆形---");
 43     }
 44 }
 45
 46
 47
 48 /**
 49  * 抽象工厂，构造两个接口
 50  */
 51 public abstract class AbstractFactory {
 52     public abstract Color getColor(String color) ;//根据颜色字符串得到哪种对象
 53     public abstract Shape getShape(String shape) ;//根据形状字符串得到哪种对象
 54 }
 55
 56
 57
 58 public  class ColorFactory extends AbstractFactory{//颜色工厂继承抽象工厂
 59     public Color getColor(String color) {//根据颜色字符串得到哪种对象
 60         if(null == color){return null;}
 61         if ( "red".equalsIgnoreCase(color) ){
 62             return new RedColor();//实例化一个RedColor对象
 63         }else if ( "green".equalsIgnoreCase(color)){
 64             return new GreenColor();//实例化一个GreenColor对象
 65         }
 66         return null;
 67     }
 68     public Shape getShape(String shape){ ;//根据形状字符串得到哪种对象
 69         return null;
 70     }
 71 }
 72
 73
 74
 75 public  class ShapeFactory extends AbstractFactory{//形状工厂继承抽象工厂
 76     public Color getColor(String color) {//根据颜色字符串得到哪种对象
 77         return null;
 78     }
 79     public Shape getShape(String shape){ ;//根据形状字符串得到哪种对象
 80         if(null == shape){return null;}
 81         if ( "triangle".equalsIgnoreCase(shape) ){
 82             return new CircleShape();//实例化一个CircleShape对象
 83         }else if ( "circle".equalsIgnoreCase(shape)){
 84             return new TriangleShape ();//实例化一个TriangleShape 对象
 85         }
 86         return null;
 87     }
 88 }
 89
 90
 91
 92 public  class FactoryBuilder{//父工厂,构建具体工厂对象
 93     public static AbstractFactory getFactory(String factory){
 94         if ( "colorfactory".equalsIgnoreCase(factory) ){
 95             return new ColorFactory();
 96         }else if ( "shapefactory".equalsIgnoreCase(factory) ){
 97             return new ShapeFactory();
 98         }
 99         return null;
100     }
101 }
102
103
104
105 /**
106  * 抽象工厂模式测试类
107  */
108 public class AbstractFactoryPattern {
109     public static void main (String [] args){
110         //获取颜色工厂
111         AbstractFactory af = FactoryBuilder.getFactory("colorfactory");
112         //创建红色对象
113         Color red = af.getColor("red");
114         //输出信息
115         red.fill();
116         //创建红色对象
117         Color green = af.getColor("green");
118         //输出信息
119         green.fill();
120
121         System.out.println("分割线---------------------------");
122
123         AbstractFactory abstractFactory = FactoryBuilder.getFactory("shapefactory");
124         Shape circle = abstractFactory.getShape("CIRCLE");
125         circle.draw();
126         Shape triangle = abstractFactory.getShape("triangle");
127         triangle.draw();
128     }
129 }

二：代理设计模式

　　代理模式指给一个对象提供一个代理对象，并由代理对象控制对原对象的引用。代理可以分为静态代理和动态代理。 
通过代理模式，可以利用代理对象为被代理对象添加额外的功能，以此来拓展被代理对象的功能。可以用于计算某个方法执行时间，在某个方法执行前后记录日志等操作。

三：单例设计模式

　　单例模式指的是，一个类只允许创建一个实例化对象，分为懒汉模式与恶汉模式。

　　　　饿汉式：构造方法私有化，外部无法产生新的实例化对象，只能通过static方法取得实例化对象。不存在线程安全的问题。

 1 public class TestSingleton{
 2   //构造方法私有化
 3   private TestSingleton(){}
 4   //类加载时，创建一个实例化对象
 5   private static final TestSingleton testSingleton = new TestSingleton();
 6   //提供一个对外的方法 ， 返回对象实例
 7   public static TestSingleton getTestSingleton(){
 8       return testSingleton;
 9   }
10 }

　　　　懒汉式：需要加上同步锁，同步锁影响了程序执行效率。

　　　　　　1）、双重if判断

 1 public class TestSingleton{
 2
 3   /**
 4    * volatile的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略，
 5    * 且要求每次直接读值。
 6    * volatile让变量每次在使用的时候，都从主存中取。而不是从各个线程的“工作内存”。
 7    *       声明对象变量
 8    *  volatile 禁止指令重排 主要由于new TestSingleton();可能出现问题
 9    */
10   private static volatile TestSingleton testSingleton = null ;
11
12   //构造方法私有化
13   private TestSingleton(){}
14
15   /**
16    * 提供一个对外的方法 ， 返回对象实例
17    * 双重 if 校验锁 (synchronized) 保证线程安全。
18    */
19   public staticTestSingleton getTestSingleton(){
20       //if判断，该对象还未实例化
21       if ( testSingleton == null ){
22           //加锁
23           synchronized (TestSingleton.class){
24               //if判断，该对象还未实例化
25               if ( testSingleton == null ){
26                  testSingleton = new TestSingleton();
27               }
28           }
29       }
30       return testSingleton;    //返回实例对象
31   }

　　　　　　2）、内部类

 1 public class TestSingleton{
 2
 3   //构造器私有化
 4   private TestSingleton(){}
 5
 6   //静态内部类，在其中  实例化 私有的 静态的 外部类对象
 7   private static class InternalClass{
 8      //实例化外部类对象
 9     private static final TestSingleton TESTSINGLETON = new TestSingleton();
10   }
11
12   //提供对外的方法
13   public static TestSingleton getTestSingleton(){
14     return InternalClass.TESTSINGLETON ;
15   }
16 }

四：建造者设计模式

　　建造者模式指的是，将各种产品集中起来管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性。

五：适配器设计模式

　　适配器模式是将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的的类的兼容性问题。主要分三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

六：MVC设计模式

　　适配器模式是将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的的类的兼容性问题。主要分三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

　　　　

原文地址：https://www.cnblogs.com/in-the-game-of-thrones/p/11186620.html

时间： 2024-12-08 11:10:56

Java中几种常用设计模式的相关文章

Java 中几种常用的线程池

Java 中几种常用的线程池 转载 : https://www.cnblogs.com/sachen/p/7401959.html 原创 2016年04月14日 23:29:01 标签: java / 线程池 / Executor 878 概述: 在java内置API中操作线程所用到的类为Thread.创建线程一般有两种方式, 继承Thread方式 实现Runnable方式,并以runnable作为target创建Thread 在Android中的耗时任务一般都需要另开线程来执行,常常需要用线程

java 中几种常用数据结构

Java中有几种常用的数据结构,主要分为Collection和map两个主要接口(接口只提供方法,并不提供实现),而程序中最终使用的数据结构是继承自这些接口的数据结构类. 一.几个常用类的区别 1．ArrayList: 元素单个,效率高,多用于查询 2．Vector: 元素单个,线程安全,多用于查询 3．LinkedList:元素单个,多用于插入和删除 4．HashMap: 元素成对,元素可为空 5．HashTable: 元素成对,线程安全,元素不可为空 二.Vector.ArrayList和L

Java中几种常用的设置小数点后位数的方法

记录下几种常用的控制小数点后位数的方法,除了这几种还有很多方法也可以控制,但是用得不常见,下面是比较常见的几种方法 使用BigDecimal类对超长数字进行格式化控制 使用DecimalFormat格式化十进制数字 使用printf格式化输出 具体实现 package _12_26_test; import java.math.BigDecimal; import java.math.BigInteger; import java.text.DecimalFormat; /*控制小数点后位数的几

JAVA中几种常用的RPC框架介绍

RPC是远程过程调用的简称,广泛应用在大规模分布式应用中,作用是有助于系统的垂直拆分,使系统更易拓展.Java中的RPC框架比较多,各有特色,广泛使用的有RMI.Hessian.Dubbo等.RPC还有一个特点就是能够跨语言,本文只以JAVA语言里的RPC为例. 对于RPC有一个逻辑关系图,以RMI为例: 其他的框架结构也类似,区别在于对象的序列化方法,传输对象的通讯协议,以及注册中心的管理与failover设计(利用zookeeper). 客户端和服务端可以运行在不同的JVM中,Client只

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

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

Java中13种设计模式汇总

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

笔记：Java中的单例设计模式

之前接触过单例模式,当初不明白这样的设计用意,今天特地研究了下java中的单例设计模式的用处及用法. 单例模式:单例模式是一种常用的软件设计模式.在它的核心结构中只包含一个被称为单例类的特殊类.一个类有且仅有一个实例,并且自行实例化向整个系统提供. 单例模式的用处:一个系统中可以存在多个打印任务,但是只能有一个正在工作的任务:一个系统只能有一个窗口管理器或文件系统:一个系统只能有一个计时工具或ID(序号)生成器.如在Windows中就只能打开一个任务管理器.如果不使用机制对窗口对象进行唯一化,将

java中四种引用类型

java中四种引用类型  今天看代码,里面有一个类java.lang.ref.SoftReference把小弟弄神了,试想一下,接触java已经有3年了哇,连lang包下面的类都不了解,怎么混.后来在网上查资料,感觉收获颇多,现记录如下. 对象的强.软.弱和虚引用 在JDK 1.2以前的版本中,若一个对象不被任何变量引用,那么程序就无法再使用这个对象.也就是说,只有对象处于可触及(reachable)状态,程序才能使用它.从JDK 1.2版本开始,把对象的引用分为4种级别,从而使程序能更加灵活地

JAVA 中两种判断输入的是否是数字的方法__正则化_

JAVA 中两种判断输入的是否是数字的方法 package t0806; import java.io.*; import java.util.regex.*; public class zhengzehua_test { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub try { System.out.println("请输入第一个数字:"