设计模式【工厂模式】【单例模式】【装饰者模式】

<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">设计模式（Design pattern）是一套被反复使用、多数人知晓的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。</span>
 

建立设计模式有如下优点：

优点：使代码编制真正工程化、统一化

      确立通用术语，提升代码易读性

      使软件更容易修改和维护

      降低代码耦合，提升软件扩展性

 

JAVA中，有如下的设计模式：

创建型模式：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式

结构型模式：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式：、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录策略模式模式、状态模式、访问者模式、中介者模式、解释器模式。

 

总的结构如下：

 

这里我们介绍三类设计模式

工厂模式：

单例模式：

装饰者模式：

观察者模式：

 

一、工厂模式：

工厂模式分为：

      简单工厂模式、抽象工厂模式

内涵：

工厂模式是由一个工厂对象决定创建出哪一个具体实例，简单工厂模式是工厂模式家族中最简单最常用的一种

 1.简单工厂

<span style="font-size:10px;">public class PhoneFactory {
/**
* 工厂函数
* @return
*/
public static Phone createPhone(String type){
Phone phone = null;
if("iphone".equals(type)){
phone = new IPhone(256);
}else if("huawei".equals(type)){
phone = new HuaweiPhone(256);
}
return phone;
}
}</span>

/**
* 产品的抽象父类
* @author minGe_000
*
*/
public abstract class Phone {
public int size;

public Phone(int size) {
super();
this.size = size;
}

public abstract void descript();
}

/**
* 苹果手机类具体类
* @author minGe_000
*
*/
public class IPhone extends Phone{

public IPhone(int size) {
super(size);
}

@Override
public void descript() {
System.out.println("生产了一个苹果手机");
}
}

/**
* 产品的具体类
* @author minGe_000
*
*/
public class HuaweiPhone extends Phone{
public HuaweiPhone(int size) {
super(size);
}

@Override
public void descript() {
System.out.println("生产了一个华为手机");
}
}

public class Test {
public static void main(String[] args) {
//需要苹果手机对象,高耦合性
Phone phone1 = PhoneFactory.createPhone("huawei");
Phone phone2 = PhoneFactory.createPhone("iphone");

phone1.descript();
phone2.descript();
}
}

2.抽象工厂模式

<span style="font-size:10px;">/** * 产品的抽象父类 * @author minGe_000 * */ public abstract class Phone { public int size; public Phone(int size) { super(); this.size = size; } public abstract void descript(); }</span>

/**
* 苹果手机类具体类
* @author minGe_000
*
*/
public class IPhone extends Phone{

public IPhone(int size) {
super(size);
}

@Override
public void descript() {
System.out.println("生产了一个苹果手机");
}
}

/**
* 产品的具体类
* @author minGe_000
*
*/
public class HuaweiPhone extends Phone{
public HuaweiPhone(int size) {
super(size);
}

@Override
public void descript() {
System.out.println("生产了一个华为手机");
}
}

public class IPhoneFactory extends Factory{
public Phone createPhone() {
return new IPhone(246);
}

}

public class HuaweiFactory extends Factory{

@Override
public Phone createPhone() {
return new HuaweiPhone(256);
}

}

public abstract class Factory {
public abstract Phone createPhone();
}

public class Test {
public static void main(String[] args) {
//构造一个华为工厂对象
Factory factory = new HuaweiFactory();
Phone phone1 = factory.createPhone();
}
}

二、单例模式

内涵：保证当前类有且仅有一个对象，不允许被创建多个实例

分类：饿汉式、懒汉式

实现思路：1.构造函数私有化

          2.声明一个本类对象静态引用

          3.提供获取当前实例的静态方法

 /**
* 单例模式
* @author minGe_000
*
*/
public class Student {
public String name;
//1.构造方法私有化
private Student(){}
private Student(String name){
this.name = name;
}
//2.提供唯一的对象
private static Student stu;
//3.提供一个get实例的函数
public static synchronized Student getInstance(String n){
if(stu==null){
stu = new Student(n);
}
return stu;
}
}
public class Test {

/**
* @param args
*/
public static void main(String[] args) {
new Thread(){
public void run() {
Student stu = Student.getInstance("abc");
};
}.start();
new Thread(){
public void run() {
Student stu1 = Student.getInstance("abc");
};
}.start();
new Thread(){
public void run() {
Student stu2 = Student.getInstance("abc");
};
}.start();
}

}

三、装饰者模式

内涵：在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

 

适用场景：

1. 需要动态的给一个对象添加功能，这些功能可以再动态的撤销

2. 需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实

3 当不能采用生成子类的方法进行扩充时

 

类图：

 
实际应用：

IO流体系的应用

被装饰者：
饼：Cake
手抓饼、肉夹馍、月饼、煎饼......

装饰者：
鸡蛋、牛排、肉松、辣酱、番茄酱、沙拉.......
/**
* 被装饰者的抽象父类
* @author minGe_000
*
*/
public interface Cake {
public float price();
public String description();
}

/**
* 被装饰者的实体类（手抓饼）
* @author minGe_000
*
*/
public class GraspCake implements Cake{
public float price() {
return 3.0f;
}
public String description() {
return "您点了一个原味手抓饼";
}
}

/**
* 装饰着的具体实体类
* @author minGe_000
*
*/
public class EggDecorator extends Decorator{
public EggDecorator(Cake cake) {
super(cake);
}
@Override
public float price() {
return super.price()+1.5f;
}
@Override
public String description() {
return super.description()+"+鸡蛋";
}

public void test(){
System.out.println("鸡蛋装饰测试函数");
}
}

/**
* 装饰着的父类
* @author minGe_000
*
*/
public abstract class Decorator implements Cake{
//体现和被装饰者的关联关系
private Cake cake;
public Decorator(Cake cake){
this.cake = cake;
}
public float price() {
return cake.price();
}
public String description() {
return cake.description();
}
}

public class BeefDecorator extends Decorator{
public BeefDecorator(Cake cake) {
super(cake);
}
@Override
public float price() {
return super.price()+2.0f;
}
@Override
public String description() {
return super.description()+"+牛排";
}

public void test2(){
System.out.println("测试2");
}
}

public class Test {
public static void main(String[] args) {
InputStream ins;
InputStream fis = new FileInputStream();
InputStream ois = new ObjectInputStream(fis);
InputStream dis = new DataInputStream(ois);

Cake gc = new GraspCake();

Cake ed = new EggDecorator(gc);

Cake bf = new BeefDecorator(gc);

System.out.println(bf.price());
System.out.println(bf.description());
}
}

 四、观察者模式

/**
* 观察者抽象父类
* @author minGe_000
*
*/
public interface Watcher {
public void addObserver(Observer obs);
public void removeObserver(Observer obs);
public void notifys(String msg);
}

/**
* 观察者的实体类
* @author minGe_000
*
*/
public class Teacher implements Watcher{
private ArrayList<Observer> list = new ArrayList<Observer>();
public void addObserver(Observer obs) {
list.add(obs);
}
public void removeObserver(Observer obs) {
list.remove(obs);
}
public void notifys(String msg) {
//遍历队列，并通知到位每一个被观察对象
for (Observer obs : list) {
obs.reciveMsg(msg);
}
}
}

/**
* 被观察者抽象父类
* @author minGe_000
*
*/
public interface Observer {
public void reciveMsg(String msg);
}

/**
* 被观察者的实体类
* @author minGe_000
*
*/
public class Student implements Observer{
private String name;

public Student(String name) {
this.name = name;
}

public void reciveMsg(String msg) {
System.out.println(name+"收到一条消息:"+msg);

}
}

public class Test {
public static void main(String[] args) {
Student stu1 = new Student("漳卅");
Student stu2 = new Student("李四");
Student stu3 = new Student("王五");
Student stu4 = new Student("赵六");

Teacher tea = new Teacher();
tea.addObserver(stu1);
tea.addObserver(stu2);
tea.addObserver(stu3);
tea.addObserver(stu4);

tea.notifys("成绩还没出来了，请不要查成绩");

JFrame jf = new JFrame();
MouseListener ml = new MouseListener() {

@Override
public void mouseReleased(MouseEvent e) {
// TODO Auto-generated method stub

}

@Override
public void mousePressed(MouseEvent e) {
// TODO Auto-generated method stub

}

@Override
public void mouseExited(MouseEvent e) {
// TODO Auto-generated method stub

}

@Override
public void mouseEntered(MouseEvent e) {
// TODO Auto-generated method stub

}

@Override
public void mouseClicked(MouseEvent e) {
// TODO Auto-generated method stub

}
};
jf.addMouseListener(ml);
}
}