java设计模式

最新推荐文章于 2024-02-10 07:30:00 发布

woyixinyiyi

最新推荐文章于 2024-02-10 07:30:00 发布

阅读量557

点赞数

分类专栏：大话设计模式

本文链接：https://blog.csdn.net/woyixinyiyi/article/details/82107212

版权

大话设计模式专栏收录该内容

1 篇文章 0 订阅

订阅专栏

-----------------------------------------中介者模式---------------------------------------------

package 中介模式;

public class ConcreteMediator implements  Mediator {

    private Parter  parterA;
    private Parter parterB;

    @Override
    public void send(String msg, Parter parter) {
        if (parter instanceof  PartaerA){
            parterB.receive("parterB ConcreteMediator ");
        }else if (parter instanceof  ParterB){
            parterA.receive("PartaerA ConcreteMediator ");
        }
    }

    public  void  setParter(Parter parterA ,Parter parterB){
        this.parterA=parterA;
        this.parterB=parterB;
    }

package 中介模式;

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

        Parter parterA = new PartaerA();
        Parter parterB = new ParterB();
        Mediator mediator = new ConcreteMediator();
        parterA.setMediator(mediator);
        parterB.setMediator(mediator);//同时之间只认识 中介
       ((ConcreteMediator) mediator).setParter(parterA, parterB);

    ((PartaerA) parterA).send("111");
    }
}
package 中介模式;

public interface Mediator {
    public void send(String msg,Parter parter);
}
package 中介模式;

import 中介模式.Parter;

public class PartaerA extends Parter {

    public void send (String msg){
        mediator.send("this is A send " + msg,this);
    }


    public void receive (String msg){
        System.out.println("this is A receive msg " + msg);
    }
}
package 中介模式;

public abstract class Parter {
    Mediator mediator;

    public void setMediator(Mediator mediator){
        this.mediator=mediator;
    }

    public abstract  void receive(String msg);
package 中介模式;

public class ParterB extends  Parter {

    public void send (String msg){
       mediator.send("this is B send " + msg,this);
    }

    public void receive (String msg){
        System.out.println("this is B receive msg " + msg);
    }
}

}

}
-----------------------------------------中介者模式---------------------------------------------

--------------------------代理模式--------------------------------------
package 代理模式;

public class BeautifulGirl {

    String name;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
package 代理模式;

public interface Gift {

    void giveGift();
}

package 代理模式;

public class Liu  implements  Gift{


    @Override
    public void giveGift() {
        System.out.println( "liu send gift");
    }
}
package 代理模式;

/**
 * 代理模式
 * 本来 liu要送礼物给一个美丽女孩，但是害羞，通过代理小明赠送
 * 代理模式 代理者必须持有真实发生操作的引用，代理者和操作者需要实现同一个接口
 *
 *
 * 代理模式和装饰着模式，主要的区别在于侧重点不同
 *
 * 代理模式侧重点是 对原对象的执行的控制权，如果是要对原方法的改进 使用代理模式
 * 装饰模式侧重点是 对原对象的执行的功能的增加，对原方法增添新的功能 使用装饰着模式
 *
 */
public class Main {
    public static void main(String[] args) {

        XiaoMingProxy xiaoMingProxy = new XiaoMingProxy(new Liu());
        xiaoMingProxy.giveGift();

    }
}
package 代理模式;

public class XiaoMingProxy implements  Gift {
    Liu liu;
    @Override
    public void giveGift() {
        System.out.println(" proxy send gift ");
        liu.giveGift();
    }


    public XiaoMingProxy(Liu liu) {
        this.liu = liu;
    }
}

--------------------------代理模式--------------------------------------

---------------------------原型模式--------------------------
package 原型模式;



public class Book  implements  Cloneable {
    private  String id ;
    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Book(String id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package 原型模式;

import javax.sound.midi.Soundbank;

/**
 * 根据指定的原型创建实例对象,通过复制这个对象创建实例对象
 * 假如现在有一个班学生，去吃饭，他们的的班级和学校都相同。
 * clone一个对象的时候并不会调用构造方法 new出的对象。
 */
public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
       /*shapeCope();*/
        deepCope();
    }

    /**
     * 浅拷贝,只拷贝值中 基本类型的值，对于引用类型，是直接引用元对象。
     * @throws CloneNotSupportedException
     */
     static void shapeCope() throws CloneNotSupportedException{
         Student zhangsan = new Student("张三", 3,"302","北京丰台小学");
         Book book = new Book("1", "设计模式");
         zhangsan.setBook(book);
         Student clone = (Student)zhangsan.clone();
         clone.setName("李四");
         clone.setAge(4);
         clone.getBook().setId("2");
        System.out.println(zhangsan);
        System.out.println(clone);
    }

    /**
     * 深拷贝，会拷贝引用类型的对象
     * 这个时候重写 student类中的clone方法 对book也进行 值拷贝
     */
    static void deepCope() throws CloneNotSupportedException {
        Student zhangsan = new Student("张三", 3,"302","北京丰台小学");
        Book book = new Book("1", "设计模式");
        zhangsan.setBook(book);
        Student clone = (Student)zhangsan.clone();
        clone.setName("李四");
        clone.setAge(4);
        clone.getBook().setId("2");
        System.out.println(zhangsan);
        System.out.println(clone);
    }

}
package 原型模式;

public class Student  implements  Cloneable {

    private String name ;
    private int age;
    private String  room;
    private String  schoolAddress;
    private Book book;

    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name, int age, String room, String schoolAddress) {
        this.name = name;
        this.age = age;
        this.room = room;
        this.schoolAddress = schoolAddress;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getRoom() {
        return room;
    }

    public void setRoom(String room) {
        this.room = room;
    }

    public String getSchoolAddress() {
        return schoolAddress;
    }

    public void setSchoolAddress(String schoolAddress) {
        this.schoolAddress = schoolAddress;
    }

    /*@Override*/
    /*protected Object clone() throws CloneNotSupportedException {*/
    /*    return super.clone();*/
    /*}*/

     @Override
     protected Object clone() throws CloneNotSupportedException {
            Student student =  null;

            student = (Student) super.clone();
            student.book = (Book) this.book.clone();
            return student;

       }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", room='" + room + '\'' +
                ", schoolAddress='" + schoolAddress + '\'' +
                ", book=" + book +
                '}';
    }
}


---------------------------原型模式--------------------------

-----------------------------备忘录模式----------------------------
package 备忘录模式;

public class Caretaker {
    private Memento memento;

    public Caretaker(Memento memento) {
        this.memento = memento;
    }

    public Memento getMemento() {
        return memento;
    }

    public void setMemento(Memento memento) {
        this.memento = memento;
    }
}
package 备忘录模式;

public class CFRole {
    private int blood;
    private int gunCount;
    private int state;

    @Override
    public String toString() {
        return "CFRole{" +
                "blood=" + blood +
                ", gunCount=" + gunCount +
                ", state=" + state +
                '}';
    }

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
    }

    public int getBlood() {
        return blood;
    }

    public void setBlood(int blood) {
        this.blood = blood;
    }

    public int getGunCount() {
        return gunCount;
    }

    public void setGunCount(int gunCount) {
        this.gunCount = gunCount;
    }

    public void fightBoss(){
        blood = 0;
        gunCount = 0;
    }

    public void show(){
        System.out.println("子弹数量:"+gunCount+";血："+blood);
    }
}
package 备忘录模式;

/**
 * memento 为备份 当前的cfrole角色对象， caretaker为角色管理人，管理当前的备份。
 *
 * originaler为当前 角色 备份发起人
 */
public class Main {

    public static void main(String[] args) {
        Originaler originaler = new Originaler();
        CFRole cfRole = new CFRole();
        cfRole.setBlood(100);
        cfRole.setGunCount(30);
        originaler.setCfRole(cfRole);
        Caretaker caretaker = new Caretaker(originaler.createMemento());

        originaler.getCfRole().fightBoss();
        originaler.rescover(caretaker.getMemento());
        System.out.println(originaler.getCfRole());

    }


}
package 备忘录模式;

public class Memento {
    private CFRole cfRole;

    public CFRole getCfRole() {
        return cfRole;
    }

