一,创建型模式(主要用于创建对象)
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);
}