Why is there a private access modifier in an abstract class in Java, even though we cannot create an instance of an abstract class?

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?

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() {}

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.
 }

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.

It's the same as in a non-abstract class, there's no difference.

Which means that if nothing in your abstract class calls the private method, then you can just as well remove it, as it won't be called (baring some evil reflection work).

Usually, private methods are only used as internal utility methods that have a very specific task that the other methods in the class use to do their work.

I know it is not a good coding practice to declare a method as private in an abstract class.

I don't. Where did you get that idea?

what is the scope of it within an abstract class?

The abstract class.

The method can be accessed only from within the abstract class. For example, you could have an abstract class with a public final method that makes use of a private helper method.

package arrayafter;

public abstract class Abstract_Demo {

    abstract void display();

    private void display1() {
        System.out.println("Private Method");
    }

    final void display2() {
        System.out.println("final Method");
        display1();
    }

    public static void display3() {

        System.out.println("Static methods");
    }

}

package arrayafter;

import java.util.Scanner;

public class Practice extends Abstract_Demo{

    public static void main(String[] args) {
        
        Practice pr=new Practice();
        pr.display();
        pr.display2();
        Abstract_Demo.display3();
    }

    @Override
    void display() {
        // TODO Auto-generated method stub
        System.out.println("Abstract method");
        
    }

}