几种常用的设计模式浅析

一，创建型模式（主要用于创建对象）

1.工厂方法模式

定义了一个创建对象的接口，但由子类决定要实例化的类是哪个。

例如：FactoryMethodModel

Factory.java

package FactoryMethodModel;

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

}

HuaWeiFactory.java

package FactoryMethodModel;

public class HuaweiFactory extends Factory{
public Phone createPhone() {
return new HuaweiPhone(256);
}

}

HuaWeiPhone.java

package FactoryMethodModel;

/**

 * 产品的具体类

 * @author minGe_000

 *

 */

public class HuaweiPhone extends Phone{
public HuaweiPhone(int size) {
super(size);
}
public void descript() {
System.out.println("生产了一个华为手机");
}

}

Iphone.java

package FactoryMethodModel;

/**

 * 苹果手机类具体类

 * @author minGe_000

 *

 */

public class IPhone extends Phone{

public IPhone(int size) {
super(size);
}
public void descript() {
System.out.println("生产了一个苹果手机");
}

}

IphoneFactory.java

package FactoryMethodModel;

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

Phone.java

package FactoryMethodModel;

/**

 * 产品的抽象父类

 * @author minGe_000

 *

 */

public abstract class Phone {
public int size;

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

}

Test.java

package FactoryMethodModel;

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

// //需要苹果手机对象,高耦合性

// Phone phone1 = PhoneFactory.createPhone("huawei");

// Phone phone2 = PhoneFactory.createPhone("iphone");

//

// phone1.descript();

// phone2.descript();
//构造一个华为工厂对象
Factory factory = new HuaweiFactory();
Phone phone1 = factory.createPhone();
}

}

2.简单工厂方法模式

例如：SimpleFactoryModel

HuaweiPhone.java

package SimpleFactoryModel;

/**

 * 产品的具体类

 * @author minGe_000

 *

 */

public class HuaweiPhone extends Phone{
public HuaweiPhone(int size) {
super(size);
}

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

}

Iphone.java

package SimpleFactoryModel;

/**

 * 苹果手机类具体类

 * @author minGe_000

 *

 */

public class IPhone extends Phone{

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

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

}

Phone.java

package SimpleFactoryModel;

/**

 * 产品的抽象父类

 * @author minGe_000

 *

 */

public abstract class Phone {
public int size;

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

}

PhoneFactory.java

package SimpleFactoryModel;

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;
}

}

Test.java

package SimpleFactoryModel;

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

}

3.单例模式

SingleObjectModel

例如：

Student.java

package SingleObjectModel;

/**

 * 单利模式

 * @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;
}

}

Test.java

package SingleObjectModel;

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();
}

二，结构型模式（用于处理类或对象的组合）

装饰模式（DecoratorModel)

例如：

BeefDecorator.java

package DecoratorModel;

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");
}

}

Cake.java

package DecoratorModel;

/**

 * 被装饰者的抽象父类

 * @author minGe_000

 *

 */

public interface Cake {
public float price();
public String description();

}

Decorator.java

package DecoratorModel;

/**

 * 装饰着的父类

 * @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();
}

}

EggDecorator.java

package DecoratorModel;

/**

 * 装饰着的具体实体类

 * @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("鸡蛋装饰测试函数");
}

}

GraspCake.java

package DecoratorModel;

/**

 * 被装饰者的实体类（手抓饼）

 * @author minGe_000

 *

 */

public class GraspCake implements Cake{
public float price() {
return 3.0f;
}
public String description() {
return "您点了一个原味手抓饼";
}

}

Test.java

package DecoratorModel;

import java.io.DataInputStream;

import java.io.FileInputStream;

import java.io.InputStream;

import java.io.ObjectInputStream;

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());
}

}

三，行为型模式（用于描述对类或对象怎样交互和怎样分配职责）

观察者模式

例如：

Observer.java

package ObserverModel;

/**

 * 被观察者抽象父类

 * @author minGe_000

 *

 */

public interface Observer {
public void reciveMsg(String msg);

}

Student.java

package ObserverModel;

/**

 * 被观察者的实体类

 * @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);

}

}

Teacher.java

package ObserverModel;

import java.util.ArrayList;

/**

 * 观察者的实体类

 * @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);
}
}

}

Test.java

package ObserverModel;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import javax.swing.JFrame;

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);
}

}

Watcher.java

package ObserverModel;

/**

 * 观察者抽象父类

 * @author minGe_000

 *

 */

public interface Watcher {
public void addObserver(Observer obs);
public void removeObserver(Observer obs);
public void notifys(String msg);

}