合成设计模式
任何人类产品都是可以拆分的，而后进行重新组合，所以这样设计中被称为合成设计模式。
定义出一种可以描述电脑组成的类，在这样状态下就应该进行拆分为显示器与主机。而主机可以进一步拆分成主板、鼠标和键盘。主板又可以拆分成内存、cpu、显卡、键盘。
再比如：C盘中有一个文件夹jdk,文件夹jdk中存在两个文件jdk1.txt与jdk2.txt。这两个txt文件共同组成了jdk这个文件夹。这个文件夹再与其他同路径文件组成C盘。反过来就可以将C盘拆分成层层文件。
像这种把需要设计的东西经过层层拆分，拆分成不同的组成部件，在需要使用的时候经过调用拼装，形成需要的产品整体。
例子：
class 电脑{ //1
private 显示器 对象数组[];
private 主机 主机；
}
class 显示器{ } //1.1
class 主机{ //1.2
private 主板 对象;
private 鼠标 对象;
private 键盘 对象;
}
class 主板{ //1.2.1
private 内存 对象数组[];
private cpu 对象数组[];
private 显卡 对象;
private 硬盘 对象数组[];
}
class 键盘{ } //1.2.2
class 鼠标{ } //1.2.3
class 内存{ } //1.2.1.1
class CPU{ } //1/2.1.2
class 显卡{ } //1.2.1.3
class 硬盘{ } //1.2.1.4
public class Array{
public static void main (String args[]){
}
}
模板设计模式
假设有三类事物：
·机器类：不休息、补充能量、工作；
·人类：需要休息、吃饭、努力工作；
·猪类：需要休息、吃饭、不工作；
abstract class Action{ //抽象类
public static final int eating=1; //定义指令
public static final int sleeping=5;
public static final int working=10;
public void command (int code){ //指令选择
switch(code){
case eating : {
this.eating();
break;
}
case sleeping : {
this.sleeping();
break;
}
case working : {
this.working();
break;
}
case sleeping +eating+working: {
this.sleeping();
this.eating();
this.working();
break;
}
}
}
public abstract void eating(); //抽象方法
public abstract void sleeping();
public abstract void working();
}
class Robot extends Action{//继承
public void eating(){//覆写方法
System.out.println(“机器充电”);
}
public void sleeping(){
}
public void working(){
System.out.println(“机器工作”);
}
}
class Person extends Action{//继承
public void eating(){//覆写方法
System.out.println(“人吃饭”);
}
public void sleeping(){
System.out.println(“人休息”);
}
public void working(){
System.out.println(“人工作”);
}
}
class Pig extends Action{//继承
public void eating(){
System.out.println(“猪吃食”);
}
public void sleeping(){
System.out.println(“猪睡觉”);
}
public void working(){
}
}
public class App2 {
public static void main(String[] args){
Action ro=new Robot();//向上转型
Action pe=new Person();
Action pi=new Pig();
System.out.println("----------机器行为----------");
pe.command(Action.sleeping+Action.working+Action.eating);
System.out.println("----------人类行为----------");
pe.command(Action.sleeping+Action.working+Action.eating);
System.out.println("----------猪的行为----------");
pi.command(Action.sleeping+Action.working+Action.eating);
}
}
输出结果：
----------机器行为----------
人休息
人吃饭
人工作
----------人类行为----------
人休息
人吃饭
人工作
----------猪的行为----------
猪睡觉
猪吃食
抽象类的好处是对子类方法进行统一管理，自身提供一些普通方法并且这些普通方法可以调用抽象方法，（这些抽象方法必须为子类覆写）
工厂设计模式
对于接口而言，必须要有子类，并且子类可以通过对象向上转型来获取接口的实例化对象。对象实例化过程存在设计问题。
例子：观察程序
interface IFood{//定义接口标准
public void eat();
}
class Rice implements IFood{
public void eat(){
System.out.println(“吃米饭”);
}
}
public class Jiekou {
public static void main(String[] args)
{
IFood a=new Rice();
a.eat(); //吃米饭
}
}
此时程序结构设计如下：
如果添加一种功能喝饮料，就要修改new后面的类名，此时就出现了耦合问题，而造成耦合最直接的原因是“关键字new”。而JVM的核心原理是利用java虚拟机运行Java程序，操作系统与程序之间并不直接关联，由JVM来匹配。良好的设计应该避免耦合。（高内聚，低耦合）
例子：
interface IFood{//定义接口标准
public void eat();
}
class Rice implements IFood{
public void eat(){
System.out.println(“吃米饭”);
}
}
class Drink implements IFood{
public void eat(){
System.out.println(“喝饮料”);
}
}
class Factory{
public static IFood get(String className){
if (“rice”.equals(className)){
return new Rice();
}else if (“drink”.equals(className)){
return new Drink();
}else{
return null;
}
}
}
public class Jiekou {
public static void main(String[] args)
{
IFood food=Factory.get(args [0]);
food.eat();
}
}
输出结果：
F:\Java学习\java>java Jiekou rice
吃米饭
F:\Java学习\java>java Jiekou drink
喝饮料
在本程序中，客户端程序类与IFood接口的子类没有任何关联，所有的关联都是通过Factor类完成的，在程序运行时候通过初始化参数进行要使用的子类定义。
如果在日后进行子类扩充的时候，只需要修改factory类的程序类即可。
代理设计模式
代理设计模式功能是帮助用户将所有的开发注意力只集中在核心业务功能的处理上。例如：肚子饿了，如何可以吃的东西。
例子：实现代理设计
interface IEat{//定义接口标准
public void getEat();
}
class Person implements IEat{ //吃的主体人
public void getEat(){
System.out.println(“得到食物开始吃东西”);
}
}
class EatSever implements IEat{//为吃提供准备服务
private IEat eating;//为吃服务
public EatSever (IEat eating){
this.eating=eating;
}
public void getEat(){
this.prepare();
this.make();
this.eating.getEat();
this.clear();
}
public void prepare(){//准备过程
System.out.println(“第一步:购买食材”);
}
public void make(){
System.out.println(“第二步:加工食材”);
}
public void clear(){
System.out.println(“第三步:收拾碗筷”);
}
}
public class Jiekou {
public static void main(String[] args)
{
IEat a=new EatSever(new Person());
a.getEat();
}
}
输出结果：
第一步:购买食材
第二步:加工食材
得到食物开始吃东西
吃完东西付钱
第三步:收拾碗筷
代理设计模式主要特点是一个接口提供两个子类，其中一个子类是真实业务操作类，另一个主题是代理业务操作类。没有代理业务真实业务无法操作。