软件重构学习篇(一)

最新推荐文章于 2024-04-28 14:25:45 发布

helloworld2353

最新推荐文章于 2024-04-28 14:25:45 发布

阅读量192

点赞数

文章标签：重构学习 java

本文链接：https://blog.csdn.net/helloworld2353/article/details/130411715

版权

第一次学习重构记录一下

package test1.exma3;

public interface Shape {
    void draw();
    void erase();
}

package test1.exma3;

public class Rectangle implements Shape {
    public void draw() {
        System.out.println("Drawing Rectangle");
    }

    public void erase() {
        System.out.println("Erasing Rectangle");
    }
}


package test1.exma3;

public class Triangle implements Shape {
    public void draw() {
        System.out.println("Drawing Triangle");
    }

    public void erase() {
        System.out.println("Erasing Triangle");
    }
}

package test1.exma3;

public class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing Circle");
    }

    public void erase() {
        System.out.println("Erasing Circle");
    }
}

package test1.exma3;

public class UnsupportedShapeException extends RuntimeException {
    public UnsupportedShapeException(String message) {
        super(message);
    }
}

package test1.exma3;

public class DrawingTool {
    public static Shape createShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("Circle")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("Rectangle")) {
            return new Rectangle();
        } else if (shapeType.equalsIgnoreCase("Triangle")) {
            return new Triangle();
        } else {
            throw new UnsupportedShapeException("Shape not supported: " + shapeType);
        }
    }
}

package test1.exma3;

import test1.exma2.ShapeFactorys;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        System.out.println("请输入要绘制的图形");
        Scanner in = new Scanner(System.in);
        String stringShape=in.next();
        DrawingTool drawingTool = new DrawingTool();
        try {
            Shape shape1 = drawingTool.createShape(stringShape);
            shape1.draw();
            shape1.erase();
        }catch (Exception e){
            System.out.println(e.getMessage());
        }
    }
}

exma3：(普通工厂模式)

单一职责原则（Single Responsibility Principle，SRP）：接口Shape只定义了绘制和擦除方法，遵循了该原则。类Rectangle、Triangle、Circle实现了接口Shape，它们的职责也是实现绘制和擦除方法。
开闭原则（Open/Closed Principle，OCP）：类DrawingTool是一个工厂类，通过传入参数创建不同的图形。当需要添加新的图形时，只需要在该类中添加相应的代码即可，不需要修改原有代码。
里氏替换原则（Liskov Substitution Principle，LSP）：所有图形都实现了Shape接口，可以在任何需要Shape接口的地方使用具体的图形类。
接口隔离原则（Interface Segregation Principle，ISP）：接口Shape只定义了绘制和擦除方法，没有过多的接口方法，遵循了该原则。
依赖倒置原则（Dependency Inversion Principle，DIP）：Main类中使用了DrawingTool类创建Shape对象，而DrawingTool类只依赖于Shape接口，遵循了该原则。

exma4：(外观模式)

在这段代码中，BackupFacade 就是外观类，它包装了 ContactsManager、SmsManager、PhotoManager 和 MusicManager 这些子系统中的一组接口，并提供了一个 backup() 方法，这个方法将备份通讯录、短信、照片和歌曲的操作组合在一起，让客户端只需要调用一次 backup() 方法就能够完成所有的备份操作，同时隐藏了子系统的实现细节和复杂性。而客户端只需要和 Backup 接口交互，不需要关心子系统的具体实现，从而简化了客户端的代码。

上述代码用到了以下设计原则：

外观模式（Facade Pattern）：BackupFacade类是一个外观类，为客户端提供了简单的接口，使得客户端可以通过Backup接口的backup()方法来备份通讯录、短信、照片和歌曲。BackupFacade将客户端和备份过程分离开来，使得客户端不必关心备份的具体实现细节。
单一职责原则（Single Responsibility Principle）：ContactsManager、MusicManager、PhotoManager和SmsManager类都实现了Backup接口，这样它们各自负责了备份自己的数据，而且只有一个理由会引起它们的修改，即备份。
接口隔离原则（Interface Segregation Principle）：Backup接口中只有一个backup()方法，这保证了BackupFacade只提供了必要的方法，使得BackupFacade只依赖于Backup接口中的方法，而不是依赖于Backup接口中多余的方法。
依赖倒置原则：BackupFacade 依赖于抽象 Backup 接口，而不是具体的实现类，从而减少了系统的耦合性，使得系统更加灵活、可扩展和易于维护。
接口隔离原则：Backup 接口只包含 backup() 方法，而不包含其它与备份无关的方法，从而使得接口更加简单和易于使用。
开闭原则：当需要增加新的备份功能时，只需要增加一个新的备份管理类，并在 BackupFacade 中添加相应的方法即可，而不需要修改已有的代码。这样就实现了对修改关闭，对扩展开放的设计原则。

public interface Backup {
    public void backup();
}

public class ContactsManager implements Backup {
    public void backup(){
        System.out.println("备份通讯录");
    }
}

public class MusicManager implements Backup {
    public void backup(){
        System.out.println("备份歌曲");
    }
}

public class PhotoManager implements Backup {
    public void backup(){
        System.out.println("备份照片");
    }
}

public class SmsManager implements Backup {
    public void backup(){
        System.out.println("备份短信");
    }
}

public class BackupFacade implements Backup{
    private ContactsManager contactsManager;
    private SmsManager smsManager;
    private PhotoManager photoManager;
    private MusicManager musicManager;

    public BackupFacade() {
        contactsManager = new ContactsManager();
        smsManager = new SmsManager();
        photoManager = new PhotoManager();
        musicManager = new MusicManager();
    }


    public void backup() {
        contactsManager.backup();
        smsManager.backup();
        photoManager.backup();
        musicManager.backup();
    }
}

public class Client {
    public static void main(String[] args) {
        Backup backup = new BackupFacade();
        backup.backup();
    }
}

exma5(工厂方法模式)：

这段代码实现了工厂方法模式，其中：

ImageReaderFactory 是抽象工厂类，定义了创建工厂方法的接口。
GifReaderFactory 和 JpgReaderFactory 是具体工厂类，继承 ImageReaderFactory 实现了工厂方法，用于创建具体产品类的实例。
ImageReader 是抽象产品类，定义了产品的接口。
GifReader 和 JpgReader 是具体产品类，继承 ImageReader 实现了具体产品的接口。

客户端代码使用具体工厂类创建了具体产品对象并调用了其方法。

上述代码涉及到了以下设计原则：

开闭原则（Open/Closed Principle，OCP）：通过定义抽象工厂类和抽象产品接口，具体工厂类和具体产品类可以在不修改现有代码的情况下扩展系统，实现了对修改关闭，对扩展开放的原则。
单一职责原则（Single Responsibility Principle，SRP）：抽象产品接口 ImageReader 定义了读取图像和获取图像信息两个方法，保证了一个类只负责一个功能的设计原则。
工厂方法模式中的依赖倒置原则（Dependency Inversion Principle，DIP）：具体工厂类 GifReaderFactory 和 JpgReaderFactory 依赖于抽象工厂类 ImageReaderFactory，具体产品类 GifReader 和 JpgReader 依赖于抽象产品类 ImageReader。通过依赖倒置原则，将高层模块与低层模块解耦，提高了代码的灵活性和可扩展性。
接口隔离原则（Interface Segregation Principle，ISP）：抽象产品接口 ImageReader 只包含了读取图像和获取图像信息两个方法，避免了接口臃肿和不必要的方法的设计，符合接口隔离原则。
里氏替换原则（Liskov Substitution Principle，LSP）：抽象工厂类 ImageReaderFactory 和抽象产品类 ImageReader 可以被具体工厂类 GifReaderFactory、JpgReaderFactory 和具体产品类 GifReader、JpgReader 所替代，符合里氏替换原则。

public interface ImageReader {
    void readImage(String filePath);
    void getImageInfo();
}

public abstract class ImageReaderFactory {
    public abstract ImageReader createReader();
}

public class GifReader implements ImageReader {
    @Override
    public void readImage(String filePath) {
        System.out.println("读取GIF格式的图片：" + filePath);
    }

    @Override
    public void getImageInfo() {
        System.out.println("获取GIF图片信息");
    }
}


public class GifReaderFactory extends ImageReaderFactory {
    @Override
    public ImageReader createReader() {
        return new GifReader();
    }
}


public class JpgReader implements ImageReader {
    @Override
    public void readImage(String filePath) {
        System.out.println("读取JPG格式的图片：" + filePath);
    }

