为什么在Java中的抽象类中存在私有访问修饰符，即使我们无法创建抽象类的实例？ [英] Why is there a private access modifier in an abstract class in Java, even though we cannot create an instance of an abstract class?

问题描述

我知道在 abstract 类中将方法声明为 private 并不是一个好的编码习惯。即使我们无法创建 abstract 类的实例，为什么<$ c c中的 private 访问修饰符可用$ c> abstract 类，它在 abstract 类中的范围是什么？在哪种情况下，抽象类中使用的私有访问说明符？

I know it is not a good coding practice to declare a method as private in an abstract class. Even though we cannot create an instance of an abstract class, why is the private access modifier available within an abstract class, and what is the scope of it within an abstract class? In which scenario is the private access specifier used in an abstract class?

查看此代码，其中 Vehicle 类是抽象的， Car extends Vehicle。

check out this code where Vehicle class is abstract and Car extends Vehicle.

package com.vehicle;

abstract class Vehicle {

 // What is the scope of the private access modifier within an abstract class, even though  method below cannot be accessed??
  private void onLights(){
   System.out.println("Switch on Lights");
  }

  public void startEngine(){
   System.out.println("Start Engine");
  }

}

在同一个包中创建一个汽车类

Within is the same package creating a Car class

package com.vehicle;
/*
 * Car class extends the abstract class Vehicle
 */
public class Car extends Vehicle {

 public static void main(String args[]){
  Car c =  new Car();
  c.startEngine();
  // Only startEngine() can be accessed 
 }

}

推荐答案

由于抽象类可以包含功能（而不是接口），因此它可以包含私有变量或方法。

Since an abstract class can contain functionality (as opposed to an interface) it can have private variables or methods.

在您的示例中，您可能会执行以下操作：

In your example you might do something like

 public void startEngine(){
   injectFuel();
   igniteSpark();
   // etc. my understanding of engines is limited at best
   System.out.println("Start Engine");
 }

 private void injectFuel() {}
 private void igniteSpark() {}

这样你可以将一些工作传播到其他方法（所以你没有1000行startEngine方法），但是你不希望孩子们能够调用injectFuel因为它在startEngine的上下文之外没有意义（你想确保它只在那里使用）。

That way you can spread some of the work to other methods (so you don't have a 1000 line startEngine method), but you don't want the children to be able to call injectFuel separately since it doesn't make sense outside the context of startEngine (you want to make sure it's only used there).

或者甚至更多你可能有私有方法在其他几个公共方法中调用，具有不同的参数。这样就可以避免在每个公共方法中编写相同的代码两次或更多次，并将公共代码分组为私有方法，确保子代不访问它（就像他们之前不能只调用公共方法的一部分一样） ）。这样的事情：

Or even more you might have a private method that gets called in several other public methods, with different parameters. This way you avoid writing the same code twice or more in each of the public methods, and grouping the common code in a private method makes sure the children don't access it (like they couldn't just call part of the public method before). Something like this:

 public void startEngine() {
   dishargeBattery(50);
   System.out.println("Start Engine");
 }

 public void startRadio() {
   dischargeBattery(20);
 }

 private void dischargeBattery(int value) {
   battery.energy -= value; //battery should probably be a private field.
 }

这种方式你的方法可以使用电池，但孩子们不应该'搞乱它，你不会在它们两个中写相同的行（ battery.energy - = value ）。请注意，这些都是非常简单的例子，但如果dischargeBattery是500行方法，那么用其他方法编写它将是一件麻烦事。

This way your methods can have access to the battery, but the children shouldn't mess with it, and you don't write the same line (battery.energy -= value) in both of them. Take note though, that these are very simple examples, but if dischargeBattery was a 500 line method, writing it in both the other methods would be a hassle.

这篇关于为什么在Java中的抽象类中存在私有访问修饰符，即使我们无法创建抽象类的实例？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！