    public void setCfRole(CFRole cfRole) {
        this.cfRole = cfRole;
    }

    public Memento(CFRole cfRole) {
        this.cfRole = new CFRole();
        this.cfRole.setGunCount(cfRole.getGunCount());
        this.cfRole.setBlood(cfRole.getBlood());
        this.cfRole.setState(cfRole.getState());
    }
}
package 备忘录模式;

public class Originaler {


    private CFRole cfRole;

   public Memento  createMemento(){
     return new Memento(cfRole);
   }

    public CFRole getCfRole() {
        return cfRole;
    }

    public void setCfRole(CFRole cfRole) {
        this.cfRole = cfRole;
    }

    public  void rescover(Memento memento){
       this.cfRole = memento.getCfRole();
    }


}

-----------------------------备忘录模式----------------------------

----------------------------外观模式-----------------------
package 外观模式;

public class CaiDan {
    private XiCai xiCai = new XiCai();
    private QieCai qieCai = new QieCai();
    private ChaoCai chaoCai = new ChaoCai();

    void zuoCai(){

        xiCai. beginXiCai();

        qieCai.beginQieCai();

        chaoCai.beginChaoCai();
    }

}
package 外观模式;

public class ChaoCai {

    void beginChaoCai(){

        System.out.println(" 开始炒菜 ");
    }
}
package 外观模式;

/**
 * 对外 掩藏子系统的内部实现，只需和外部接口内交互，更好的划分职责和层次。
 * 继续做菜，你只关心菜做好，实际并不关心，洗菜，切菜的等操作。由接口内 进行调用子系统进行相应的操作
 *
 *
 */
public class Main {
    public static void main(String[] args) {

        CaiDan caiDan = new CaiDan();
        caiDan.zuoCai();

    }

}
package 外观模式;

public class QieCai {

    void  beginQieCai(){
        System.out.println(" 开始切菜 ");
    }
}
package 外观模式;

public class XiCai {

    void beginXiCai(){
        System.out.println(" 开始洗菜 ");
    }
}

----------------------------外观模式-----------------------

-------------------------工厂方法模式-----------------------------
package 工厂方法模式;

public class Add  extends   AlgorithmFactory {
    @Override
    public AlgorithmFactory createAlgorithm() {
        return new Add();
    }
   @Override
    public String getResult(String a ,String b){

        return String.valueOf(Integer.valueOf(a) + Integer.valueOf(b));
    }

}
package 工厂方法模式;

public class AlgorithmFactory implements JiSuan   {

    AlgorithmFactory createAlgorithm(){
     return null;
    }


    @Override
    public String getResult(String a, String b) {
        return null;
    }
}
package 工厂方法模式;


public  interface JiSuan {

    public String getResult(String a ,String b );
}
package 工厂方法模式;


/**
 * 工厂方法模式，和简单工厂模式，区别，工厂方法模式实例化对象是在子类完成的，而简单工厂模式是在工厂父类完成的
 * 这样 动态添加算法的时候，就不需要修改原算法工厂了，不用在switch里面添加分支
 *
 *
 */
public class Main {
    public static void main(String[] args) {
        AlgorithmFactory algorithmFactory = new Add();
        AlgorithmFactory algorithm = algorithmFactory.createAlgorithm();
        String result = algorithm.getResult("1", "4");
        System.out.println(result);
    }
}
package 工厂方法模式;

public class Sub extends AlgorithmFactory {

    @Override
    public AlgorithmFactory createAlgorithm() {
        return new Sub();
    }

    @Override
    public String getResult(String a ,String b){

        return String.valueOf(Integer.valueOf(a) - Integer.valueOf(b));
    }
}

-------------------------工厂方法模式-----------------------------

-----------------------工厂模式------------------------------
package 工厂模式;

public class Add  extends  JiSuan {
    @Override
    String getResult(String a, String b) {
        return String.valueOf((Integer.valueOf(a) + Integer.valueOf(b)));
    }
}

package 工厂模式;

public class AlgorithmFactory {


   JiSuan  getAlgorithm(String type){
        switch (type){
            case "+" :
            return new Add();

            case "-":
            return  new Sub();
        }

       return null;
   }

}
package 工厂模式;

public abstract class JiSuan {
   abstract String  getResult(String a,String b);
}
package 工厂模式;

public class Main {

    /**
     * 简单工厂模式 ：根据合适的条件创建一类对象。
     * @param args
     */
    public static void main(String[] args) {
        JiSuan algorithm = new AlgorithmFactory().getAlgorithm("+");
        String result = algorithm.getResult("1", "2");
        System.out.println(result);
    }
}
package 工厂模式;

public class Sub  extends  JiSuan{

    @Override
    String getResult(String a, String b) {
        return String.valueOf((Integer.valueOf(a) - Integer.valueOf(b)));
    }


}

-----------------------工厂模式------------------------------

--------------------------建造者模式---------------------------
package 建造者模式;

/**
 * 规范建造人的过程
 */
public interface Builder {

    Builder buildHead();
    Builder buildBody();
    Builder buildFoot();

    //构造人的方法
    Person build();

}
package 建造者模式;

public class ConcreteBuilder implements Builder {

    Person person = new Person();

    @Override
    public Builder buildHead() {
        System.out.println(" build head ");
        person.setHead("head");
        return this;
    }

    @Override
    public Builder buildBody() {
        System.out.println(" build body ");
        person.setBody("body");
        return this;
    }

    @Override
    public Builder buildFoot() {
        System.out.println(" build foot ");
        person.setFoot("foot");
        return this;
    }

    @Override
    public Person build() {
       return this.person;
    }
}
package 建造者模式;

/**
 * 指导者，指导具体的建造顺序，
 */
public class Director {

    Person buildPerson(Builder builder){
        builder.buildHead();
        builder.buildBody();
        builder.buildFoot();
        return  builder.build();
    }


}
package 建造者模式;

/**
 * 使对象的构造与展示分离
 * 适用于 构造的对象比较复杂，或者构造的顺序 会产生不同的对象
 *
 */
public class Main {


    public static void main(String[] args) {
      /*  Director director =  new Director();
        director.buildPerson(new ConcreteBuilder());*/

      //当不使用director类的时候 来构造一个对象

        Person person = new ConcreteBuilder().buildHead().buildBody().buildFoot().build();
        System.out.println(person);
    }
}
package 建造者模式;

/**
 * 人是个复杂的对象 由三部分组成。
 *
 */
public class Person {
    String head;
    String body;
    String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

--------------------------建造者模式---------------------------

---------------------------桥接模式-------------------
package 桥接模式;

public class ApplePhone  implements  Phone{
    @Override
    public void play() {
        System.out.println("use applephone play");
    }
}
package 桥接模式;

/**
 * 桥接模式 是抽象和实现分离， 抽象，实现部分可以自行扩展，使得两者都可以独立变化
 * soft 也可以 实现一个 照相的功能，但是不是所有手机都支持的，那个支持照相 设置即可
 * 手机型号也可以 有一个 三星手机，也可以动态设置所有功能
 */
public class Main {
    public static void main(String[] args) {
        Phone phone = new ApplePhone() ;
        Soft music = new MusicSoft();
        music.setPhone(phone);
        music.play();
     }
}
package 桥接模式;

public class MotoPhone implements Phone {

    @Override
    public void play() {
        System.out.println("use motophone play");
    }
}
package 桥接模式;

public class MusicSoft extends  Soft {

    public void play(){
        System.out.println("i am musicsoft");
        super.play();
    }
}
package 桥接模式;

public interface Phone {

    public void play();
}
package 桥接模式;

public abstract class Soft {

    Phone phone ;

    public void play(){
        phone.play();
    }

    public void setPhone (Phone phone){
        this.phone = phone;
    }


}

---------------------------桥接模式-------------------

------------------------------模板模式--------------------------
package 模板模式;

/**
 * 菜品基类 ，提供骨架算法
 */
public abstract class Food {

    public void doFood(){

        System.out.println("洗菜");
        System.out.println("切菜");
        getDeliciours();//具体怎么做衍生到子类去做
        System.out.println("装盘");
    }

