设计模式

最新推荐文章于 2025-06-01 11:32:32 发布

原创最新推荐文章于 2025-06-01 11:32:32 发布 · 504 阅读

1 ·

CC 4.0 BY-SA版权

java 同时被 2 个专栏收录

37 篇文章

订阅专栏

日志

7 篇文章

订阅专栏

一.单例设计模式就是:

只允许内存中存在一个实例的模式

/**
 * Created by Void Young on 2:40 PM 7/20/2016 .
 * IDEA-Test .
 * 单例设计模式  :只允许内存中存在一个实例的模式
 */
public class SingletonTest {
    public static void main (String[] args) {
        Singleton s1 = Singleton.getInstance ();
    }
}

/*
懒汉式  单例的延迟加载模式,面试的时候用,在多线程中可能会生成不止一个实例

class Singleton{
    private  Singleton(){}//第一步,private构造方法

    private static Singleton s;//第二步,声明private的变量

    public static Singleton getInstance (){//第三,创建public的访问器
        if (s == null) {
            s = new Singleton ();
        }
            return  s;
    }
}
 */

/*
饿汉式   开发的时候用
 */
class Singleton{
    private  Singleton(){}//第一步,private构造方法

    private static Singleton s  = new Singleton ();//第二步,声明private的变量并创建实例赋值

    public static Singleton getInstance (){//第三,创建public的访问器,直接return实例s
        return  s;
    }
}



/*
第三种模式:

class Singleton{

    private  Singleton(){}//第一步,private构造方法

    public static final Singleton s  = new Singleton ();//第二步,声明public的final变量并创建实例赋值


} */

下为转载:

二.工厂方法模式
* A:工厂方法模式概述
* 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
* B:优点
* 客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
* C:缺点
* 需要额外的编写代码，增加了工作量
D:案例演示

动物抽象类：public abstract Animal { public abstract void eat(); }
工厂接口：public interface Factory {public abstract Animal createAnimal();}
具体狗类：public class Dog extends Animal {}
具体猫类：public class Cat extends Animal {}
开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦，用工厂方法改进，针对每一个具体的实现提供一个具体工厂。
狗工厂：public class DogFactory implements Factory {
public Animal createAnimal() {…}
}
猫工厂：public class CatFactory implements Factory {
public Animal createAnimal() {…}

}

三.适配器设计模式
* a.什么是适配器
* 在使用监听器的时候, 需要定义一个类事件监听器接口.
* 通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.
* 适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.
* b.适配器原理
* 适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.
* 适配器类需要定义成抽象的,因为创建该类对象,调用空方法是没有意义的
* 目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.

比如事件监听器里面的MouseAdapter等等

四.模版方法模式:

概述

模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现
优点和缺点
优点
使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
缺点
如果算法骨架有修改的话，则需要修改抽象类

样例:

/**
 * Created by Void Young on 7:07 PM 7/26/2016 .
 * IDEA-Test .
 * 模版方法设计模式样例
 * 计算方法运行时间
 */
public abstract class GetTime {

    public final long getTime () {//模版方法修饰为final 防止继承者修改
        long start = System.currentTimeMillis ();
        code();
        long end = System.currentTimeMillis ();
        return end - start;
    }

    public abstract void code ();//实际要运行的代码抽取为抽象方法,具体的代码让子类来实现
}

五.装饰设计模式:

当想要对已有的对象进行功能增强时，
可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。
那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。

如一个简单的demo 人吃饭，刚开始人穷只是普通的吃饭后来人生活好了吃饭就不一样了增强了吃饭的功能虽然例子不是恰当能说明问题就行

看代码：

Java代码  

//穷的时候吃饭简简单单的吃饭  

class Person  

{  

    public void chiFan(){  

        System.out.println("吃饭");  

    }  

}  

//富裕后吃饭 吃饭前来杯酒吃饭后来根烟 但是这中间的过程还是有吃饭  

class SuperPerson  

{  

    private Person p;  

    public SuperPerson(Person p){  

        this.p=p;  

    }  

    public void superChiFan(){  

        //吃饭前来杯开胃酒增加食量  

        System.out.println("开胃酒");  

        p.chiFan();  

        //吃完饭后来根烟  

        System.out.println("来根烟");  

    }  

}  

public class PersonDemo  

{   public static void main(String args[]){  

    Person p=new Person();  

    SuperPerson sp= new SuperPerson(p);  

    sp.superChiFan();  

    }  

}

以上只是简单说明一下，在JAVA IO中用了很多增强如：FileRead中read()方法只是一个一个字节去读，为了读得更快在BufferedReader就增强了read()方法而产生了reandLine()一行一行的去读

有人说没必要那么麻烦：你只要拿superPerson继承person 在覆写person的chiFan()方法不就行了？

装饰是构造函数参数传递进行增强

如果为了某个功能而产生子类（继承）那么那个体系是非常臃肿的

例如：你有个对象有个功能是在N年前建立的，如今你觉得功能不够用了写个类把对象传进来就可以解决问题了如果这个功能写错了我就把自己写的功能去掉又不影响以前的功能灵活性相当强的。

装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。

转自:http://jiangnanlove.iteye.com/blog/914120 这个很浅显易懂,一看就懂了

-抽象构件角色：给出一个抽象接口，以规范准备接收附加责任的对象。

/**
 * Created by Void Young on 9:36 PM 7/26/2016 .
 * IDEA-Test .
 * 抽象构件接口,用来规范的接收要附加功能的对象
 */
public interface Component {
    void doSomething();
}

-具体构件角色：定义一个将要接收附加责任的类。

/**
 * Created by Void Young on 9:39 PM 7/26/2016 .
 * IDEA-Test .
 * 被装饰的类
 */
public class ConcreteComponent implements Component {

    @Override
    public void doSomething () {
        System.out.println ("基本功能A");
    }
}

-装饰角色：持有一个构件对象的引用，并定义一个与抽象构件接口一致的接口。

**
 * Created by Void Young on 9:41 PM 7/26/2016 .
 * IDEA-Test .
 * 实现装饰动作的类, 被装饰类 和 实际装饰类中间的接口
 */
public class Decorator implements Component {

    private Component component;//持有一个Component对象的引用

    public Decorator (Component component) {
        this.component = component;
    }

    @Override
    public void doSomething () {
        component.doSomething ();//不直接做什么,而是调用被装饰类的doSomething
    }
}

具体装饰角色：负责给构件对象“贴上”附加的责任

/**
 * Created by Void Young on 9:46 PM 7/26/2016 .
 * IDEA-Test .
 * 具体的装饰类  追加了其他的功能
 */
public class ConcerteDecorator1 extends Decorator {

    public ConcerteDecorator1 (Component component) {
        super (component);
    }

    @Override
    public void doSomething () {
        super.doSomething ();
        this.doAnotherThing ();//附加的功能

    }
    private void doAnotherThing(){
        System.out.println ("附加的功能B");
    }
}

/**
 * Created by Void Young on 9:50 PM 7/26/2016 .
 * IDEA-Test .
 * 具体的装饰类2
 */
public class ConcreteDecorator2 extends Decorator {

    public ConcreteDecorator2 (Component component) {
        super (component);
    }

    public void doSomething () {
        super.doSomething ();
        this.doAnotherThing ();//附加的功能

    }
    private void doAnotherThing(){
        System.out.println ("附加的功能C");
    }
}

test:

/**
 * Created by Void Young on 9:56 PM 7/26/2016 .
 * IDEA-Test .
 */
public class TestDecorator {
    public static void main (String[] args) {
        Component c = new ConcreteDecorator2 //实际装饰类2 附加了功能c
                (new ConcerteDecorator1 //实际装饰类1  附加了功能B
                        (new ConcreteComponent ()));//被装饰的类,包含基本功能
        c.doSomething ();
    }
}

结果功能ABC都实现了,略复杂,,,