如何通过使用超类来减少代码？

时间：2018-09-26 08:45:29

标签： java inheritance subclass superclass

我想重构一些当前由超类和两个子类组成的代码。

这些是我的课程：

public class Animal {
    int a;
    int b;
    int c;
}

public class Dog extends Animal {
    int d;
    int e;
}

public class Cat extends Animal {
    int f; 
    int g;
}

这是我当前的代码：

ArrayList<Animal> listAnimal = new ArrayList<>();

if (condition) {
    Dog dog = new Dog();
    dog.setA(..);
    dog.setB(..);
    dog.setC(..);
    dog.setD(..);
    dog.setE(..);   
    listAnimal.add(dog);

} else {
    Cat cat = new Cat();
    cat.setA(..);
    cat.setB(..);
    cat.setC(..);
    cat.setF(..);
    cat.setG(..);
    listAnimal.add(cat);
}

如何重构有关通用属性的代码？

我想要这样的东西：

Animal animal = new Animal();
animal.setA(..);
animal.setB(..);
animal.setC(..);

if (condition) {
    Dog anim = (Dog) animal; //I know it doesn't work
    anim.setD(..);
    anim.setE(..);  
} else {
    Cat anim = (Cat) animal; //I know it doesn't work
    anim.setF(..);
    anim.setG(..);
}

listAnimal.add(anim);

10 个答案:

答案 0 :(得分：37)

您的想法是使用类型为Animal的变量是好的。但是您还必须确保使用正确的构造函数：

Animal animal; // define a variable for whatever animal we will create

if (condition) {
    Dog dog = new Dog(); // create a new Dog using the Dog constructor
    dog.setD(..);
    dog.setE(..);  
    animal = dog; // let both variables, animal and dog point to the new dog
} else {
    Cat cat = new Cat(); 
    cat.setF(..);
    cat.setG(..);
    animal = cat;
}

animal.setA(..); // modify either cat or dog using the animal methods
animal.setB(..);
animal.setC(..);

listAnimal.add(animal);

提示：如果动物总是猫或狗，请考虑制作动物abstract。然后，每当您尝试进行new Animal()时，编译器都会自动进行投诉。

答案 1 :(得分：15)

构造猫或狗的过程很复杂，因为涉及很多领域。对于the builder pattern，这是一个很好的情况。

我的想法是为每种类型编写一个构建器并组织它们之间的关系。可能是合成或继承。

  • AnimalBuilder构造一个常规的Animal对象并管理a，b，c字段
  • CatBuilder接受AnimalBuilder（或对其进行扩展），并继续构建管理Cat，f字段的g对象
  • DogBuilder接受AnimalBuilder（或扩展它）并继续构建管理Dog，d字段的e对象

如果您不想创建构建器，请考虑为每个子类引入一个带有有意义名称的静态工厂方法：

Animal animal = condition ? Dog.withDE(4, 5) : Cat.withFG(6, 7);
// populate animal's a, b, c
listAnimal.add(animal);

这将简化构造并使其更简洁，更易读。

答案 2 :(得分：11)

答案

一种实现方法是将适当的构造函数添加到您的类中。看下面：

public class Animal {
   int a, b, c; 

   public Animal(int a, int b, int c) {
      this.a = a;
      this.b = b;
      this.c = c;
   } 
}

public class Dog extends Animal {
   int d, e; 

   public Dog(int a, int b, int c, int d, int e) {
      super(a, b, c);
      this.d = d;
      this.e = e;
   } 
} 

public class Cat extends Animal {
   int f, g; 

   public Cat(int a, int b, int c, int f, int g) {
      super(a, b, c);
      this.f = f;
      this.g = g;
   } 
}

现在，要实例化对象，可以执行以下操作：

ArrayList<Animal> listAnimal = new ArrayList();

//sample values
int a = 10;
int b = 5;
int c = 20;

if(condition) {
   listAnimal.add(new Dog(a, b, c, 9, 11));
   //created and added a dog with e = 9 and f = 11
} 
else {
   listAnimal.add(new Cat(a, b, c, 2, 6));
   //created and added a cat with f = 2 and g = 6
}

这是我在这种情况下使用的方法。通过避免大量的“设置”方法，它可以使代码更整洁并更具可读性。请注意，super()是对超类的（在本例中为Animal）构造函数的调用。



奖金

如果您不打算创建类Animal的实例，则应将其声明为abstract。 抽象类无法实例化，但是可以被子类化，并且可以包含抽象方法。声明这些方法时不使用主体，这意味着所有子类都必须提供其自己的实现。这是一个示例：

public abstract class Animal {
   //...  

   //all animals must eat, but each animal has its own eating behaviour
   public abstract void eat();
} 

public class Dog {
   //... 

   @Override
   public void eat() {
     //describe the eating behaviour for dogs
   } 
}

现在您可以为每种动物叫eat()！在前面的示例中，通过动物列表，您可以像下面这样进行操作：

for(Animal animal: listAnimal) {
   animal.eat();
}

答案 3 :(得分：4)

请考虑使您的类不可变（Effective Java 3rd Edition Item 17）。如果需要所有参数，请使用构造函数或静态工厂方法（Effective Java 3rd Edition Item 1）。如果有必需参数和可选参数，请使用构建器模式（Effective Java 3rd Edition Item 2）。

答案 4 :(得分：4)

我会考虑动态查找/注册功能/功能：飞行/游泳。

问题在于这是否适合您的用法：代替“飞翔和游泳”，而要使用“鸟和鱼”。

这取决于添加的属性是排他性（狗/猫）还是添加性（飞行/游泳/哺乳动物/昆虫/蛋壳/ ...）。后者更多是用于使用地图进行查找。

interface Fish { boolean inSaltyWater(); }
interface Bird { int wingSpan(); setWingSpan(int span); }

Animal animal = ...

Optional<Fish> fish = animal.as(Fish.class);
fish.ifPresent(f -> System.out.println(f.inSaltyWater()? "seafish" : "riverfish"));

Optional<Bird> bird = animal.as(Bird.class);
bird.ifPresent(b-> b.setWingSpan(6));

Animal不需要实现任何接口，但是您可以查找（查找或也许查找）功能。这是将来可扩展的，动态的：可以在运行时更改。

实施为

private Map<Class<?>, ?> map = new HashMap<>();

public <T> Optional<T> as(Class<T> type) {
     return Optional.ofNullable(type.cast(map.get(type)));
}

<S> void register(Class<S> type, S instance) {
    map.put(type, instance);
}

该实现进行安全的动态转换，因为寄存器可确保安全填充（键，值）条目。

Animal flipper = new Animal();
flipper.register(new Fish() {
    @Override
    public boolean inSaltyWater() { return true; }
});

答案 5 :(得分：4)

作为替代，您可以将猫和狗的“动物”部分设置为单独的实体，该实体可通过“动物”界面使用。这样，您首先要创建公共状态，然后在需要时将其提供给特定物种的构造函数。

public class Animal {
    int a;
    int b;
    int c;
}

public interface Animalian {
    Animal getAnimal();
}

public class Dog implements Animalian {
    int d;
    int e;
    Animal animal;
    public Dog(Animal animal, int d, int e) {
        this.animal = animal;
        this.d = d;
        this.e = e;
    }
    public Animal getAnimal() {return animal};
}

public class Cat implements Animalian {
    int f;
    int g;
    Animal animal;
    public Cat(Animal animal, int f, int g) {
        this.animal = animal;
        this.f = f;
        this.g = g;
    }
    public Animal getAnimal() {return animal};
}

现在创建动物：

Animal animal = new Animal();
animal.setA(..);
animal.setB(..);
animal.setC(..);

if (condition) {
    listAnimalian.add(new Dog(animal, d, e));
} else {
    listAnimalian.add(new Cat(animal, f, g));
}

执行此操作的原因是“ favor composition over inheritance”。我要表达的是，这只是解决所提出问题的另一种方式。这并不意味着在任何时候都应优先考虑组合而不是继承。工程师应根据出现问题的环境确定正确的解决方案。

reading on this topic中有很多。

答案 6 :(得分：4)

这是一个解决方案，与slartidan的解决方案非常接近，但是使用setter和构建者的风格，避免使用dog和cat变量

public class Dog extends Animal
{
    // stuff

    Dog setD(...)
    {
        //...
        return this;
    }

    Dog setE(...)
    {
        //...
        return this;
    }
}

public class Cat extends Animal
{
    // stuff

    Cat setF(...)
    {
        //...
        return this;
    }

    Cat setG(...)
    {
        //...
        return this;
    }
}

Animal animal = condition ?
    new Dog().setD(..).setE(..) :
    new Cat().setF(..).setG(..);

animal.setA(..);
animal.setB(..);
animal.setC(..);

listAnimal.add(animal);

答案 7 :(得分：4)

这是我想提出的建议：

let portal = new ComponentPortal(componentFactory.componentType);

let component = overlayRef.attach<SomeComponent>(portal);

component.instance.someEventEmitter.subscribe(() => {
  //Some code
});

一些值得注意的点：

  1. 在声明import java.util.ArrayList; import java.util.List; class Animal { int a; int b; int c; public Animal setA(int a) { this.a = a; return this; } public Animal setB(int b) { this.b = b; return this; } public Animal setC(int c) { this.c = c; return this; } } class Dog extends Animal { int d; int e; public Dog setD(int d) { this.d = d; return this; } public Dog setE(int e) { this.e = e; return this; } } class Cat extends Animal { int f; int g; public Cat setF(int f) { this.f = f; return this; } public Cat setG(int g) { this.g = g; return this; } } class Scratch { public static void main(String[] args) { List<Animal> listAnimal = new ArrayList(); boolean condition = true; Animal animal; if (condition) { animal = new Dog() .setD(4) .setE(5); } else { animal = new Cat() .setF(14) .setG(15); } animal.setA(1) .setB(2) .setC(3); listAnimal.add(animal); System.out.println(listAnimal); } } 中使用List接口
  2. 在创建对象List<Animal> listAnimal时使用界面动物
  3. Animal animal;类Animal
  4. 设置者返回abstract，以使代码更整洁。否则，您将不得不使用类似this animal.setD(4);
    5. 的代码

这样，我们可以利用动物界面，并一次设置公共属性。希望这会有所帮助。

答案 8 :(得分：1)

将代码重构为： 

ArrayList<Animal> listAnimal = new ArrayList();

//Other code...

if (animalIsDog) {
    addDogTo(listAnimal, commonAttribute, dogSpecificAttribute); 
} else {
    addCatTo(listAnimal, commonAttribute, catSpecificAttribute);
}

具有新代码的优点：

  1. 隐藏的复杂性：您已经隐藏了复杂性，现在在稍后重新访问代码时，必须使用较小的代码（几乎用纯英语编写）。

但是现在，必须编写方法addDogTo和addCatTo。这是他们的样子：

private void addDogTo(ArrayList<Animal> listAnimal,
    AnimalAttribute generalAttribute,
    DogAttribute specificAttribute) {
    var dog = createDog(commonAttribute, specificAttribute);
    listAnimal.add(dog);
}

private void addCatTo(ArrayList<Animal> listAnimal,
    AnimalAttribute generalAttribute,
    CatAttribute specificAttribute) {
    var cat = createCat(commonAttribute, specificAttribute);
    listAnimal.add(cat);
}

好处：

  1. 隐藏的复杂性；
  2. 这两种方法都是私有的：这意味着只能在类中调用它们。因此，您可以放心地检查输入是否为null等，因为调用者（在类之内）必须注意不要将虚假数据传递给它自己的成员。

这意味着现在我们需要使用createDog和createCat方法。这就是我编写这些方法的方式：

private Dog createDog(AnimalAttribute generalAttribute,
    DogAttribute specificAttribute) {
    var dog = new Dog(generalAttribute, specificAttribute);
    return dog;
}

private Cat createCat(AnimalAttribute generalAttribute,
    CatAttribute specificAttribute) {
    var cat = new Cat(generalAttribute, specificAttribute);
    return cat;
}

好处：

  1. 隐藏的复杂性；
  2. 这两种方法都是私有的。

现在，对于上面编写的代码，您将不得不为Cat和Dog编写构造函数，这些构造函数具有用于对象构造的公共属性和特定属性。看起来像这样：

public Dog(AnimalAttribute generalAttribute,
    DogAttribute specificAttribute)
        : base (generalAttribute) {
    this.d = specificAttribute.getD();
    this.e = specificAttribute.getE();
}

和

public Cat(AnimalAttribute generalAttribute,
    CatAttribute specificAttribute)
        : base (generalAttribute) {
    this.f = specificAttribute.getF();
    this.g = specificAttribute.getG();
}

好处：

  1. 代码为DRY：这两个构造函数都使用generalAttributes调用超类方法，并且该方法处理了两个子类对象的公共属性；
  2. 整个对象都将保留：无需调用构造函数并向其传递2万个参数，只需传递2，即。一般动物属性对象和特定动物属性对象。这两个参数将其余的属性保存在其中，并在需要时在构造函数中取消装箱。

最后，您的Animal的构造函数将如下所示：

public Animal(AnimalAttribute attribute) {
    this.a = attribute.getA();
    this.b = attribute.getB();
    this.c = attribute.getC();
}

好处：

  1. 整个对象被保留;

为了完整起见：

  • AnimalAttribute / DogAttribute / CatAttribute类仅包含一些字段，以及这些字段的getter和setter；
  • 这些字段是构造Animal / Dog / Cat对象所需的数据。

答案 9 :(得分：0)

这里有很多很棒的建议。我将使用我个人最喜欢的构建器模式（但具有附加的继承风格）：

public class Animal {

    int a;
    int b;
    int c;

    public Animal() {
    }

    private <T> Animal(Builder<T> builder) {
        this.a = builder.a;
        this.b = builder.b;
        this.c = builder.c;
    }

    public static class Builder<T> {
        Class<T> builderClass;
        int a;
        int b;
        int c;

        public Builder(Class<T> builderClass) {
            this.builderClass = builderClass;
        }

        public T a(int a) {
            this.a = a;
            return builderClass.cast(this);
        }

        public T b(int b) {
            this.b = b;
            return builderClass.cast(this);
        }

        public T c(int c) {
            this.c = c;
            return builderClass.cast(this);
        }

        public Animal build() {
            return new Animal(this);
        }
    }
    // getters and setters goes here 

}

public class Dog extends Animal {

    int d;
    int e;

    private Dog(DogBuilder builder) {
        this.d = builder.d;
        this.e = builder.e;
    }

    public static class DogBuilder extends Builder<DogBuilder> {
        int d;
        int e;

        public DogBuilder() {
            super(DogBuilder.class);
        }

        public DogBuilder d(int d) {
            this.d = d;
            return this;
        }

        public DogBuilder e(int e) {
            this.e = e;
            return this;
        }

        public Dog build() {
            return new Dog(this);
        }
    }
    // getters and setters goes here 
}

public class Cat extends Animal {

    int f;
    int g;

    private Cat(CatBuilder builder) {
        this.f = builder.f;
        this.g = builder.g;
    }

    public static class CatBuilder extends Builder<CatBuilder> {
        int f;
        int g;

        public CatBuilder() {
            super(CatBuilder.class);
        }

        public CatBuilder f(int f) {
            this.f = f;
            return this;
        }

        public CatBuilder g(int g) {
            this.g = g;
            return this;
        }

        public Cat build() {
            return new Cat(this);
        }
    }
    // getters and setters goes here 
}

public class TestDrive {

    public static void main(String[] args) {

        Boolean condition = true;
        ArrayList<Animal> listAnimal = new ArrayList<>();

        if (condition) {
            Dog dogA = new Dog.DogBuilder().a(1).b(2).c(3).d(4).e(5).build();
            Dog dogB = new Dog.DogBuilder().d(4).build();
            listAnimal.add(dogA);
            listAnimal.add(dogB);

        } else {
            Cat catA = new Cat.CatBuilder().b(2).f(6).g(7).build();
            Cat catB = new Cat.CatBuilder().g(7).build();
            listAnimal.add(catA);
            listAnimal.add(catB);
        }
        Dog doggo = (Dog) listAnimal.get(0);
        System.out.println(doggo.d); 
    }
}

注意：Animal.Builder构造函数采用Class builderClass作为通用参数。返回时，将对象的当前实例转换为此类。

相关问题
最新问题