    protected abstract void getDeliciours();
}
package 模板模式;

public class HongShao extends  Food {

    @Override
    protected void getDeliciours() {
        System.out.println("红烧菜");
    }
}
package 模板模式;

/**
 * 由 基类定义一些算法骨架，由子类做一些差别衍生
 *
 * 比如现在做菜。由父类提供材料，由子类进行实现
 */
public class Main {
    public static void main(String[] args) {

        Food food = new HongShao();
        food.doFood();
    }
}
package 模板模式;

public class Zhu extends Food {

    @Override
    protected void getDeliciours() {
        System.out.println("煮菜");
    }
}

------------------------------模板模式--------------------------

---------------------策略模式-----------------------
package 策略模式;

public class Add  extends JiSuanStratgy {
    @Override
    String getResult(String a, String b) {
        return String.valueOf((Integer.valueOf(a) + Integer.valueOf(b)));
    }
}
package 策略模式;

/**
 * 具体封装的上下文类
 */
public class Context {

    private  JiSuanStratgy stratgy;

    Context( JiSuanStratgy stratgy){
        this.stratgy = stratgy;
    }

   String  getResult(String a,String b){
       String result = stratgy.getResult(a, b);
       return result;
   }

}
package 策略模式;

/**
   公共的策略方法
 */
public  class JiSuanStratgy {
    String  getResult(String a,String b){
       return a;
    }
}
package 策略模式;

public class Main {

    /**
     *  * 策略类，提供相应的公共接口，由其子类去实现策略，子类可以互相替换
     *  * 策略模式  对具体的算法封装，只对外暴露其策略方法。
     *  *  context，客户端必须知道 有哪些策略类，具体调用那个策略由客户端决定
     * @param args
     */
    public static void main(String[] args) {

        Context context = new Context(new Add());
        String result = context.getResult("1", "2");
        System.out.println(result);
    }
}
package 策略模式;

public class Sub  extends JiSuanStratgy {

    @Override
    String getResult(String a, String b) {
        return String.valueOf((Integer.valueOf(a) - Integer.valueOf(b)));
    }


}


---------------------策略模式-----------------------

------------------------职责链模式------------------------
package 职责链模式;

public class Large implements  Math {

    @Override
    public int jisuan(int a, int b) {
        System.out.println("this is  large");
        return a+b;
    }
}
package 职责链模式;

public class Main {

    public static void main(String[] args) {

        SmallMath smallMath = new SmallMath();
        Medium medium = new Medium();
        Large large = new Large();

        smallMath.math = medium;
        medium.math = large;

        int jisuan = smallMath.jisuan(10, 20);
        System.out.println(jisuan);
    }
}

package 职责链模式;

public interface Math {

   int jisuan(int a,int b);
}
package 职责链模式;

public class Medium implements  Math {
    Math math;
    @Override
    public int jisuan(int a, int b) {
        if (a<20 || b<20 ){
            System.out.println("this is  medium");
            return a+b;
        }else {
            return math.jisuan(a, b);
        }
    }
}
package 职责链模式;

public class SmallMath implements Math{
    Math math ;
    @Override
    public int jisuan(int a, int b) {
        if (a < 10  || b < 10){
            System.out.println("this is  small");
            return a+b;
        }else{
            return  math.jisuan(a, b);
        }
    }
}

------------------------职责链模式------------------------

----------------------装饰着模式------------------------
package 装饰着模式;

/**
 * 装饰  公共 的基类,可以给对象动态的添加职责
 */
public interface Eat {
    void eat();
}
package 装饰着模式;

public abstract class Food implements  Eat {
    Eat  eat;

    public Eat getEat() {
        return eat;
    }

    public void setEat(Eat eat) {
        this.eat = eat;
    }

    @Override
    public void eat() {

    }
}
package 装饰着模式;

/**
 * 装饰着模式：把职责动态的添加到已有的对象上去
 * 原本执行的是 liu吃米饭这个方法，现在需要给这个饭加上菜
 * 装饰着模式  有一个共同的基类（FOOD），因为要在装饰的类中执行原方法。
 */
public class Main {