    @Override
    public void getImageInfo() {
        System.out.println("获取JPG图片信息");
    }
}

public class JpgReaderFactory extends ImageReaderFactory {
    @Override
    public ImageReader createReader() {
        return new JpgReader();
    }
}


public class Client {
    public static void main(String[] args) {
        ImageReaderFactory factory = new GifReaderFactory();
        ImageReader reader = factory.createReader();
        reader.readImage("test.gif");
        reader.getImageInfo();

        factory = new JpgReaderFactory();
        reader = factory.createReader();
        reader.readImage("test.jpg");
        reader.getImageInfo();
    }
}

exma6（代理模式）:

单一职责原则（SRP）：每个类或接口应该仅有一个引起它变化的原因。在这个代码中，HouseService 接口只有 rent() 和 display() 两个方法，它们分别处理租房和展示租房情况的功能。
开闭原则（OCP）：一个软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。在这个代码中，ProxyHouse 类扩展了 HostHouse 类，增加了记录日志和统计交易数的功能，但是并没有修改 HostHouse 类的实现。
依赖倒置原则（DIP）：高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。在这个代码中，ProxyHouse 类和 HostHouse 类都依赖于 HouseService 接口，而不是彼此之间的具体实现。
接口隔离原则（ISP）：客户端不应该依赖它不需要的接口。在这个代码中，HouseService 接口只有 rent() 和 display() 两个方法，而 ProxyHouse 和 HostHouse 类都只实现了需要的方法。
迪米特法则（LoD）：一个软件实体应当尽可能少地与其他实体发生相互作用。在这个代码中，Client 只和 ProxyHouse 类交互，而不是 HostHouse 类，降低了系统的耦合度。

下面的代码涉及到的设计模式是代理模式。其中，HostHouse是真实主题，ProxyHouse是代理主题，而Client则是客户端。在代理模式中，代理主题持有真实主题的引用，通过代理主题来访问真实主题，并在此过程中加入一些附加操作。在这个例子中，ProxyHouse代理主题在执行房屋租赁操作时加入了记录日志和统计交易次数的功能。

public interface HouseService {
    void rent();
    void display();
}

public class HostHouse implements HouseService {
    public void rent(){
        System.out.println("交押金");
        System.out.println("签合同");
        System.out.println("拿钥匙");
    }
    public void display(){

    }
}

public class ProxyHouse implements HouseService{
    HouseService service = new HostHouse();
    int count=0;
    public void rent(){
        System.out.println("记录日志 执行交易");
        service.rent();
        count++;
    }
    public void display(){
        System.out.println("已经办理的交易数："+count);
    }
}

public class Client {
    public static void main(String[] args) {
        HouseService service = new ProxyHouse();
        service.rent();
        service.rent();
        service.rent();
        service.display();
    }
}

exam7(简单的工厂模式):

以上代码是一个简单的工厂模式的示例，其包含以下几个部分：
1. 抽象产品类 Clothing，其中定义了产品的通用行为 display。
2. 具体产品类 OrdinaryClothing 和 SeniorClothing，实现了 Clothing 接口，并实现了各自的 display 方法，用于展示不同等级的服装价格。
3. 工厂类 ClothingFactorys，其中定义了一个 create 方法，用于根据传入的参数类型创建对应的产品对象。
4. 客户端类 Client，其中通过 Scanner 获取用户的选择，然后通过工厂类创建对应的产品对象并调用 display 方法展示价格。

这个代码涉及到的设计原则：

单一职责原则（SRP）：每个类都有一个明确的责任，并且该类应该只有一个原因来进行更改。
开放-封闭原则（OCP）：软件实体（类、模块、函数等）应该是可以扩展的，但是不可修改。
工厂模式：通过工厂方法隐藏对象的创建过程，将对象的创建和使用解耦，使得代码更加灵活、可扩展。
依赖倒置原则（DIP）：高层次的模块不应该依赖于低层次的模块，两者都应该依赖于抽象。在这里，客户端代码依赖于Clothing接口而不是具体的服装实现类。
接口隔离原则（ISP）：客户端代码只需要使用Clothing接口中定义的方法，而不需要知道实现类的其他方法。
里氏替换原则（LSP）：实现类可以替换其基类或接口，而不会破坏程序的正确性。
最少知识原则（LKP）：一个对象应该对其他对象有最少的了解。在这里，客户端只需要和ClothingFactory和Clothing接口交互，而不需要知道具体的实现类。

public interface Clothing {
    void display();
}

public class OrdinaryClothing implements Clothing {
    private String Level;
    private double TopsPrices;
    private double BottomPrices;
    private double SocksPrices;
    private double ShoesPrices;
    public void init(){
      this.TopsPrices=150;
      this.BottomPrices=120;
      this.Level="普通";
      this.SocksPrices=50;
      this.ShoesPrices=80;
    }
    public void display(){
        init();
        System.out.println(this.Level+"服装：\n"+" 上装的价格是："
                +this.TopsPrices+"元\n"+" 下装的价格是："
                +this.BottomPrices+"元\n"+" 袜子的价格是："
                +this.SocksPrices+"元\n"+" 鞋子的价格是："
                +this.ShoesPrices+"元");
    };
}

public class SeniorClothing implements Clothing{
    private String Level;
    private double TopsPrices;
    private double BottomPrices;
    private double SocksPrices;
    private double ShoesPrices;

    public void init(){
        this.TopsPrices=200;
        this.BottomPrices=150;
        this.Level="高级";
        this.SocksPrices=80;
        this.ShoesPrices=120;
    }
    public void display(){
        init();
        System.out.println(this.Level+"服装：\n"+" 上装的价格是："
                +this.TopsPrices+"元\n"+" 下装的价格是："
                +this.BottomPrices+"元\n"+" 袜子的价格是："
                +this.SocksPrices+"元\n"+" 鞋子的价格是："
                +this.ShoesPrices+"元");
    };
}

public class ClothingFactorys {
    public Clothing create(String ClothingType){
        if (ClothingType.equals("high")){
            return new SeniorClothing();
        }
        if (ClothingType.equals("ordinary")){
            return  new OrdinaryClothing();
        }
        return null;
    }
}

public class Client {
    public static void main(String[] args) {
        System.out.println("请选择服装等级");
        System.out.println("1.高级服装\n2.普通服装");
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        ClothingFactorys factorys = new ClothingFactorys();
        if (num==1){
         Clothing clothing= factorys.create("high");
         clothing.display();
        }
        if (num==2){
            Clothing clothing= factorys.create("ordinary");
            clothing.display();
        }
    }
}

exam8（享元模式）：

public interface IDCard {
    void setId(String id);
    String getId();
}

public class IDCardObj implements IDCard {
    private String id;

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

    public String getId() {
        return this.id;
    }
}

public class IDCardFactory {
    private Map<String, IDCard> idCardMap = new HashMap<>();

    public IDCard getIDCard(String id) {
        if (!idCardMap.containsKey(id)) {
            System.out.println("第一次办理身份证，分配新号码！");
            IDCard idCard = new IDCardObj();
            idCard.setId(id);
            idCardMap.put(id, idCard);
            System.out.println("身份证号码为："+id);
        }
        else {
            System.out.println("重复办理身份证，获取旧号码！"+id);
        }
        return idCardMap.get(id);
    }
}

public class Client
{
    public static void main(String a[])
    {
        IDCardFactory factory = new IDCardFactory();
        // 申请身份证号码
        IDCard idCard1 = factory.getIDCard("110101199001011234");
        IDCard idCard2 = factory.getIDCard("110101199001012345");
        // 重复申请相同的身份证号码
        IDCard idCard3 = factory.getIDCard("110101199001011234");
    }
}

exam9（普通工厂）：

这段代码实现了简单工厂模式。该模式可以在客户端不必知道对象创建的具体细节的情况下，通过工厂类创建所需的对象。

在这个例子中，RentFactory 是一个简单工厂类，用于创建 RentCalculate 接口的实例。Dormitory、SuperApartment 和 Apartment 类都实现了 RentCalculate 接口，其中 rent() 方法用于计算不同类型房屋的租金。

在 Client 类中，通过选择不同的房型和公寓类型，通过 RentFactory 创建相应的实例对象，并调用 rent() 方法计算租金。

通过使用简单工厂模式，可以将对象的创建和客户端代码分离，提高了代码的可维护性和可扩展性。如果需要添加新的房型，只需要在 RentFactory 类中添加新的逻辑即可。

工厂模式：RentFactory 类充当了工厂，根据传入的参数（HouseType）创建相应的实例，隐藏了对象创建的细节，让客户端可以更简单地使用对象。
接口隔离原则：RentCalculate 接口只包含计算租金的方法，避免了接口臃肿，保证了接口的单一职责。
单一职责原则：每个类只负责自己的职责，例如 Dormitory 只负责计算宿舍的租金，而不需要关心公寓和超级公寓的计算租金方式。
开闭原则：在增加新的房型时，只需要添加相应的类和实现 RentCalculate 接口，而不需要修改原有代码，符合开闭原则的要求。
迪米特法则：客户端只与 RentCalculate 接口和 RentFactory 类进行交互，避免了与具体房型类的耦合，降低了代码的复杂性。

public interface RentCalculate {
    int rent();
}
public class Dormitory implements RentCalculate{
    private final int numToilets = 1; // 卫生间数量
    private final int numShowers = 1; // 沐浴间数量
    private final int numKitchens = 0; // 厨房数量
    public int rent() {
        return numToilets * 100 + numShowers * 100;
    }
}
public class SuperApartment implements RentCalculate{
    private final int numToilets = 2; // 卫生间数量
    private final int numShowers = 2; // 沐浴间数量
    private final int numKitchens = 1; // 厨房数量
    public int rent() {
        return numToilets * 100 + numShowers * 100+numKitchens*100;
    }
}
public class Apartment implements RentCalculate{
    private final int numToilets = 2; // 卫生间数量
    private final int numShowers = 2; // 沐浴间数量
    public int rent() {
        return numToilets * 100 + numShowers * 100;
    }
}
public class RentFactory {
    public RentCalculate create(String HouseType){
        if (HouseType.equals("Apartment")){
            return new Apartment();
        }
        if (HouseType.equals("Dormitory")){
            return new Dormitory();
        }
        if (HouseType.equals("SuperApartment")){
            return new SuperApartment();
        }
        return null;
    }
}
public class Client {
    public static void main(String[] args) {
        System.out.println("请选择房型");
        System.out.println("1.宿舍\n2.公寓");
        Scanner in = new Scanner(System.in);
        int op = in.nextInt();
        int rentMoney=0;
        RentFactory factory = new RentFactory();
        if (op==1){
            RentCalculate rentCalculate = factory.create("Dormitory");
            rentMoney=rentCalculate.rent();
        }
        if (op==2){
            System.out.println("请选择公寓类型");
            System.out.println("1.普通公寓\n2.带厨房的公寓");
            int opt = in.nextInt();
            if (opt==1){
                RentCalculate rentCalculate = factory.create("Apartment");
                rentMoney=rentCalculate.rent();
            }if (opt==2){
                RentCalculate rentCalculate = factory.create("SuperApartment");
                rentMoney=rentCalculate.rent();
            }
        }
        System.out.println("您的租金为 "+rentMoney+"元");
    }
}

exam10(策略+组合)

针对这个游戏软件的需求，可以采用策略模式和组合模式的混合使用来实现灵活性和可扩展性。

组合模式体现在GameComposite类中。GameComposite类采用了组合模式来组织和管理游戏难度等级对象。具体来说，GameComposite类中包含了一个Map类型的levels属性，其中String类型的LevelName作为键，DifficultyLevel类型的level作为值，用于存储不同的游戏难度等级对象。同时，GameComposite类还包含了add()、remove()和Getplay()三个方法，这些方法实现了对游戏难度等级对象的添加、删除和获取操作。在add()方法中，将LevelName和level添加到levels中；在remove()方法中，将LevelName对应的level从levels中删除；在Getplay()方法中，通过LevelName获取对应的level对象，并调用其play()方法来启动游戏。通过组合模式，GameComposite类可以灵活地组合和管理不同的游戏难度等级对象，而不需要修改客户端代码。

策略模式用于实现不同难度下怪兽和士兵的行为动作，游戏中玩家可以自由的选择不同的难度进行游戏，系统会根据玩家选择的难度匹配相应的策略类。

