Java 如何与超类中的实例变量共享方法？

我有一个抽象类叫做Car。然后我有两个子类，福特和道奇，它们都扩展了汽车。每个子类都有一个名为move（）的方法。这个方法中的代码对于Ford和Dodge是相同的，所以我的本能是将这个方法实现放到Car超类中，这样我就不必在两个子类中都有两次相同的代码，即得到重复的代码，只需在超类中的代码中编写一次这个方法，每个子类都可以在需要时调用它

现在是我的…事情：在每个子类的move方法中，每个子类的实例变量都在被操作。因此，您可以看到，尽管代码是相同的，但每个move（）-方法中发生的情况取决于该特定子类的实例变量的状态。像这样：

abstract class Car {

  // I want to put move()-method in here and erase it from subclasses
}


class Ford extends Car {

    private int rpm;

    public void move(){

    dosomestuff + rpm // value of rpm being used here is unique to Ford

     }
}

 class Dodge extends Car {

    private int rpm;

    public void move(){

    dosomestuff + rpm // value of rpm being used here is unique to Dodge

     }
}

我想让它像这样，并使用子类实例变量从每个子类调用超类中的move（）：

abstract class Car {

  move(){
    // do stuff that is identical to Ford and Dodge but
    //  dependent on different instance variables
    }
}


class Ford extends Car {

    private int rpm;
}

 class Dodge extends Car {

    private int rpm;

}

我应该在超类车内创建变量吗？但这正是我在思考问题时遇到的问题，因为我知道抽象类无法实例化！因此，如果我在本例中将rpm变量作为move（）方法（如move（rpm））中的参数传递，而move（）的实现仅在Car类中，那么我必须返回rpm变量以获取其操纵值。这是可行的，例如一次实例变量形成一个子类。问题是，移动方法依赖于几种不同类型的变量。因此，每次我都必须返回几个变量给子类，但我不知道该怎么做

---

我很困惑。如何将子类中的“重复代码”压缩到超类Car中，并且仍然能够操作从Car类继承的不同子类中的实例变量？我是否将它们作为参数传递并返回它们？我是否使用get set方法执行某些操作？我很不确定…

使用

受保护的
变量

abstract class Car {
  protected int rpm;
  move(){

    // ACCESS RPM HERE, which would be specific to implementing class
    }
}


class Ford extends Car {
}

 class Dodge extends Car {
}

由于变量
rpm
现在受到保护，因此
Car
的子类可以访问该变量，并且当您实例化
Ford
或
Dodge
时，它将具有自己的
rpm
值

有意义吗？
使用
受保护的
变量

abstract class Car {
  protected int rpm;
  move(){

    // ACCESS RPM HERE, which would be specific to implementing class
    }
}


class Ford extends Car {
}

 class Dodge extends Car {
}

由于变量
rpm
现在受到保护，因此
Car
的子类可以访问该变量，并且当您实例化
Ford
或
Dodge
时，它将具有自己的
rpm
值

有意义吗？
我不知道这是否回答了您的问题，但是子类继承了超类的方法，所以我会将所有内容都放在抽象类中，并使用getter setter（或access mutate）方法来使用抽象类中的所有变量。我注意到有人声明了受保护的变量，这些变量有时会起作用，但如果您需要在包中进行封装，则不会起作用。我会这样做：

public abstract class Car{
private int rpm;
public int getRPM(){return rpm;}
public void move(){//do move using getRPM() to access the data}

}
class Ford extends Car {
}

class Dodge extends Car {
}

因此，Ford和Doge之间唯一不同的是构造函数，当你进行子类化时，它通常是非常好的
我不知道这是否回答了你的问题，但是子类继承了超类的方法，所以我会将所有内容放在抽象类中，并使用getter setter（或access mutate）方法使用抽象类中的所有变量。我注意到有人声明了受保护的变量，这些变量有时会起作用，但如果您需要在包中进行封装，则不会起作用。我会这样做：

public abstract class Car{
private int rpm;
public int getRPM(){return rpm;}
public void move(){//do move using getRPM() to access the data}

}
class Ford extends Car {
}

class Dodge extends Car {
}

因此，Ford和Doge之间唯一不同的是构造函数，当您像其他人所写的那样子类化时，它通常是好的，您可以将实例变量拉入基类；并使它们要么得到保护；或者为他们提供激励；但老实说，我认为这很可能会导致一个不良的设计

问题是：应该使用继承为其子类提供行为，而不是变量

意思是：你仔细考虑你想“分享”什么样的行为；然后你考虑如何以正确的方式实施它，比如：

abstract class Base {

  public final void doTheCommonThing() {
    System.out.println("but we need subclass stuff: " + getFromSubclass());
  }

  protected abstract String getFromSubclass();
}

数据封装的全部要点是，您的基类不应该知道子类中的变量；反之亦然。因为这些都是实现细节，其他人都不知道。
正如其他人所写，您可以将实例变量拉入基类；并使它们要么得到保护；或者为他们提供激励；但老实说，我认为这很可能会导致一个不良的设计

问题是：应该使用继承为其子类提供行为，而不是变量

意思是：你仔细考虑你想“分享”什么样的行为；然后你考虑如何以正确的方式实施它，比如：

abstract class Base {

  public final void doTheCommonThing() {
    System.out.println("but we need subclass stuff: " + getFromSubclass());
  }

  protected abstract String getFromSubclass();
}

数据封装的全部要点是，您的基类不应该知道子类中的变量；反之亦然。因为这些都是实现细节，没有人知道。
首先，不要通过在继承链中多次声明
rpm
变量来隐藏它。只需在
Car
中声明它，并使用getter和setter以及构造函数来设置变量。你的
move
方法可以简单地使用getter方法来获取值。我不确定我是否正确理解了你的问题，但根据我的理解，我想到了两种方法：a）给你的超级类
Car
属性
rpm
，以及
move（）
的实现。如果这不可能（可能您有一些
汽车
以不同的方式移动），您可以拥有
汽车
的子类，这也是
福特
的常见超级类