Perché c'è un modificatore di accesso privato in una classe astratta in Java, anche se non possiamo creare un'istanza di una classe astratta?
So che non è una buona pratica di codifica dichiarare un metodo come private in una classe abstract. Anche se non possiamo creare un'istanza di una classe abstract, perché il modificatore di accesso private è disponibile all'interno di una classe abstract e qual è l'ambito di esso all'interno di una classe abstract? In quale scenario viene utilizzato l'identificatore di accesso private in una classe abstract?
Controlla questo codice dove Vehicle la classe è astratta e Car estende il veicolo.
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");
}
}
All'interno è lo stesso pacchetto che crea una classe di auto
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
}
}
4 answers
Poiché una classe astratta può contenere funzionalità (al contrario di un'interfaccia) può avere variabili o metodi privati.
Nel tuo esempio potresti fare qualcosa come
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() {}
In questo modo puoi distribuire parte del lavoro ad altri metodi (quindi non hai un metodo StartEngine da 1000 righe), ma non vuoi che i bambini siano in grado di chiamare injectFuel separatamente poiché non ha senso al di fuori del contesto di StartEngine (vuoi assicurarti che sia usato solo per la prima volta). c').
O ancora di più potresti avere un metodo privato che viene chiamato in molti altri metodi pubblici, con parametri diversi. In questo modo si evita di scrivere lo stesso codice due o più volte in ciascuno dei metodi pubblici e il raggruppamento del codice comune in un metodo privato assicura che i bambini non vi accedano (come se non potessero chiamare solo parte del metodo pubblico prima). Qualcosa del genere:
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.
}
In questo modo i tuoi metodi possono avere accesso alla batteria, ma i bambini non dovrebbe pasticciare con esso, e non si scrive la stessa riga (battery.energy -= value) in entrambi. Prendi nota però che questi sono esempi molto semplici, ma se dischargeBattery fosse un metodo a 500 righe, scriverlo in entrambi gli altri metodi sarebbe una seccatura.
È lo stesso di una classe non astratta, non c'è differenza.
Il che significa che se nulla nella tua classe astratta chiama il metodo privato, allora puoi anche rimuoverlo, dato che non verrà chiamato (mettendo a nudo un lavoro di riflessione malvagio).
Di solito, i metodi privati vengono utilizzati solo come metodi di utilità interni che hanno un compito molto specifico che gli altri metodi della classe usano per fare il loro lavoro.
So che non è una buona codifica pratica per dichiarare un metodo come privato in una classe astratta.
Non lo so. Dove ti è venuta quest'idea?
Qual è lo scopo di esso all'interno di una classe astratta?
La classe astratta.
È possibile accedere al metodo solo all'interno della classe abstract. Ad esempio, si potrebbe avere una classe astratta con un metodo public final che fa uso di un metodo helper privato.