本帖最后由 CatchException 于 2017-11-17 12:54 编辑
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。 使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。 ----百度百科
下面开始总结： 单例设计模式 单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。 分为饿汉式和懒汉式，由于饿汉式没有过多需要注意的地方，故忽略。下文为懒汉式： [Java] 纯文本查看 复制代码 public class SingleDemo {
//将实例静态私有，并置为空，目的是为了延迟加载
private static SingleDemo instance = null;
//将构造方法私有，防止被创建实例
private SingleDemo(){}
//创建实例并返回
public static SingleDemo getInstance(){
if(instance == null){
synchronized (instance) {
if(instance == null){
instance = new SingleDemo();
}
}
}
return instance;
}以上的双重if判断是为了提高性能，如果没有外层的if，那么每个线程进来都要拿到一次锁，才可以进行判断此时instance是否为空，如果是非空的，会立即释放锁，这是一个非常消耗系统资源的过程，所以在每个线程进来时先进行一次判断，如果非空，就没必要去拿到锁，而是直接将现有的实例返回。 工厂设计模式
工厂模式分为三种： 1、普通工厂 2、多个工厂 3、静态工厂 1、普通工厂模式：就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。 我们举一个生产手机的例子。把所有的手机放在一个工厂里面去生产。 [Java] 纯文本查看 复制代码 package com.itheima.factory;
//创建手机共同的接口
public interface Phone{
public void call();
}
//创建不同手机生产的实现类
public class Mi implements Phone{
@Override
public void call() {
System.out.println("小米手机call...");
}
}
public class HuaWei implements Phone{
@Override
public void call() {
System.out.println("华为手机call...");
}
}
//最后创建工厂类
public class PhoneFactory {
public Phone make(String phone){
if("Mi".equals(phone)){
return new Mi();
}else if("HuaWei".equals(phone)){
return new HuaWei();
}else{
System.out.println("请输入正确的手机型号");
}
}
}
//我们来测试下
public class FactoryTest{
public static void main(String[] args) {
PhoneFactory pf = new PhoneFactory();
Phone phone = pf.make("Mi");
phone.call();
}
}
输出结果：小米手机call... 2、多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。 以上代码不做修改，只把PhoneFactory修改一下 [Java] 纯文本查看 复制代码 public class MoreFactory {
//生产小米手机的工厂方法
public Phone makeMi(){
return new Mi();
}
//生产华为手机的工厂方法
public Phone makeHuaWei(){
return new HuaWei();
}
}测试一下 [Java] 纯文本查看 复制代码 public class FactoryTest(){
MoreFactory mf = new MoreFactory();
Phone phone = mf.makeHuaWei();
phone.call();
}输出结果：华为手机call... 3.静态工厂模式：就是将上述两个生产方法加上static关键字修饰，即在使用时不需要创建工厂对象，直接用类名调用即可。此处不再举例 抽象工厂设计模式 工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这些工厂实现同一个总工厂的接口。这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。 [Java] 纯文本查看 复制代码 package com.itheima.factory;
//创建手机共同的接口
public interface Phone{
public void call();
}
//创建手机生产工厂需要实现的总工厂接口
public interface Factory {
public Phone make();
}
//创建不同手机生产的实现类
public class Mi implements Phone{
@Override
public void call() {
System.out.println("小米手机call...");
}
}
public class HuaWei implements Phone{
@Override
public void call() {
System.out.println("华为手机call...");
}
}
//小米生产工厂
public class MiFactory implements Factory{
@Override
public Phone make() {
return new Mi();
}
}
//华为生产工厂
public class HuaWeiFactory implements Factory{
@Override
public Phone make() {
return new HuaWei();
}
}
//测试一下
public class FactoryTest(){
Factory factory = new MiFactory();
Phone phone = factory.make();
phone.call();
}
输出结果：小米手机call... 这个模式的好处就是，如果你现在想生产一个新手机：iPhone，则只需做一个实现类，实现Phone接口，同时做一个工厂类，实现Factory接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！ 装饰者模式
装饰器模式的应用场景：
1、需要扩展一个类的功能。
2、动态的为一个对象增加功能，而且还能动态撤销。（动态的增强一个类中需要增强的方法）
必要条件：
* 包装对象和被包装的对象都要实现相同的接口.
* 包装的对象中需要获得到被包装对象的引用.
缺点：如果接口的方法比较多,增强其中的某个方法.其他的功能的方法需要原有调用. 举个例子：现在的服务员类中有一个服务的方法（输出：服务...），我们想对这个服务方法加以增强（输出：微笑服务...）。 [Java] 纯文本查看 复制代码 //包装类和被包装类需要实现的同一个接口
public interface Waiter{
public void server();
}
public class Waiteress implements Waiter{
@Override
public void server() {
System.out.println("服务...");
}
}
public class WaiteressWrapper implements Waiter{
private Waiter waiter;
public WaiteressWrapper(Waiter waiter) {
this.waiter = waiter;
}
@Override
public void server() {
System.out.print("微笑");
this.waiter.server();
}
}[/align][align=left]//测试一下[/align][align=left]public class DecoratorTest {
public static void main(String[] args) {
Waiter waiter = new WaiteressWrapper(new Waiteress());
waiter.server();
}
}
输出结果：微笑服务... 以上为目前学习到的三种设计模式，以后还会有很多种设计模式
| 
收藏
淘帖
踩