    public static void main(String[] args) {
        Person liu = new Person();
        liu.setName("liu");
        XiaoLongXia xiaoLongXia = new XiaoLongXia();
        xiaoLongXia.setEat(liu);
        PiPiXia piPiXia = new PiPiXia();
        piPiXia.setEat(xiaoLongXia);
        piPiXia.eat();

    }
}
package 装饰着模式;

public class NiuPai extends   Food  {
    @Override
    public void eat() {
        System.out.println(" 加 牛排 ");
    }
}

package 装饰着模式;

public class Person implements  Eat  {

    String name;

    public void eat(){
        System.out.println( name  + " 吃米饭 " );
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}
package 装饰着模式;

public class PiPiXia extends   Food  {

    @Override
    public void eat() {
        eat.eat();
        System.out.println(" 加皮皮虾 ");
    }
}
package 装饰着模式;

public class XiaoLongXia extends   Food {
    @Override
    public void eat() {
        eat.eat();
        System.out.println(" 加 小龙虾");
    }
}

----------------------装饰着模式------------------------

-----------------------观察者模式-------------------
package 观察者模式;

public class AmericaMan implements  Observer {


    @Override
    public void update(String message) {
        System.out.println("当前AmericaMan接收 到最新 直播信息 " + message);
    }


}
package 观察者模式;

public class FIFATV extends Subject {

    @Override
    public String getState() {
        return "fifa living";
    }



}
package 观察者模式;

public class JapanMan implements  Observer {
    @Override
    public void update(String message) {
        System.out.println("当前JapanMan接收 到最新 直播信息 " + message);
    }
}
package 观察者模式;

public class Main {

    public static void main(String[] args) {
        //声明两个观察者
        Observer americaMan = new AmericaMan();
        Observer japanMan = new JapanMan();


        //声明两个主题
        Subject fifa = new FIFATV();
        Subject nba = new NBATV();

        fifa.addObserver(japanMan);


        nba.addObserver(americaMan);
        nba.addObserver(japanMan);

        fifa.notifyObserver(fifa.getState() + "比分 0：1");

        nba.notifyObserver(nba.getState() + "比分 103 ：93");
    }
}
package 观察者模式;

public class NBATV extends  Subject{

    @Override
    String getState() {
        return "nba liveing";
    }
}
package 观察者模式;

/**
 * 定义一个观察者接口
 */
public interface Observer {

    void update(String message);

}
package 观察者模式;

import java.util.ArrayList;
import java.util.List;

/**
 * 定义一个主题接口
 */
public abstract class Subject {

    protected String state;

    protected List<Observer> observerList = new ArrayList<>();


    protected void  addObserver(Observer observer){
        observerList.add(observer);
    }

    protected void deleteObserver(Observer observer){
        observerList.remove(observer);
    }

    public void notifyObserver(String message){
        for (Observer observer: observerList) {
            observer.update(message);
        }
    }

    abstract  String  getState();

    public void setState(String state) {
        this.state = state;
    }
}

-----------------------观察者模式-------------------

----------------------适配器模式------------------------
package 适配器模式;

public interface AndroidCharge {
    public void  chargeAndroid(String phone);
}
package 适配器模式;

public interface AppleCharge {
    public void chargeApple(String phone);

}
package 适配器模式;

public class AppleChargeConcrete implements  AppleCharge {

    @Override
    public void chargeApple(String phone) {
        System.out.println("current charge apple is " + phone);
    }
}
package 适配器模式;

public class ChargeAdapter implements  AndroidCharge {

    private AppleCharge  appleCharge = new AppleChargeConcrete();

    @Override
    public void chargeAndroid(String phone) {
        appleCharge.chargeApple(phone);
    }
}
package 适配器模式;

/**
 * 假设 现在 有个 苹果充电线， 有个安卓充电线， 现在有个苹果手机，
 * 假设苹果充电线是 不能直接充电 的，通过适配器，通过安卓接口  间接充电
 */
public class Main {

    public static void main(String[] args) {
        ChargeAdapter chargeAdapter = new ChargeAdapter();
        chargeAdapter.chargeAndroid( "iphone6");

    }

}

----------------------适配器模式------------------------