Modificador de acceso abstracto vs público en Java

El modificador de acceso en Java es la palabra clave reservada que se usa para definir el alcance de una clase, variable y métodos. También nos dice si la creación de clases secundarias es posible o no o si la creación de objetos es posible o no.

Abstract Access Modifier es un modificador aplicable solo para clases y métodos, pero no para variables. Si declaramos cualquier método como abstracto, ese método debe tener su implementación en la clase secundaria de la clase respectiva porque los métodos abstractos nunca hablan de implementación. Si algún modificador habla de implementación, forma una combinación ilegal con un modificador abstracto. De manera similar, si para cualquier clase de Java no se nos permite crear un objeto (debido a una implementación parcial), entonces ese tipo de clase debemos declararlo con un modificador abstracto.

Ejemplo:

// Java program to illustrate Abstract Access Modifier
 
// Importing the required packages
import java.io.*;
import java.util.*;
 
// Class 1
// Helper abstract class
abstract class Vehicle {
 
    // Declaring an abstract method getNumberOfWheel
    abstract public int getNumberOfWheel();
}
 
// Class 2
// Helper class extending above abstract class
class Bus extends Vehicle {
 
    // Giving the implementation
    // to the  parent abstract method
    public int getNumberOfWheel() { return 7; }
}
 
// Class 3
// Helper class extending above abstract class
class Auto extends Vehicle {
 
    // Giving the implementation
    // to the  parent abstract method
    public int getNumberOfWheel() { return 3; }
}
 
// Class 4
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating Bus object
        Bus b = new Bus();
 
        // Creating Auto object
        Auto a = new Auto();
 
        // Now getting and displaying
        // the number of wheels
        // for Bus by calling the
        // getNumberOfWheel method
        System.out.println("Number of wheels in bus is"
                           + " " + b.getNumberOfWheel());
 
        // Now getting and displaying
        // the number of wheels
        // for Auto by calling the
        // getNumberOfWheel method
        System.out.println("Number of wheels in Auto is"
                           + " " + a.getNumberOfWheel());
    }
}

Number of wheels in bus is 7
Number of wheels in Auto is 3

Ahora, pensando en el siguiente modificador, está el modificador de acceso público. Entonces, si una clase se declara pública, podemos acceder a esa clase desde cualquier lugar. Crearemos un paquete pack1 dentro de ese paquete declaramos una clase A que es pública y dentro de esa clase declaramos un método m1 que también es público. Ahora creamos otro paquete pack2 y dentro de ese pack2 importamos pack1 y declaramos una clase B y en el método principal de la clase B creamos un objeto de tipo clase A e intentamos acceder a los datos del método m1.

Ejemplo 1:

// Java Program to illustrate public modifier
 
// Creating a package pack1
package pack1;
 
// Declaring a class A
public class A {
 
    // Declaring a public method m1
    public void m1()
    {
 
        // Print statement
        System.out.println("GFG");
    }
}

Producción:

Ejemplo 2:

// Java Program to Illustrate Public Modifier
 
// Creating package pack2
package pack2;
// Importing package pack1;
import java.io.*;
// Importing the required modules
import java.util.*;
import pack1.*;
 
// Main class
// Declaring a class B
class B {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating object of type class A
        A b = new A();
 
        // Now calling the method m1()
        A.m1();
    }
}

Producción:

Finalmente, después de tener una comprensión adecuada de ambos, concluyamos las diferencias entre ellos para hacer clic en una mejor comprensión, como se muestra en la siguiente tabla: