【持续更新】设计模式

继承

接口实现

关联 即A中引用了B

聚合

组合 对于 自身属性

依赖 对于传入方法参数

为什么尽量不去改动已有的代码

一是为了防止有些程序员恶意破坏
二是改了之后已有的代码还需要重新到各个机器编译安装一次

简单工厂模式

运用多态，通过switch 来判断应该创建哪个子类的实例

public abstract class Operation {
double numberA=0d;
double numberB=0d;

protected void setNumberA(double number){
numberA = number;
}
protected double getNumberA(){
return numberA;
}

protected void setNumberB(double number){
numberB = number;
}
protected double getNumberB(){
return numberB;
}

public abstract double getResult();

}


public class OperationAdd extends Operation{
double result = 0d;

public double getResult(){
result = numberA+numberB;
return result;
}
}

减法
public class OperationSubtraction extends Operation{
double result = 0d;

public double getResult(){
result = numberA-numberB;
return result;
}
}

除法
public class OperationDivision extends Operation{
double result = 0d;

public double getResult(){
if(numberB !=0){
result = numberA/numberB;
}else{
System.out.println("Exception: divisor is zero!");
result = -0.0d;
}
return result;
}
}

public class OperationFactory {

public static Operation specificOperate(String operate){
Operation mOperation = null;
switch (operate){
case "+":{
mOperation = new OperationAdd();
break;
}
case "-":{
mOperation = new OperationSubtraction();
break; 
}
case "*":{
mOperation = new OperationMultiplication();
break; 
}
case "/":{
mOperation = new OperationDivision();
break; 
}
default :{
break;
}
}
return mOperation;
}


}


import java.util.Scanner;
public class OperateResult {

@SuppressWarnings("resource")
public static void main(String args[]){
Scanner mScanner = new Scanner(System.in);
double operateResult =0d;

System.out.println("please input numberA:");
double firstNum = mScanner.nextDouble();

System.out.println("please input numberB:");
double secondNum = mScanner.nextDouble();

System.out.println("please input operate + - * /:");
String mOperate = mScanner.next();

Operation spesificOperate = OperationFactory.specificOperate(mOperate);
if(spesificOperate !=null){
spesificOperate.setNumberA(firstNum);
spesificOperate.setNumberB(secondNum);
operateResult = spesificOperate.getResult();
}

System.out.print("operate result is :");
System.out.println(operateResult);

}
}

策略模式+简单工厂 在工厂实例化具体的子类后 仍然可以用该类去掉用共有的方法

public class OperationFactory {

public static Operation specificOperate(String operate){
Operation mOperation = null;
switch (operate){
case "+":{
OperationAdd mOperation1 = new OperationAdd();
mOperation= mOperation1;
break;
}
case "-":{
OperationSubtraction mOperation2 = new OperationSubtraction();
mOperation= mOperation2;
break; 
}
case "*":{
OperationMultiplication mOperation3 = new OperationMultiplication();
mOperation= mOperation3;
break; 
}
case "/":{
OperationDivision mOperation4 = new OperationDivision();
mOperation= mOperation4;
break; 
}
default :{
break;
}
}
return mOperation;
}

public double GetResult(double money){
    retuern mOperation.acceptCash(money);
}
}

装饰模式：

Component 
public interface Person {

    void eat();
}

ConcreteComponent 

public class Man implements Person {

    public void eat() {
        System.out.println("男人在吃");
    }
}

Decorator

public abstract class Decorator implements Person {
    protected Person person;
    public void setPerson(Person person) {
        this.person = person;
    }

    public void eat() {
        person.eat();
    }
}

ConcreteDectrator

public class ManDecoratorA extends Decorator {

    public void eat() {
        super.eat();
        reEat();
        System.out.println("ManDecoratorA类");
    }

    public void reEat() {
        System.out.println("再吃一顿饭");
    }
}
public class ManDecoratorB extends Decorator {

    public void eat() {
        super.eat();
        System.out.println("===============");
        System.out.println("ManDecoratorB类");
    }
}

Test 

public class Test {

    public static void main(String[] args) {
        Man man = new Man();
        ManDecoratorA md1 = new ManDecoratorA();
        ManDecoratorB md2 = new ManDecoratorB();

        md1.setPerson(man);
        md2.setPerson(md1);
        /*Md2在调用eat时会先调用super.eat即person.eat 这里的、、person就是md1 而md1.eat也会调用super.eat md1的person是传入的参数man,依此类推… */
        md2.eat();
    }
}

代理模式：代理把真是的对象中的实现方法隐藏起来 只暴露方法 不非方法的实现

public interface ICoder {

    public void implDemands(String demandName);

}

public class JavaCoder implements ICoder{

    private String name;

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

    @Override
    public void implDemands(String demandName) {
        System.out.println(name + " implemented demand:" + demandName + " in JAVA!");
    }
}

public class CoderProxy implements ICoder{

    private ICoder coder;

    public CoderProxy(ICoder coder){
        this.coder = coder;
    }

    @Override
    public void implDemands(String demandName) {
        coder.implDemands(demandName);
    }
}

public class Customer {

    public static void main(String args[]){
        //定义一个java码农
        ICoder coder = new JavaCoder("Zhang");
        //定义一个产品经理
        ICoder proxy = new CoderProxy(coder);
        //让产品经理实现一个需求
        proxy.implDemands();
    }
}

工厂方法模式：将生成类的工厂抽象为接口 用具体的工厂去实现它 创建时不用再像简单工厂那样去用switch去判断创建哪个子类，而是直接创建总工厂类型的子工厂实例对象 每当需要修改的时候只需要修改“创建总工厂类型的子工厂实例对象”这一句代码即可完成子类工厂的更换
abstract class BMW {
    public BMW(){

    }
}
public class BMW320 extends BMW {
    public BMW320() {
        System.out.println("制造-->BMW320");
    }
}
public class BMW523 extends BMW{
    public BMW523(){
        System.out.println("制造-->BMW523");
    }
}

interface FactoryBMW {
    BMW createBMW();
}

public class FactoryBMW320 implements FactoryBMW{

    @Override
    public BMW320 createBMW() {

        return new BMW320();
    }

}
public class FactoryBMW523 implements FactoryBMW {
    @Override
    public BMW523 createBMW() {

        return new BMW523();
    }
}

public class Customer {
    public static void main(String[] args) {
        FactoryBMW320 factoryBMW320 = new FactoryBMW320();
        BMW320 bmw320 = factoryBMW320.createBMW();

        FactoryBMW523 factoryBMW523 = new FactoryBMW523();
        BMW523 bmw523 = factoryBMW523.createBMW();
    }
}