单一职责原则（Single Responsibility Principle，SRP）：每个类都应该有一个单一的责任，并且该责任应该完全封装在该类中。在代码中，每个类都有自己的职责，如 DifficultyLevel 接口定义游戏难度等级的方法，EasyLevel、MediumLevel 和 HardLevel 分别实现了游戏难度等级的具体方法，GameComposite 实现了难度等级的管理，GameController 则负责控制游戏的初始化和开始等。
开闭原则（Open-Closed Principle，OCP）：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。在代码中，GameComposite 类的 add 和 remove 方法可以方便地添加或删除游戏难度等级，而不需要修改 GameController 类的代码。
接口隔离原则（Interface Segregation Principle，ISP）：客户端不应该强制依赖它们不使用的方法。在代码中，DifficultyLevel 接口只包含了游戏难度等级的方法，而没有包含其他无关的方法。
依赖倒置原则（Dependency Inversion Principle，DIP）：高层模块不应该依赖低层模块，它们都应该依赖于抽象。在代码中，GameController 类依赖于 GameComposite 类，而 GameComposite 类又依赖于 DifficultyLevel 接口，这样可以实现高层模块不依赖于低层模块，而是依赖于抽象接口的目的。
迪米特法则（Law of Demeter，LoD）：一个对象应该对其他对象有最少的了解。在代码中，GameController 类只与 GameComposite 类交互，而不需要知道 DifficultyLevel 接口和具体实现类的细节。

public interface DifficultyLevel {
    void play();
}
public class EasyLevel implements DifficultyLevel{
    public void play(){
        System.out.println("敌方士兵反应迟钝、怪兽步履缓慢");
    }
}
public class MediumLevel implements DifficultyLevel{
    public void play(){
        System.out.println("敌方士兵反应适度、怪兽步履速度中等");
    }
}
public class HardLevel implements DifficultyLevel {
    public void play(){
        System.out.println("敌方士兵反映敏捷、怪兽狰狞狡诈");
    }
}
public class GameComposite {
    private Map<String,DifficultyLevel> levels = new HashMap<>();

    public void add(String LevelName,DifficultyLevel level) {
        levels.put(LevelName,level);
    }
    public void remove(String LevelName){
        levels.remove(LevelName);
    }
    public void Getplay(String LevelName) {
       levels.get(LevelName).play();
//        System.out.println(levels.get(LevelName));
    }
}
public class GameController {
    private GameComposite gameComposite = new GameComposite();
    private DifficultyLevel easyLevel = new EasyLevel();
    private DifficultyLevel mediumLevel = new MediumLevel();
    private DifficultyLevel hardLevel = new HardLevel();
    public void init(){
        gameComposite.add("EasyLevel",easyLevel);
        gameComposite.add("MediumLevel",mediumLevel);
        gameComposite.add("HardLevel",hardLevel);
    }
    public void start(){
        System.out.println("Welcome!\n请选择游戏难度:");
        System.out.println("1.EasyLevel\n2.MediumLevel\n3.HardLevel");
        System.out.println("请输入选择的难度");
    }
    public void play(String LevelName){
//        System.out.println(gameComposite.Getplay(LevelName));
     try {
         gameComposite.Getplay(LevelName);
     }catch (Exception e){
         System.out.println("请输入正确的游戏难度！！");
     }
    }
}
public class Client {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        GameController gameController = new GameController();
        gameController.init();
        gameController.start();
        String levels=in.next();
        gameController.play(levels);
        }
    }

exam1:

public interface doArchery {
    void Archery();
}
public interface doDisplacement {
    void Displacement();
}
public interface doInvisible {
    void Invisible();
}
public interface doSilence {
    void Silenced();
}
public interface doVertigo {
    void Vertigo();
}
public interface hero_HY extends doDisplacement, doArchery, doSilence, doVertigo, doInvisible {

}
public interface hero_XY extends doDisplacement,doArchery,doInvisible,doSilence,doVertigo {

}
public class HY implements hero_HY {
    public void Archery() {
        System.out.println("HY-Archery");
    }
    public void Displacement() {
        System.out.println("HY-Displacement");
    }
    public void Invisible() {
        System.out.println("HY-Invisible");
    }
    public void Silenced() {
        System.out.println("HY-Silenced");
    }
    public void Vertigo() {
        System.out.println("HY-Vertigo");
    }
}
public class XY implements hero_XY {
    public void Archery() {
        System.out.println("XY-Archery");
    }
    public void Displacement() {
        System.out.println("XY-Displacement");
    }
    public void Invisible() {
        System.out.println("XY-Invisible");
    }
    public void Silenced() {
        System.out.println("XY-Silenced");
    }
    public void Vertigo() {
        System.out.println("XY-Vertigo");
    }
}