`

适配器模式1

阅读更多

上代码：

Person类

package com.wjy.adaptable.entity;

import com.wjy.adaptable.adaptabler.MainOperator;

public class Person implements IAdaptable{
   public String name;
   public int age;
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;
}
@Override
public Object getAdapter(Class adapter) {
    // TODO Auto-generated method stub
    if(adapter==MainOperator.class)
        return new MainOperator(this);
    return null;
}
   
}

person类的三个子类：

package com.wjy.adaptable.entity;

import com.wjy.adaptable.adaptabler.AdultOperator;

public class Man extends Person {
public double height;
public double weight;
public double getHeight() {
    return height;
}
public void setHeight(double height) {
    this.height = height;
}
public double getWeight() {
    return weight;
}
public void setWeight(double weight) {
    this.weight = weight;
}
@Override
public Object getAdapter(Class adapter) {
    // TODO Auto-generated method stub
    if(adapter==AdultOperator.class)
        return new AdultOperator(this);
    return null;
}
}



package com.wjy.adaptable.entity;

import com.wjy.adaptable.adaptabler.AdultOperator;

public class Woman extends Person {
public double height;
public double weight;
public double getHeight() {
    return height;
}
public void setHeight(double height) {
    this.height = height;
}
public double getWeight() {
    return weight;
}
public void setWeight(double weight) {
    this.weight = weight;
}
@Override
public Object getAdapter(Class adapter) {
    // TODO Auto-generated method stub
    if(adapter==AdultOperator.class)
        return new AdultOperator(this);
    return null;
}
}



package com.wjy.adaptable.entity;

import com.wjy.adaptable.adaptabler.ChildOperator;
import com.wjy.adaptable.adaptabler.MainOperator;

public class Child extends Person {
public double height;
public double weight;
public double getHeight() {
    return height;
}
public void setHeight(double height) {
    this.height = height;
}
public double getWeight() {
    return weight;
}
public void setWeight(double weight) {
    this.weight = weight;
}
@Override
public Object getAdapter(Class adapter) {
    // TODO Auto-generated method stub
    if(adapter==ChildOperator.class)
        return new ChildOperator(this);
    return null;
}
}

IAdaptable接口：

package com.wjy.adaptable.entity;
public interface IAdaptable {
    public abstract Object getAdapter(Class adapter);
}

Result类：

package com.wjy.adaptable.entity;

public class Result {
   public int age;
   public String name;
   public double height;
   public double weight;
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public double getHeight() {
    return height;
}
public void setHeight(double height) {
    this.height = height;
}
public double getWeight() {
    return weight;
}
public void setWeight(double weight) {
    this.weight = weight;
}
   
}

以下为为了实现适配器模式写的接口和类：

operateResult接口：

package com.wjy.adaptable.adaptabler;

import com.wjy.adaptable.entity.Result;

public interface operateResult {
public abstract Result getPerson();
}

MainOperator类：

package com.wjy.adaptable.adaptabler;

import com.wjy.adaptable.entity.Person;
import com.wjy.adaptable.entity.Result;

public class MainOperator implements operateResult{
    Person person;
    public MainOperator(Person person)
    {
        this.person=person;
    }
    @Override
    public Result getPerson() {
        // TODO Auto-generated method stub
        return null;
    }
    
}

MainOperator类的两个子类，其中AdultOperator类处理Woman和Man：
ChildOperator类处理Child:

package com.wjy.adaptable.adaptabler;

import com.wjy.adaptable.entity.Man;
import com.wjy.adaptable.entity.Person;
import com.wjy.adaptable.entity.Result;
import com.wjy.adaptable.entity.Woman;

public class AdultOperator extends MainOperator{
    public AdultOperator(Person person) {
        super(person);
    }

    @Override
    public Result getPerson() {
        Result result = new Result();
        if(person instanceof Man)
        {
            result.name=person.name;
            result.age=person.age;
            result.height=((Man) person).height;
            result.weight=((Man) person).weight;
        }
        else if(person instanceof Woman)
        {
            result.name=person.name;
            result.age=person.age;
            result.height=((Woman) person).height;
            result.weight=((Woman) person).weight;
        }
        return result;
    }
}



package com.wjy.adaptable.adaptabler;

import com.wjy.adaptable.entity.Child;
import com.wjy.adaptable.entity.Person;
import com.wjy.adaptable.entity.Result;
import com.wjy.adaptable.entity.Woman;

public class ChildOperator extends MainOperator {
    Result result=new Result();
    public ChildOperator(Person person) {
        super(person);
        // TODO Auto-generated constructor stub
    }

    @Override
    public Result getPerson() {
        Child child=(Child)person;
        result.name=child.name;
        result.age=child.age;
        result.weight=child.weight;
        result.height=child.height;
        return result;
    }
    
}

Main方法调用：

package com.wjy.adaptable.operator;

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

import com.wjy.adaptable.adaptabler.AdultOperator;
import com.wjy.adaptable.adaptabler.ChildOperator;
import com.wjy.adaptable.entity.Child;
import com.wjy.adaptable.entity.Man;
import com.wjy.adaptable.entity.Person;
import com.wjy.adaptable.entity.Woman;

public class humanManager {
public static void main(String[] args)
{
    List<Person> persons=new ArrayList<>();
    Woman woman=new Woman();
    woman.age=21;
    woman.name="yhw";
    woman.height=167.00;
    woman.weight=50.00;
    persons.add(woman);
    
    Man man=new Man();
    man.age=21;
    man.name="wjy";
    man.height=177.00;
    man.weight=74.00;
    persons.add(man);
    
    Child child=new Child();
    child.name="xiaobu";
    child.age=2;
    child.height=55.00;
    child.weight=88;
    persons.add(child);
    
    for (Person person : persons) {
        if(person instanceof Man || person instanceof Woman)
        {
            System.out.println((((AdultOperator)(person.getAdapter(AdultOperator.class))).getPerson()).name);
        }
        else if(person instanceof Child)
        {
            System.out.println((((ChildOperator)(person.getAdapter(ChildOperator.class))).getPerson()).name);
        }
    }
}
}

 

 

分享到：
| 《将博客园博客搬至CSDN 和 ITEYE》
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    类适配器， 对象适配器模式，缺省适配器模式1

    1. **类适配器模式**： 在类适配器模式中，适配器类通过继承被适配类（Adaptee）并实现目标接口（Target）。这种方式下，适配器和被适配类之间存在继承关系，因此适配器可以直接访问被适配类的所有公共方法。在Java...

    13适配器模式1

    1. 类适配器模式： 在类适配器模式中，适配器类通过继承目标接口（或者多个目标接口，通过多重继承实现）并组合原始不兼容类的方式工作。这种方式的优点是代码结构清晰，但缺点是如果原始类接口发生变化，适配器类...

    8.设计模式-适配器模式1

    适配器模式是一种软件设计模式，它允许不同的接口或类之间进行通信，即使它们的接口不兼容。适配器模式的核心思想是通过创建一个适配器类，将原有类的接口转换为客户期望的接口，从而使得原本无法协作的类能够协同...

    8. 适配器模式1

    适配器模式是一种设计模式，它的主要目的是解决不兼容接口之间的通信问题，使得原本由于接口不匹配而无法协同工作的组件可以有效地协作。在软件工程中，适配器模式扮演着“桥梁”的角色，将旧的或者不同的接口转换成...

    JAVA设计模式（抽象类与适配器模式）

    同时，“[浪曦原创]JAVA设计模式 第1讲 抽象类与适配器模式(jzkangta).exe”应该是一个视频教程，可以帮助你更直观地学习。PPT文件“抽象类与适配器模式.ppt”则可能是教学幻灯片，列出了关键点和示例。最后，“demo...

    设计模式之适配器模式Java实现和类设计图

    在这个Java实现中，我们将深入探讨适配器模式的两大类型：类适配器模式和对象适配器模式，并通过具体的代码示例和UML类图来阐述其工作原理。 首先，我们来理解适配器模式的基本概念。适配器模式就像现实生活中的...

    设计模式之适配器模式

    1. 当你想使用一个已经存在的类，但是它的接口不符合你的需求时，可以通过适配器模式调整接口，使其满足你的应用需求。 2. 在多个类库之间进行整合，每个库都有自己的接口定义，但需要它们共同协作完成任务时，...

    java设计模式之适配器模式

    适配器模式是一种在软件工程中广泛使用的结构型设计模式，它允许两个不兼容的接口之间进行通信。在Java中，适配器模式扮演着重要的角色，尤其在处理遗留代码或者第三方库集成时，能够有效地解决接口不匹配的问题。...

    Week11 适配器模式1

    1. **适配器模式**：适配器模式是一种结构型设计模式，它的主要目的是将两个不兼容的接口转换为可以互相操作的形式。在Python中，这通常通过创建一个新的类来实现，该类包含要适配的对象，并提供与目标接口相匹配的...

    设计模式 - 适配器模式(C++实例)

    1. 类适配器模式： 在类适配器模式中，适配器类继承自目标接口，并且通常也包含对原始不兼容接口的引用。适配器类通过重写或实现目标接口的方法，调用原始接口的方法，从而达到接口转换的目的。这种方式在C++中常见...

    第3.1章 适配器模式1

    适配器模式是一种软件设计模式，它允许不同的接口或类之间进行通信，即使它们的接口不兼容。在上述描述中，我们面临的问题是如何在现有系统中添加新的功能，即从数据库中获取数据并以JSON格式返回，而不会破坏原有的...

    java 动态代理模式 适配器模式

    Java动态代理模式与适配器模式是两种在软件设计中常用的设计模式，它们都有各自的优点和应用场景。在Java中，动态代理模式主要依赖于Java的反射API和InvocationHandler接口，而适配器模式则用于解决不同接口之间的...

    01-02-05-模板模式及适配器模式1

    适配器模式则是用来解决接口不兼容问题的设计模式，它可以将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的那些类能够一起工作。这种模式常用于老代码的维护或系统集成时，需要...

    java中适配器模式案例

    适配器模式是一种设计模式，它允许不兼容的类或接口之间进行通信，通过创建一个适配器类作为中间桥梁，使得原本不匹配的接口能够协同工作。在Java中，适配器模式广泛应用于系统集成、旧代码复用以及第三方库的兼容性...

    适配器模式案例代码

    1. **适配器模式的结构**： - **目标（Target）接口**：这是客户端需要调用的接口，通常定义了符合客户端期望的业务行为。 - **原始类（Adaptee）**：这是现有的、不兼容的接口，需要被适配以满足目标接口的需求。...

Magicbox
Global site tag (gtag.js) - Google Analytics