23中设计模式不全
工厂三兄弟(object obj = new string()😉
- 简单工厂模式
//抽象图表接口：抽象产品类
interface Chart {
public void display();
}
//柱状图类：具体产品类
class HistogramChart implements Chart {
public HistogramChart() {
System.out.println("创建柱状图！");
}
public void display() {
System.out.println("显示柱状图！");
}
}
//饼状图类：具体产品类
class PieChart implements Chart {
public PieChart() {
System.out.println("创建饼状图！");
}
public void display() {
System.out.println("显示饼状图！");
}
}
//折线图类：具体产品类
class LineChart implements Chart {
public LineChart() {
System.out.println("创建折线图！");
}
public void display() {
System.out.println("显示折线图！");
}
}
//图表工厂类：工厂类
class ChartFactory {
//静态工厂方法
public static Chart getChart(String type) {
Chart chart = null;
if (type.equalsIgnoreCase("histogram")) {
chart = new HistogramChart();
System.out.println("初始化设置柱状图！");
}
else if (type.equalsIgnoreCase("pie")) {
chart = new PieChart();
System.out.println("初始化设置饼状图！");
}
else if (type.equalsIgnoreCase("line")) {
chart = new LineChart();
System.out.println("初始化设置折线图！");
}
return chart;
}
}
class Client {
public static void main(String args[]) {
Chart chart;
chart = ChartFactory.getChart("histogram"); //通过静态工厂方法创建产品
chart.display();
}
}
- 工厂方法模式
//日志记录器接口：抽象产品
interface Logger {
public void writeLog();
}
//数据库日志记录器：具体产品
class DatabaseLogger implements Logger {
public void writeLog() {
System.out.println("数据库日志记录。");
}
}
//文件日志记录器：具体产品
class FileLogger implements Logger {
public void writeLog() {
System.out.println("文件日志记录。");
}
}
//日志记录器工厂接口：抽象工厂
interface LoggerFactory {
public Logger createLogger();
}
//数据库日志记录器工厂类：具体工厂
class DatabaseLoggerFactory implements LoggerFactory {
public Logger createLogger() {
//连接数据库，代码省略
//创建数据库日志记录器对象
Logger logger = new DatabaseLogger();
//初始化数据库日志记录器，代码省略
return logger;
}
}
//文件日志记录器工厂类：具体工厂
class FileLoggerFactory implements LoggerFactory {
public Logger createLogger() {
//创建文件日志记录器对象
Logger logger = new FileLogger();
//创建文件，代码省略
return logger;
}
}
class Client {
public static void main(String args[]) {
LoggerFactory factory;
Logger logger;
factory = new FileLoggerFactory(); //可引入配置文件实现
logger = factory.createLogger();
logger.writeLog();
}
}
- 抽象工厂模式
//按钮接口：抽象产品
interface Button {
public void display();
}
//Spring按钮类：具体产品
class SpringButton implements Button {
public void display() {
System.out.println("显示浅绿色按钮。");
}
}
//Summer按钮类：具体产品
class SummerButton implements Button {
public void display() {
System.out.println("显示浅蓝色按钮。");
}
}
//文本框接口：抽象产品
interface TextField {
public void display();
}
//Spring文本框类：具体产品
class SpringTextField implements TextField {
public void display() {
System.out.println("显示绿色边框文本框。");
}
}
//Summer文本框类：具体产品
class SummerTextField implements TextField {
public void display() {
System.out.println("显示蓝色边框文本框。");
}
}
//组合框接口：抽象产品
interface ComboBox {
public void display();
}
//Spring组合框类：具体产品
class SpringComboBox implements ComboBox {
public void display() {
System.out.println("显示绿色边框组合框。");
}
}
//Summer组合框类：具体产品
class SummerComboBox implements ComboBox {
public void display() {
System.out.println("显示蓝色边框组合框。");
}
}
//界面皮肤工厂接口：抽象工厂
interface SkinFactory {
public Button createButton();
public TextField createTextField();
public ComboBox createComboBox();
}
//Spring皮肤工厂：具体工厂
class SpringSkinFactory implements SkinFactory {
public Button createButton() {
return new SpringButton();
}
public TextField createTextField() {
return new SpringTextField();
}
public ComboBox createComboBox() {
return new SpringComboBox();
}
}
//Summer皮肤工厂：具体工厂
class SummerSkinFactory implements SkinFactory {
public Button createButton() {
return new SummerButton();
}
public TextField createTextField() {
return new SummerTextField();
}
public ComboBox createComboBox() {
return new SummerComboBox();
}
}
class Client {
public static void main(String args[]) {
//使用抽象层定义
SkinFactory factory;
Button bt;
TextField tf;
ComboBox cb;
factory = (SkinFactory)XMLUtil.getBean();
bt = factory.createButton();
tf = factory.createTextField();
cb = factory.createComboBox();
bt.display();
tf.display();
cb.display();
}
}
适配器模式
//抽象成绩操作类：目标接口
interface ScoreOperation {
public int[] sort(int array[]); //成绩排序
public int search(int array[],int key); //成绩查找
}
//快速排序类：适配者
class QuickSort {
public int[] quickSort(int array[]) {
sort(array,0,array.length-1);
return array;
}
public void sort(int array[],int p, int r) {
int q=0;
if(p<r) {
q=partition(array,p,r);
sort(array,p,q-1);
sort(array,q+1,r);
}
}
public int partition(int[] a, int p, int r) {
int x=a[r];
int j=p-1;
for (int i=p;i<=r-1;i++) {
if (a[i]<=x) {
j++;
swap(a,j,i);
}
}
swap(a,j+1,r);
return j+1;
}
public void swap(int[] a, int i, int j) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
}
//二分查找类：适配者
class BinarySearch {
public int binarySearch(int array[],int key) {
int low = 0;
int high = array.length -1;
while(low <= high) {
int mid = (low + high) / 2;
int midVal = array[mid];
if(midVal < key) {
low = mid +1;
}
else if (midVal > key) {
high = mid -1;
}
else {
return 1; //找到元素返回1
}
}
return -1; //未找到元素返回-1
}
}
//操作适配器：适配器
class OperationAdapter implements ScoreOperation {
private QuickSort sortObj; //定义适配者QuickSort对象
private BinarySearch searchObj; //定义适配者BinarySearch对象
public OperationAdapter() {
sortObj = new QuickSort();
searchObj = new BinarySearch();
}
public int[] sort(int array[]) {
return sortObj.quickSort(array); //调用适配者类QuickSort的排序方法
}
public int search(int array[],int key) {
return searchObj.binarySearch(array,key); //调用适配者类BinarySearch的查找方法
}
}
class Client {
public static void main(String args[]) {
ScoreOperation operation; //针对抽象目标接口编程
operation = (ScoreOperation)XMLUtil.getBean(); //读取配置文件，反射生成对象
int scores[] = {84,76,50,69,90,91,88,96}; //定义成绩数组
int result[];
int score;
System.out.println("成绩排序结果：");
result = operation.sort(scores);
//遍历输出成绩
for(int i : scores) {
System.out.print(i + ",");
}
System.out.println();
System.out.println("查找成绩90：");
score = operation.search(result,90);
if (score != -1) {
System.out.println("找到成绩90。");
}
else {
System.out.println("没有找到成绩90。");
}
System.out.println("查找成绩92：");
score = operation.search(result,92);
if (score != -1) {
System.out.println("找到成绩92。");
}
else {
System.out.println("没有找到成绩92。");
}
}
}
外观模式
(1) FileReader：文件读取类，充当子系统类。
//FileReader.cs
using System;
using System.Text;
using System.IO;
namespace FacadeSample
{
class FileReader
{
public string Read(string fileNameSrc)
{
Console.Write("读取文件，获取明文：");
FileStream fs = null;
StringBuilder sb = new StringBuilder();
try
{
fs = new FileStream(fileNameSrc, FileMode.Open);
int data;
while((data = fs.ReadByte())!= -1)
{
sb = sb.Append((char)data);
}
fs.Close();
Console.WriteLine(sb.ToString());
}
catch(FileNotFoundException e)
{
Console.WriteLine("文件不存在！");
}
catch(IOException e)
{
Console.WriteLine("文件操作错误！");
}
return sb.ToString();
}
}
}
(2) CipherMachine：数据加密类，充当子系统类。
//CipherMachine.cs
using System;
using System.Text;
namespace FacadeSample
{
class CipherMachine
{
public string Encrypt(string plainText)
{
Console.Write("数据加密，将明文转换为密文：");
string es = "";
char[] chars = plainText.ToCharArray();
foreach(char ch in chars)
{
string c = (ch % 7).ToString();
es += c;
}
Console.WriteLine(es);
return es;
}
}
}
(3) FileWriter：文件保存类，充当子系统类。
//FileWriter.cs
using System;
using System.IO;
using System.Text;
namespace FacadeSample
{
class FileWriter
{
public void Write(string encryptStr,string fileNameDes)
{
Console.WriteLine("保存密文，写入文件。");
FileStream fs = null;
try
{
fs = new FileStream(fileNameDes, FileMode.Create);
byte[] str = Encoding.Default.GetBytes(encryptStr);
fs.Write(str,0,str.Length);
fs.Flush();
fs.Close();
}
catch(FileNotFoundException e)
{
Console.WriteLine("文件不存在！");
}
catch(IOException e)
{
Console.WriteLine(e.Message);
Console.WriteLine("文件操作错误！");
}
}
}
}
(4) EncryptFacade：加密外观类，充当外观类。
// EncryptFacade.cs
namespace FacadeSample
{
class EncryptFacade
{
//维持对其他对象的引用
private FileReader reader;
private CipherMachine cipher;
private FileWriter writer;
public EncryptFacade()
{
reader = new FileReader();
cipher = new CipherMachine();
writer = new FileWriter();
}
//调用其他对象的业务方法
public void FileEncrypt(string fileNameSrc, string fileNameDes)
{
string plainStr = reader.Read(fileNameSrc);
string encryptStr = cipher.Encrypt(plainStr);
writer.Write(encryptStr, fileNameDes);
}
}
}
(5) Program：客户端测试类
//Program.cs
using System;
namespace FacadeSample
{
class Program
{
static void Main(string[] args)
{
EncryptFacade ef = new EncryptFacade();
ef.FileEncrypt("src.txt", "des.txt");
Console.Read();
}
}
}
PS:抽象外观模式==>即多准备几个组件或先添加几个组件;组建外观类前先规定一个抽象的外观类,但组件具体外观类时再分套路组建不同标签的组件成目标外观组件
https://blog.csdn.net/lovelion/article/details/8259789
组合模式
AbstractFile充当抽象构件类，Folder充当容器构件类，ImageFile、TextFile和VideoFile充当叶子构件类。完整代码如下所示：
//抽象文件类：抽象构件
abstract class AbstractFile {
public abstract void add(AbstractFile file);
public abstract void remove(AbstractFile file);//此方法感觉没啥用
public abstract AbstractFile getChild(int i);//此方法感觉没啥用
public abstract void killVirus();
}
//图像文件类：叶子构件
class ImageFile extends AbstractFile {
private String name;
public ImageFile(String name) {
this.name = name;
}
public void add(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public void remove(AbstractFile file) {//此方法感觉没啥用
System.out.println("对不起，不支持该方法！");
}
public AbstractFile getChild(int i) {//此方法感觉没啥用
System.out.println("对不起，不支持该方法！");
return null;
}
public void killVirus() {
//模拟杀毒
System.out.println("----对图像文件'" + name + "'进行杀毒");
}
}
//文本文件类：叶子构件
class TextFile extends AbstractFile {
private String name;
public TextFile(String name) {
this.name = name;
}
public void add(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public void remove(AbstractFile file) {//此方法感觉没啥用
System.out.println("对不起，不支持该方法！");
}
public AbstractFile getChild(int i) {//此方法感觉没啥用
System.out.println("对不起，不支持该方法！");
return null;
}
public void killVirus() {
//模拟杀毒
System.out.println("----对文本文件'" + name + "'进行杀毒");
}
}
//视频文件类：叶子构件
class VideoFile extends AbstractFile {
private String name;
public VideoFile(String name) {
this.name = name;
}
public void add(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public void remove(AbstractFile file) {//此方法感觉没啥用
System.out.println("对不起，不支持该方法！");
}
public AbstractFile getChild(int i) {//此方法感觉没啥用
System.out.println("对不起，不支持该方法！");
return null;
}
public void killVirus() {
//模拟杀毒
System.out.println("----对视频文件'" + name + "'进行杀毒");
}
}
//文件夹类：容器构件
class Folder extends AbstractFile {
//定义集合fileList，用于存储AbstractFile类型的成员
private ArrayList<AbstractFile> fileList=new ArrayList<AbstractFile>();
private String name;
public Folder(String name) {
this.name = name;
}
public void add(AbstractFile file) {
fileList.add(file);
}
public void remove(AbstractFile file) {//此方法感觉没啥用
fileList.remove(file);
}
public AbstractFile getChild(int i) {//此方法感觉没啥用
return (AbstractFile)fileList.get(i);
}
public void killVirus() {
System.out.println("****对文件夹'" + name + "'进行杀毒"); //模拟杀毒
//递归调用成员构件的killVirus()方法
for(Object obj : fileList) {
((AbstractFile)obj).killVirus();
}
}
}
编写如下客户端测试代码：
class Client {
public static void main(String args[]) {
//针对抽象构件编程
AbstractFile file1,file2,file3,file4,file5,folder1,folder2,folder3,folder4;
folder1 = new Folder("Sunny的资料");
folder2 = new Folder("图像文件");
folder3 = new Folder("文本文件");
folder4 = new Folder("视频文件");
file1 = new ImageFile("小龙女.jpg");
file2 = new ImageFile("张无忌.gif");
file3 = new TextFile("九阴真经.txt");
file4 = new TextFile("葵花宝典.doc");
file5 = new VideoFile("笑傲江湖.rmvb");
folder2.add(file1);
folder2.add(file2);
folder3.add(file3);
folder3.add(file4);
folder4.add(file5);
folder1.add(folder2);
folder1.add(folder3);
folder1.add(folder4);
//从“Sunny的资料”节点开始进行杀毒操作
folder1.killVirus();
}
}
代理模式
AccessValidator：身份验证类，业务类，它提供方法Validate()来实现身份验证。
//AccessValidator.cs
using System;
namespace ProxySample
{
class AccessValidator
{
//模拟实现登录验证
public bool Validate(string userId)
{
Console.WriteLine("在数据库中验证用户'" + userId + "'是否是合法用户？");
if (userId.Equals("杨过")) {
Console.WriteLine("'{0}'登录成功！",userId);
return true;
}
else {
Console.WriteLine("'{0}'登录失败！", userId);
return false;
}
}
}
}
Logger：日志记录类，业务类，它提供方法Log()来保存日志。
//Logger.cs
using System;
namespace ProxySample
{
class Logger
{
//模拟实现日志记录
public void Log(string userId) {
Console.WriteLine("更新数据库，用户'{0}'查询次数加1！",userId);
}
}
}
Searcher：抽象查询类，充当抽象主题角色，它声明了DoSearch()方法。
//Searcher.cs
namespace ProxySample
{
interface Searcher
{
string DoSearch(string userId, string keyword);
}
}
RealSearcher：具体查询类，充当真实主题角色，它实现查询功能，提供方法DoSearch()来查询信息。
//RealSearcher.cs
using System;
namespace ProxySample
{
class RealSearcher : Searcher
{
//模拟查询商务信息
public string DoSearch(string userId, string keyword) {
Console.WriteLine("用户'{0}'使用关键词'{1}'查询商务信息！",userId,keyword);
return "返回具体内容";
}
}
}
ProxySearcher：代理查询类，充当代理主题角色，它是查询代理，维持了对RealSearcher对象、AccessValidator对象和Logger对象的引用。
//ProxySearcher.cs
namespace ProxySample
{
class ProxySearcher : Searcher
{
private RealSearcher searcher = new RealSearcher(); //维持一个对真实主题的引用
private AccessValidator validator;
private Logger logger;
public string DoSearch(string userId, string keyword)
{
//如果身份验证成功，则执行查询
if (this.Validate(userId))
{
string result = searcher.DoSearch(userId, keyword); //调用真实主题对象的查询方法
this.Log(userId); //记录查询日志
return result; //返回查询结果
}
else
{
return null;
}
}
//创建访问验证对象并调用其Validate()方法实现身份验证
public bool Validate(string userId)
{
validator = new AccessValidator();
return validator.Validate(userId);
}
//创建日志记录对象并调用其Log()方法实现日志记录
public void Log(string userId)
{
logger = new Logger();
logger.Log(userId);
}
}
}
配置文件App.config，在配置文件中存储了代理主题类类名。
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="proxy" value="ProxySample.ProxySearcher"/>
</appSettings>
</configuration>
Program：客户端测试类
//Program.cs
using System;
using System.Configuration;
using System.Reflection;
namespace ProxySample
{
class Program
{
static void Main(string[] args)
{
//读取配置文件
string proxy = ConfigurationManager.AppSettings["proxy"];
//反射生成对象，针对抽象编程，客户端无须分辨真实主题类和代理类
Searcher searcher;
searcher = (Searcher)Assembly.Load("ProxySample").CreateInstance(proxy);
String result = searcher.DoSearch("杨过", "玉女心经");
Console.Read();
}
}
}
观察者模式
AllyControlCenter充当目标类，ConcreteAllyControlCenter充当具体目标类，Observer充当抽象观察者，Player充当具体观察者。完整代码如下所示：
//抽象观察类
interface Observer {
public String getName();
public void setName(String name);
public void help(); //声明支援盟友方法
public void beAttacked(AllyControlCenter acc); //声明遭受攻击方法
}
//战队成员类：具体观察者类
class Player implements Observer {
private String name;
public Player(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
//支援盟友方法的实现
public void help() {
System.out.println("坚持住，" + this.name + "来救你！");
}
//***!!!遭受攻击方法的实现，当遭受攻击时将调用战队控制中心类的通知方法notifyObserver()来通知盟友!!!***
public void beAttacked(AllyControlCenter acc) {
System.out.println(this.name + "被攻击！");
acc.notifyObserver(name);
}
}
//战队控制中心类：目标类
abstract class AllyControlCenter {
protected String allyName; //战队名称
protected ArrayList<Observer> players = new ArrayList<Observer>(); //定义一个集合用于存储战队成员
public void setAllyName(String allyName) {
this.allyName = allyName;
}
public String getAllyName() {
return this.allyName;
}
//注册方法
public void join(Observer obs) {
System.out.println(obs.getName() + "加入" + this.allyName + "战队！");
players.add(obs);
}
//注销方法
public void quit(Observer obs) {
System.out.println(obs.getName() + "退出" + this.allyName + "战队！");
players.remove(obs);
}
//声明抽象通知方法
public abstract void notifyObserver(String name);
}
//具体战队控制中心类：具体目标类
class ConcreteAllyControlCenter extends AllyControlCenter {
public ConcreteAllyControlCenter(String allyName) {
System.out.println(allyName + "战队组建成功！");
System.out.println("----------------------------");
this.allyName = allyName;
}
//实现通知方法
public void notifyObserver(String name) {
System.out.println(this.allyName + "战队紧急通知，盟友" + name + "遭受敌人攻击！");
//遍历观察者集合，调用每一个盟友（自己除外）的支援方法
for(Object obs : players) {
if (!((Observer)obs).getName().equalsIgnoreCase(name)) {
((Observer)obs).help();
}
}
}
}
编写如下客户端测试代码：
class Client {
public static void main(String args[]) {
//定义观察目标对象
AllyControlCenter acc;
acc = new ConcreteAllyControlCenter("金庸群侠");
//定义四个观察者对象
Observer player1,player2,player3,player4;
player1 = new Player("杨过");
acc.join(player1);
player2 = new Player("令狐冲");
acc.join(player2);
player3 = new Player("张无忌");
acc.join(player3);
player4 = new Player("段誉");
acc.join(player4);
//某成员遭受攻击
Player1.beAttacked(acc);
}
}
编译并运行程序，输出结果如下：
金庸群侠战队组建成功！
----------------------------
杨过加入金庸群侠战队！
令狐冲加入金庸群侠战队！
张无忌加入金庸群侠战队！
段誉加入金庸群侠战队！
杨过被攻击！
金庸群侠战队紧急通知，盟友杨过遭受敌人攻击！
坚持住，令狐冲来救你！
坚持住，张无忌来救你！
坚持住，段誉来救你！
迭代器模式
AbstractObjectList充当抽象聚合类，ProductList充当具体聚合类，AbstractIterator充当抽象迭代器，ProductIterator充当具体迭代器。完整代码如下所示：
//抽象聚合类
abstract class AbstractObjectList {
protected List<Object> objects = new ArrayList<Object>();
public AbstractObjectList(List objects) {
this.objects = objects;
}
public void addObject(Object obj) {
this.objects.add(obj);
}
public void removeObject(Object obj) {
this.objects.remove(obj);
}
public List getObjects() {
return this.objects;
}
//声明创建迭代器对象的抽象工厂方法
public abstract AbstractIterator createIterator();
}
//商品数据类：具体聚合类
class ProductList extends AbstractObjectList {
public ProductList(List products) {
super(products);
}
//实现创建迭代器对象的具体工厂方法
public AbstractIterator createIterator() {
return new ProductIterator(this);
}
}
//抽象迭代器
interface AbstractIterator {
public void next(); //移至下一个元素
public boolean isLast(); //判断是否为最后一个元素
public void previous(); //移至上一个元素
public boolean isFirst(); //判断是否为第一个元素
public Object getNextItem(); //获取下一个元素
public Object getPreviousItem(); //获取上一个元素
}
//商品迭代器：具体迭代器
class ProductIterator implements AbstractIterator {
private ProductList productList;
private List products;
private int cursor1; //定义一个游标，用于记录正向遍历的位置
private int cursor2; //定义一个游标，用于记录逆向遍历的位置
public ProductIterator(ProductList list) {
this.productList = list;
this.products = list.getObjects(); //获取集合对象
cursor1 = 0; //设置正向遍历游标的初始值
cursor2 = products.size() -1; //设置逆向遍历游标的初始值
}
public void next() {
if(cursor1 < products.size()) {
cursor1++;
}
}
public boolean isLast() {
return (cursor1 == products.size());
}
public void previous() {
if (cursor2 > -1) {
cursor2--;
}
}
public boolean isFirst() {
return (cursor2 == -1);
}
public Object getNextItem() {
return products.get(cursor1);
}
public Object getPreviousItem() {
return products.get(cursor2);
}
}
编写如下客户端测试代码：
class Client {
public static void main(String args[]) {
List products = new ArrayList();
products.add("倚天剑");
products.add("屠龙刀");
products.add("断肠草");
products.add("葵花宝典");
products.add("四十二章经");
AbstractObjectList list;
AbstractIterator iterator;
list = new ProductList(products); //创建聚合对象
iterator = list.createIterator(); //创建迭代器对象
System.out.println("正向遍历：");
while(!iterator.isLast()) {
System.out.print(iterator.getNextItem() + "，");
iterator.next();
}
System.out.println();
System.out.println("-----------------------------");
System.out.println("逆向遍历：");
while(!iterator.isFirst()) {
System.out.print(iterator.getPreviousItem() + "，");
iterator.previous();
}
}
}
编译并运行程序，输出结果如下：
正向遍历：
倚天剑，屠龙刀，断肠草，葵花宝典，四十二章经，
-----------------------------
逆向遍历：
四十二章经，葵花宝典，断肠草，屠龙刀，倚天剑，
策略模式
MovieTicket充当环境类角色，Discount充当抽象策略角色，StudentDiscount、 ChildrenDiscount 和VIPDiscount充当具体策略角色。完整代码如下所示：
//电影票类：环境类
class MovieTicket {
private double price;
private Discount discount; //维持一个对抽象折扣类的引用
public void setPrice(double price) {
this.price = price;
}
//注入一个折扣类对象
public void setDiscount(Discount discount) {
this.discount = discount;
}
public double getPrice() {
//调用折扣类的折扣价计算方法
return discount.calculate(this.price);
}
}
//折扣类：抽象策略类
interface Discount {
public double calculate(double price);
}
//学生票折扣类：具体策略类
class StudentDiscount implements Discount {
public double calculate(double price) {
System.out.println("学生票：");
return price * 0.8;
}
}
//儿童票折扣类：具体策略类
class ChildrenDiscount implements Discount {
public double calculate(double price) {
System.out.println("儿童票：");
return price - 10;
}
}
//VIP会员票折扣类：具体策略类
class VIPDiscount implements Discount {
public double calculate(double price) {
System.out.println("VIP票：");
System.out.println("增加积分！");
return price * 0.5;
}
}
编写如下客户端测试代码：
class Client {
public static void main(String args[]) {
MovieTicket mt = new MovieTicket();
double originalPrice = 60.0;
double currentPrice;
mt.setPrice(originalPrice);
System.out.println("原始价为：" + originalPrice);
System.out.println("---------------------------------");
Discount discount;
discount = (Discount)XMLUtil.getBean(); //读取配置文件并反射生成具体折扣对象
mt.setDiscount(discount); //注入折扣对象
currentPrice = mt.getPrice();
System.out.println("折后价为：" + currentPrice);
}
}
编译并运行程序，输出结果如下：
原始价为：60.0
---------------------------------
学生票：
折后价为：48.0
命令模式
FBSettingWindow是“功能键设置”界面类，FunctionButton充当请求调用者，Command充当抽象命令类，MinimizeCommand和HelpCommand充当具体命令类，WindowHanlder和HelpHandler充当请求接收者。完整代码如下所示：
import java.util.*;
//功能键设置窗口类
class FBSettingWindow {
private String title; //窗口标题
//定义一个ArrayList来存储所有功能键
private ArrayList<FunctionButton> functionButtons = new ArrayList<FunctionButton>();
public FBSettingWindow(String title) {
this.title = title;
}
public void setTitle(String title) {
this.title = title;
}
public String getTitle() {
return this.title;
}
public void addFunctionButton(FunctionButton fb) {
functionButtons.add(fb);
}
public void removeFunctionButton(FunctionButton fb) {
functionButtons.remove(fb);
}
//显示窗口及功能键
public void display() {
System.out.println("显示窗口：" + this.title);
System.out.println("显示功能键：");
for (Object obj : functionButtons) {
System.out.println(((FunctionButton)obj).getName());
}
System.out.println("------------------------------");
}
}
//功能键类：请求发送者
class FunctionButton {
private String name; //功能键名称
private Command command; //维持一个抽象命令对象的引用
public FunctionButton(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
//为功能键注入命令
public void setCommand(Command command) {
this.command = command;
}
//发送请求的方法
public void onClick() {
System.out.print("点击功能键：");
command.execute();
}
}
//抽象命令类
abstract class Command {
public abstract void execute();
}
//帮助命令类：具体命令类
class HelpCommand extends Command {
private HelpHandler hhObj; //维持对请求接收者的引用
public HelpCommand() {
hhObj = new HelpHandler();
}
//命令执行方法，将调用请求接收者的业务方法
public void execute() {
hhObj.display();
}
}
//最小化命令类：具体命令类
class MinimizeCommand extends Command {
private WindowHanlder whObj; //维持对请求接收者的引用
public MinimizeCommand() {
whObj = new WindowHanlder();
}
//命令执行方法，将调用请求接收者的业务方法
public void execute() {
whObj.minimize();
}
}
//窗口处理类：请求接收者
class WindowHanlder {
public void minimize() {
System.out.println("将窗口最小化至托盘！");
}
}
//帮助文档处理类：请求接收者
class HelpHandler {
public void display() {
System.out.println("显示帮助文档！");
}
}
编写如下客户端测试代码：
class Client {
public static void main(String args[]) {
FBSettingWindow fbsw = new FBSettingWindow("功能键设置");
FunctionButton fb1,fb2;
fb1 = new FunctionButton("功能键1");
fb2 = new FunctionButton("功能键1");
Command command1,command2;
//通过读取配置文件和反射生成具体命令对象
command1 = (Command)XMLUtil.getBean(0);
command2 = (Command)XMLUtil.getBean(1);
//将命令对象注入功能键
fb1.setCommand(command1);
fb2.setCommand(command2);
fbsw.addFunctionButton(fb1);
fbsw.addFunctionButton(fb2);
fbsw.display();
//调用功能键的业务方法
fb1.onClick();
fb2.onClick();
}
}
编译并运行程序，输出结果如下：
显示窗口：功能键设置
显示功能键：
功能键1
功能键1
------------------------------
点击功能键：显示帮助文档！
点击功能键：将窗口最小化至托盘！
中介者
Component充当抽象同事类，Button、List、ComboBox和TextBox充当具体同事类，Mediator充当抽象中介者类，ConcreteMediator充当具体中介者类，ConcreteMediator维持了对具体同事类的引用，为了简化ConcreteMediator类的代码，我们在其中只定义了一个Button对象和一个TextBox对象。完整代码如下所示：
//抽象中介者
abstract class Mediator {
public abstract void componentChanged(Component c);
}
//具体中介者
class ConcreteMediator extends Mediator {
//维持对各个同事对象的引用
public Button addButton;
public List list;
public TextBox userNameTextBox;
public ComboBox cb;
//封装同事对象之间的交互
public void componentChanged(Component c) {
//单击按钮
if(c == addButton) {
System.out.println("--单击增加按钮--");
list.update();
cb.update();
userNameTextBox.update();
}
//从列表框选择客户
else if(c == list) {
System.out.println("--从列表框选择客户--");
cb.select();
userNameTextBox.setText();
}
//从组合框选择客户
else if(c == cb) {
System.out.println("--从组合框选择客户--");
cb.select();
userNameTextBox.setText();
}
}
}
//抽象组件类：抽象同事类
abstract class Component {
protected Mediator mediator;
public void setMediator(Mediator mediator) {
this.mediator = mediator;
}
//转发调用
public void changed() {
mediator.componentChanged(this);
}
public abstract void update();
}
//按钮类：具体同事类
class Button extends Component {
public void update() {
//按钮不产生交互
}
}
//列表框类：具体同事类
class List extends Component {
public void update() {
System.out.println("列表框增加一项：张无忌。");
}
public void select() {
System.out.println("列表框选中项：小龙女。");
}
}
//组合框类：具体同事类
class ComboBox extends Component {
public void update() {
System.out.println("组合框增加一项：张无忌。");
}
public void select() {
System.out.println("组合框选中项：小龙女。");
}
}
//文本框类：具体同事类
class TextBox extends Component {
public void update() {
System.out.println("客户信息增加成功后文本框清空。");
}
public void setText() {
System.out.println("文本框显示：小龙女。");
}
}
编写如下客户端测试代码：
class Client {
public static void main(String args[]) {
//定义中介者对象
ConcreteMediator mediator;
mediator = new ConcreteMediator();
//定义同事对象
Button addBT = new Button();
List list = new List();
ComboBox cb = new ComboBox();
TextBox userNameTB = new TextBox();
addBT.setMediator(mediator);
list.setMediator(mediator);
cb.setMediator(mediator);
userNameTB.setMediator(mediator);
mediator.addButton = addBT;
mediator.list = list;
mediator.cb = cb;
mediator.userNameTextBox = userNameTB;
addBT.changed();
System.out.println("-----------------------------");
list.changed();
}
}
编译并运行程序，输出结果如下：
--单击增加按钮--
列表框增加一项：张无忌。
组合框增加一项：张无忌。
客户信息增加成功后文本框清空。
-----------------------------
--从列表框选择客户--
组合框选中项：小龙女。
文本框显示：小龙女。
