Question

我是java新手并且很难理解抽象类和方法的继承：以下是我试图设置的内容，以便更好地掌握抽象类。我有一个抽象类公民，应该有助于改变公民的重量：

    public abstract class Citizen{

        public double weight;
        /**
         * Constructor of the abstract class
         */
        public Citizen(double weight) {
            this.weight = weight;
        }

        public abstract double doubleValue();
    }

我有一些人伸出公民 - 约翰：

    public class American extends Citizen{

        public American(int weight) {
            super(weight);
        }
        @Override
        public double doubleValue() {
            return weight;
        }

    }

彼得：

    public class European extends Citizen {

      public European(int weight) {
          super(weight);
      }
      @Override
      public double doubleValue() {
          return weight;
      }

    }

弗朗索瓦：

    public class European extends Citizen {

      public European(int weight) {
          super(weight);
      }
      @Override
      public double doubleValue() {
          return weight;
      }

    }

在这里，我试着把它们放在一起：

    import java.util.*;

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

            European.setWeight(2,20462); # should convert Françoise to pound
            European.setWeight(2,20462); # should convert Peter to pound

            List<Citizen> weightiness = new ArrayList<Citizen>();
            weightiness.add(new European(100)); # Converted to pound
            weightiness.add(new European(95)); # Converted to pound
            weightiness.add(new American(220));

            for (int i = 0; i < weightiness.size(); i++){
                System.out.println(weightiness.get(i).doubleValue());
            }

        }
    }

由于欧洲人来自欧洲，因此以千克为单位测量，美国人以磅为单位。我想用磅计算所有这些的整体重量，因此必须通过设定它们的重量来转换欧洲：

哪个应该只返回相应欧洲的2,20462 * kg的产品。

因为只有欧洲人需要转换成英镑，所以我很难理解在哪里放置方法（在公民或欧洲）setWeight以及如何。

我试图把setWeight放在欧洲，比如：

    public class European extends Citizen {

      public double weightconversion;

      public European(int weight) {
          super(weight);
      }
      @Override
      public double doubleValue() {
          return weight;
      }

      public void setWeight(double weightconversion)
      {
          this.weightconversion=weightconversion;
      }
      public double getWeight() {
          return weightconversion * weight;
      }

    }

但使用European.setWeight(2,20462);

似乎不正确

欣赏任何见解！

Answer 1

让我们从扩展Citizen的类开始。如果您正在与欧洲和美国公民合作，那么您应该创建这样的课程：

public class European extends Citizen { //code}
public class American extends Citizen { //code}

然后，您只需实例化这些类：

Citizen peter = new European(weight1);
Citizen francoise = new European(weight2);
Citizen john = new American(weight3);

然后，关于你的setWeight方法。它应该在Citizen类中声明为抽象方法。

公民类：

public abstract void setWeight(int w);

然后，您只需在American和European类中实现该方法。如果只有那个方法应该是欧洲类，那么你可以在欧洲类中定义它，但是你应该像这样实例化对象（为了不让编译错误）：

European peter = new European(weight1);
European francoise = new European(weight2);

考虑一下你想要的只是一种转换方法。它也可以在util类中使用，并且不会使用不适合的方法弄乱欧洲类。

此外，您可以在欧洲类的变量中指定2.20462值。在这种情况下，您不需要任何其他方法。当你创建一个欧洲人时，你可以在构造函数中创建这个分配。

Answer 2

你可以创建：

public abstract class KgCitizen extends Citizen {
    public KgCitizen(double weight) {
        super(weight*2.2);
    }
}

然后让你的欧洲人扩展那个班级。（我希望我的数学是正确的。）

顺便说一下，如果你这样做，似乎Citizen应该实现doubleValue（），因为你的所有子类都有相同的实现。你可以让Citizen成为抽象的，即使它没有抽象的方法，以避免任何人直接实例化Citizen。

如果您希望对象中存储的权重是本地区域的度量单位，而不是所有磅数，但希望doubleValue（）仅提供磅数，那么您可以实现doubleValue（）在KgCitizen中进行转换。

Answer 3

查看以下结构，您将能够理解

public abstract class Citizen {

  public double weight;

  /**
   * Constructor of the abstract class
  */
  public Citizen(double weight) {
    this.weight = weight;
  }

  public abstract double convertWeight();

  public double doubleValue() {
    return convertWeight();
  } 
}

欧洲

// Provide conversion logic for european in this class
public class European extends Citizen {

   public European(double weight) {
      super(weight);
   }

   @Override
   public double convertWeight() {
      return this.weight * 2;
   }

}

美国

// Provide conversion logic for american in this class
public class American extends Citizen {

  public American(double weight) {
      super(weight);
  }

  @Override
  public double convertWeight() {
      return this.weight;
  }

}

约翰

public class John extends American {
  public John(int weight) {
    super(weight);
  } 
}

彼得

public class Peter extends European {
  public Peter(int weight) {
    super(weight);
  }
}

弗朗索瓦丝

public class Francoise extends European {
  public Francoise(int weight) {
      super(weight);
  }
}

主要

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

public class Main {

  public static void main(String arp[]) {

      List<Citizen> weightiness = new ArrayList<Citizen>();
      weightiness.add(new John(90));
      weightiness.add(new Peter(90));
      weightiness.add(new Francoise(90));

      for (int i = 0; i < weightiness.size(); i++) {
          System.out.println(weightiness.get(i).doubleValue());
      }
   }
}

如何在抽象类中实现多个方法？欧洲的

3 个答案: