¿Cuál es la diferencia entre público, protegido, paquete privado y privado en Java?

https://stackoverflow.com/questions/215497

03-07-2019
|

Pregunta

En Java, hay reglas claras sobre cuándo usar cada uno de los modificadores de acceso, a saber, el predeterminado (paquete privado), público , protegido y privado , al tiempo que crea class y interface y se ocupa de la herencia?

Solución

El tutorial oficial puede serle de alguna utilidad. .

            │ Class │ Package │ Subclass │ Subclass │ World
            │       │         │(same pkg)│(diff pkg)│ 
────────────┼───────┼─────────┼──────────┼──────────┼────────
public      │   +   │    +    │    +     │     +    │   +     
────────────┼───────┼─────────┼──────────┼──────────┼────────
protected   │   +   │    +    │    +     │     +    │         
────────────┼───────┼─────────┼──────────┼──────────┼────────
no modifier │   +   │    +    │    +     │          │    
────────────┼───────┼─────────┼──────────┼──────────┼────────
private     │   +   │         │          │          │    

 + : accessible         blank : not accessible

Otros consejos

(Advertencia: no soy un programador de Java, soy un programador de Perl. Perl no tiene protecciones formales, tal vez por eso entiendo el problema tan bien :))

Privado

Como pensaría, solo la clase en la que está declarada puede verla.

Paquete privado

Solo se puede ver y usar el paquete en el que se declaró. Este es el valor predeterminado en Java (que algunos ven como un error).

Protegido

El paquete privado + puede verse por subclases o miembro del paquete.

Público

Todos pueden verlo.

Publicado

Visible fuera del código que controlo. (Si bien no es la sintaxis de Java, es importante para esta discusión).

C ++ define un nivel adicional llamado " amigo " y cuanto menos sepas, mejor.

¿Cuándo deberías usar qué? La idea general es la encapsulación para ocultar información. En la medida de lo posible, desea ocultar los detalles de cómo se hace algo a sus usuarios. ¿Por qué? Porque entonces puedes cambiarlos más tarde y no romper el código de nadie. Esto le permite optimizar, refactorizar, rediseñar y corregir errores sin preocuparse de que alguien esté utilizando el código que acaba de revisar.

Entonces, la regla de oro es hacer que las cosas sean tan visibles como tienen que ser. Comience con privado y solo agregue más visibilidad según sea necesario. Solo haga público lo que sea absolutamente necesario para que el usuario sepa, cada detalle que haga público obstaculizará su capacidad para rediseñar el sistema.

Si desea que los usuarios puedan personalizar los comportamientos, en lugar de hacer públicos los internos para que puedan anularlos, a menudo es una mejor idea meter esas agallas en un objeto y hacer que la interfaz sea pública. De esa manera, simplemente pueden enchufar un nuevo objeto. Por ejemplo, si estaba escribiendo un reproductor de CD y quería que " vaya a buscar información sobre este CD " personalizable, en lugar de hacer públicos esos métodos, pondría toda esa funcionalidad en su propio objeto y haría público solo el que obtiene / establece el objeto. De esta manera, ser tacaño al exponer sus entrañas fomenta la buena composición y la separación de preocupaciones

Personalmente, me quedo con solo " privado " y " público " ;. Muchos idiomas OO solo tienen eso. " Protegido " Puede ser útil, pero es realmente un tramposo. Una vez que una interfaz es más que privada, queda fuera de su control y debe buscar el código de otras personas para encontrar usos.

Aquí es donde aparece la idea de " publicada " entra. Cambiar una interfaz (refactorizarla) requiere que encuentre todo el código que la está utilizando y que también lo cambie. Si la interfaz es privada, bueno no hay problema. Si está protegido tienes que ir a buscar todas tus subclases. Si es público tienes que buscar todo el código que usa tu código. A veces esto es posible, por ejemplo, si está trabajando en un código corporativo que es solo para uso interno, no importa si una interfaz es pública. Puedes sacar todo el código del repositorio corporativo. Pero si se publica una interfaz " " ;, si hay un código que la utiliza fuera de su control, entonces se muestra. Debe admitir esa interfaz o código de riesgo de ruptura. Incluso las interfaces protegidas se pueden considerar publicadas (por lo que no me molesto en protegerlas).

Muchos idiomas consideran que la naturaleza jerárquica de público / protegido / privado es demasiado limitante y no está en línea con la realidad. Para ese fin, existe el concepto de una clase de rasgos , pero ese es otro programa.

Aquí hay una mejor versión de la tabla. (Prueba de futuro con una columna para módulos).

Explicaciones

Un miembro privado ( i ) es solo accesible dentro de la misma clase que se declara.
Un miembro con sin modificador de acceso ( j ) solo es accesible dentro de las clases en el mismo paquete.
Un miembro protegido ( k ) es accesible dentro de todas las clases en el mismo paquete y dentro de las subclases en otros paquetes.
Un miembro público ( l ) es accesible a todas las clases (a menos que resida en un module que no exporta el paquete en el que está declarado).

¿Qué modificador elegir?

Los modificadores de acceso es una herramienta para ayudarlo a evitar que se rompa la encapsulación ^(*) accidentalmente. Pregúntese si desea que el miembro sea algo interno de la clase, el paquete, la jerarquía de clases o no sea interno, y elija el nivel de acceso en consecuencia.

Ejemplos :

Un campo long internalCounter probablemente debería ser privado, ya que es mutable y un detalle de implementación.
Una clase que solo debe crearse una instancia en una clase de fábrica (en el mismo paquete) debe tener un constructor de paquete restringido, ya que no debería ser posible llamarlo directamente desde fuera del paquete.
Un método interno de void beforeRender () llamado justo antes de renderizar y usado como un enganche en subclases debe estar protegido.
El método void saveGame (File dst) que se llama desde el código GUI debe ser público.

^{(*) ¿Qué es exactamente la encapsulación?}

                | highest precedence <---------> lowest precedence
*———————————————+———————————————+———————————+———————————————+———————
 \ xCanBeSeenBy | this          | any class | this subclass | any
  \__________   | class         | in same   | in another    | class
             \  | nonsubbed     | package   | package       |    
Modifier of x \ |               |           |               |       
————————————————*———————————————+———————————+———————————————+———————
public          |       ✔       |     ✔     |       ✔       |   ✔   
————————————————+———————————————+———————————+———————————————+———————
protected       |       ✔       |     ✔     |       ✔       |   ✘   
————————————————+———————————————+———————————+———————————————+———————
package-private |               |           |               |
(no modifier)   |       ✔       |     ✔     |       ✘       |   ✘   
————————————————+———————————————+———————————+———————————————+———————
private         |       ✔       |     ✘     |       ✘       |   ✘

Regla fácil. Comience con declarar todo lo privado. Y luego avanza hacia el público a medida que surgen las necesidades y el diseño lo justifica.

Al exponer a los miembros, pregúntese si está exponiendo las opciones de representación o las opciones de abstracción. Lo primero es algo que desea evitar, ya que introducirá demasiadas dependencias en la representación real en lugar de en su comportamiento observable.

Como regla general, trato de evitar anular las implementaciones de métodos mediante subclases; Es demasiado fácil arruinar la lógica. Declare los métodos abstractos protegidos si pretende que se invalide.

También, use la anotación @Override al anular para evitar que las cosas se rompan cuando se refactoriza.

En realidad es un poco más complicado que una simple cuadrícula. La cuadrícula le dice si se permite un acceso, pero ¿qué constituye exactamente un acceso? Además, los niveles de acceso interactúan con las clases anidadas y la herencia de formas complejas.

El " predeterminado " El acceso (especificado por la ausencia de una palabra clave) también se denomina package-private . Excepción: en una interfaz, ningún modificador significa acceso público; Los modificadores que no sean públicos están prohibidos. Las constantes de enumeración son siempre públicas.

Resumen

¿Se permite el acceso a un miembro con este especificador de acceso?

El miembro es privado : solo si el miembro está definido dentro de la misma clase que el código de llamada.
El miembro es un paquete privado: solo si el código de llamada está dentro del paquete que lo contiene inmediatamente.
El miembro está protegido : el mismo paquete, o si el miembro está definido en una superclase de la clase que contiene el código de llamada.
El miembro es public : Sí.

A qué especificadores de acceso se aplican

Las variables locales y los parámetros formales no pueden tomar especificadores de acceso. Debido a que son intrínsecamente inaccesibles al exterior según las reglas de alcance, son efectivamente privadas.

Para las clases en el ámbito superior, solo se permiten public y package-private. Esta opción de diseño es presumiblemente porque protected y private serían redundantes en el nivel del paquete (no hay herencia de paquetes).

Todos los especificadores de acceso son posibles en miembros de clase (constructores, métodos y funciones de miembro estático, clases anidadas).

Relacionado: Accesibilidad a la clase Java

Orden

Los especificadores de acceso pueden ser estrictamente ordenados

público > protegido > paquete privado > privado

significa que public proporciona el mayor acceso, private lo menos. Cualquier referencia posible en un miembro privado también es válida para un miembro privado del paquete; cualquier referencia a un miembro privado del paquete es válida en un miembro protegido, y así sucesivamente. (Dar acceso a miembros protegidos a otras clases en el mismo paquete se consideró un error).

Notas

Los métodos de una clase tienen permiso para acceder a miembros privados de otros objetos del misma clase. Más precisamente, un método de clase C puede acceder a miembros privados de C en objetos de cualquier subclase de C. Java no admite restricciones de acceso por instancia, solo por clase. (Compare con Scala, que lo admite utilizando private [this] .)
Necesitas acceso a un constructor para construir un objeto. Por lo tanto, si todos los constructores son privados, la clase solo puede construirse mediante el código que vive dentro de la clase (por lo general, los métodos de fábrica estáticos o los inicializadores de variables estáticas). Del mismo modo para el paquete privado o constructores protegidos.
- Tener solo constructores privados también significa que la clase no puede ser subclasificada externamente, ya que Java requiere que los constructores de una subclase llamen implícita o explícitamente a un constructor de superclase. (Sin embargo, puede contener una clase anidada que la subclasifique).

Clases internas

También debe tener en cuenta los ámbitos anidados , como las clases internas. Un ejemplo de la complejidad es que las clases internas tienen miembros, que ellos mismos pueden tomar modificadores de acceso. Así que puedes tener una clase interna privada con un miembro público; ¿Se puede acceder al miembro? (Ver a continuación). La regla general es mirar el alcance y pensar de forma recursiva para ver si se puede acceder a cada nivel.

Sin embargo, esto es bastante complicado, y para más detalles, consulte la Especificación del lenguaje Java . (Sí, ha habido errores de compilación en el pasado).

Para saber cómo interactúan, considere este ejemplo. Es posible " filtrar " clases internas privadas; esto suele ser una advertencia:

class Test {
    public static void main(final String ... args) {
        System.out.println(Example.leakPrivateClass()); // OK
        Example.leakPrivateClass().secretMethod(); // error
    }
}

class Example {
    private static class NestedClass {
        public void secretMethod() {
            System.out.println("Hello");
        }
    }
    public static NestedClass leakPrivateClass() {
        return new NestedClass();
    }
}

Salida del compilador:

Test.java:4: secretMethod() in Example.NestedClass is defined in an inaccessible class or interface
        Example.leakPrivateClass().secretMethod(); // error
                                  ^
1 error

Algunas preguntas relacionadas:

Java: ¿Accesibilidad del método dentro de la clase privada del paquete?

Como regla general:

private : alcance de la clase.
predeterminado (o package-private ): alcance del paquete.
protected : package scope + child (como el paquete, pero podemos crear subclases de diferentes paquetes). El modificador protegido siempre mantiene el " padre-hijo " relación.
public : en todas partes.

Como resultado, si dividimos el derecho de acceso en tres derechos:

(D) irect (invocar desde un método dentro de la misma clase, o a través de " esta " sintaxis).
(R) eference (invoque un método utilizando una referencia a la clase, o mediante la sintaxis de " punto ").
(I) herencia (mediante subclasificación).

entonces tenemos esta tabla simple:

+—-———————————————+————————————+———————————+
|                 |    Same    | Different |
|                 |   Package  | Packages  |
+—————————————————+————————————+———————————+
| private         |   D        |           |
+—————————————————+————————————+———————————+
| package-private |            |           |
| (no modifier)   |   D R I    |           |
+—————————————————+————————————+———————————+
| protected       |   D R I    |       I   |
+—————————————————+————————————+———————————+
| public          |   D R I    |    R  I   |
+—————————————————+————————————+———————————+

En muy corto

public : accesible desde cualquier lugar.
protected : accesible por las clases del mismo paquete y las subclases que residen en cualquier paquete.
predeterminado (sin modificador especificado): accesible por las clases del mismo paquete.
private : accesible solo dentro de la misma clase.

El modificador de acceso más incomprendido en Java está protegido . Sabemos que es similar al modificador predeterminado con una excepción en la que las subclases pueden verlo. ¿Pero cómo? Aquí hay un ejemplo que esperamos clarifique la confusión:

Supongamos que tenemos 2 clases; Father y Son , cada uno en su propio paquete:

package fatherpackage;

public class Father
{

}

-------------------------------------------

package sonpackage;

public class Son extends Father
{

}

Agreguemos un método protegido foo () a Father .

package fatherpackage;

public class Father
{
    protected void foo(){}
}

El método foo () se puede llamar en 4 contextos:

Dentro de una clase que se encuentra en el mismo paquete donde se define foo () ( fatherpackage ):

package fatherpackage;

public class SomeClass
{
    public void someMethod(Father f, Son s)
    {
        f.foo();
        s.foo();
    }
}

Dentro de una subclase, en la instancia actual a través de this o super :

package sonpackage;

public class Son extends Father
{
    public void sonMethod()
    {
        this.foo();
        super.foo();
    }
}

En una referencia cuyo tipo es la misma clase:

package fatherpackage;

public class Father
{
    public void fatherMethod(Father f)
    {
        f.foo(); // valid even if foo() is private
    }
}

-------------------------------------------

package sonpackage;

public class Son extends Father
{
    public void sonMethod(Son s)
    {
        s.foo();
    }
}

En una referencia cuyo tipo es la clase principal y está dentro del paquete donde se define foo () ( fatherpackage ) [Esto puede ser incluido dentro del contexto no. 1]:
```
package fatherpackage;

public class Son extends Father
{
    public void sonMethod(Father f)
    {
        f.foo();
    }
}
```

Las siguientes situaciones no son válidas.
1. En una referencia cuyo tipo es la clase principal y está fuera del paquete donde se define foo () ( fatherpackage ):
```
package sonpackage;

public class Son extends Father
{
    public void sonMethod(Father f)
    {
        f.foo(); // compilation error
    }
}
```
2. Una no subclase dentro de un paquete de una subclase (Una subclase hereda los miembros protegidos de su padre y los hace privados a no subclases):
```
package sonpackage;

public class SomeClass
{
    public void someMethod(Son s) throws Exception
    {
        s.foo(); // compilation error
    }
}
```

Privado

Métodos, variables y constructores

Los métodos, variables y constructores que se declaran privados solo se pueden acceder dentro de la clase declarada.

Clase e interfaz

El modificador de acceso privado es el nivel de acceso más restrictivo. La clase y las interfaces no pueden ser privadas.

Nota

Se puede acceder a las variables que se declaran privadas fuera de la clase si los métodos de obtención públicos están presentes en la clase. Solo las subclases de otro paquete o cualquier clase dentro del paquete de la clase de los miembros protegidos pueden acceder a las variables, métodos y constructores que están declarados protegidos en una superclase.

Protegido

Clase e interfaz

El modificador de acceso protegido no se puede aplicar a clase e interfaces.

Los métodos, los campos se pueden declarar protegidos, sin embargo, los métodos y los campos en una interfaz no se pueden declarar protegidos.

Nota

El acceso protegido le da a la subclase la oportunidad de usar el método o variable auxiliar, mientras evita que una clase no relacionada intente usarlo.

Public

Se puede acceder a una clase, método, constructor, interfaz, etc. declarada pública desde cualquier otra clase.

Por lo tanto, se puede acceder a los campos, métodos y bloques declarados dentro de una clase pública desde cualquier clase que pertenezca al Universo Java.

Paquetes diferentes

Sin embargo, si la clase pública a la que intentamos acceder está en un paquete diferente, la clase pública aún necesita ser importada.

Debido a la herencia de clase, todos los métodos y variables públicos de una clase son heredados por sus subclases.

Predeterminado -No palabra clave:

El modificador de acceso predeterminado significa que no declaramos explícitamente un modificador de acceso para una clase, campo, método, etc.

Dentro de los mismos paquetes

Una variable o método declarado sin ningún modificador de control de acceso está disponible para cualquier otra clase en el mismo paquete. Los campos en una interfaz son implícitamente públicos final estático y los métodos en una interfaz son públicos por defecto.

Nota

No podemos anular los campos estáticos. Si intentas anularlo, no aparece ningún error. pero no funciona lo que nosotros exceptuamos.

Respuestas relacionadas

Anulación de métodos estáticos en java

Enlaces de referencias

http://docs.oracle.com/javase/tutorial/ java / javaOO / accesscontrol.html http://www.tutorialspoint.com/java/java_access_modifiers.htm

Privado : acceso limitado solo a la clase

Predeterminado (sin modificador) : acceso limitado a la clase y al paquete

Protegido : acceso limitado a clase, paquete y subclases (paquete interno y externo)

Público : accesible para la clase, el paquete (todas) y las subclases ... En resumen, en todas partes.

La diferencia se puede encontrar en los enlaces que ya se proporcionaron, pero cuál de ellos usualmente se reduce al " Principio de conocimiento mínimo " Solo permita la menor visibilidad que se necesite.

Los modificadores de acceso están ahí para restringir el acceso en varios niveles.

Público: Es básicamente tan simple como puedes acceder desde cualquier clase, ya sea que esté en el mismo paquete o no.

Para acceder, si está en el mismo paquete, puede acceder directamente, pero si está en otro paquete, puede crear un objeto de la clase.

Predeterminado: Es accesible en el mismo paquete desde cualquiera de la clase de paquete.

Para acceder puedes crear un objeto de la clase. Pero no puede acceder a esta variable fuera del paquete.

Protegido: puede acceder a las variables en el mismo paquete, así como a la subclase en cualquier otro paquete. así que básicamente es el comportamiento predeterminado + heredado .

Para acceder al campo protegido definido en la clase base, puede crear el objeto de la clase secundaria.

Privado: se puede acceder en la misma clase.

En los métodos no estáticos, puede acceder directamente debido a la referencia de esta (también en los constructores), pero para acceder a los métodos estáticos que necesita para crear el objeto de la clase.

Modificadores de acceso en Java.

Los modificadores de acceso de Java se utilizan para proporcionar control de acceso en Java.

1. Predeterminado:

Accesible solo para las clases en el mismo paquete.

Por ejemplo,

// Saved in file A.java
package pack;

class A{
  void msg(){System.out.println("Hello");}
}

// Saved in file B.java
package mypack;
import pack.*;

class B{
  public static void main(String args[]){
   A obj = new A(); // Compile Time Error
   obj.msg(); // Compile Time Error
  }
}

Este acceso es más restringido que público y protegido, pero menos restringido que privado.

2. Público

Se puede acceder desde cualquier lugar. (Acceso global)

Por ejemplo,

// Saved in file A.java

package pack;
public class A{
  public void msg(){System.out.println("Hello");}
}

// Saved in file B.java

package mypack;
import pack.*;

class B{
  public static void main(String args[]){
    A obj = new A();
    obj.msg();
  }
}

Salida: Hola

3. Privado

Accesible solo dentro de la misma clase.

Si intenta acceder a miembros privados de una clase en otra, se producirá un error de compilación. Por ejemplo,

class A{
  private int data = 40;
  private void msg(){System.out.println("Hello java");}
}

public class Simple{
  public static void main(String args[]){
    A obj = new A();
    System.out.println(obj.data); // Compile Time Error
    obj.msg(); // Compile Time Error
  }
}

4. Protegido

Accesible solo para las clases en el mismo paquete y para las subclases

Por ejemplo,

// Saved in file A.java
package pack;
public class A{
  protected void msg(){System.out.println("Hello");}
}

// Saved in file B.java
package mypack;
import pack.*;

class B extends A{
  public static void main(String args[]){
    B obj = new B();
    obj.msg();
  }
}

Salida: Hola

Solo quiero abordar un detalle que generalmente se equivoca, incluso en la mayoría de las respuestas de esta página. " Predeterminado " el acceso (cuando no hay un modificador de acceso) no es siempre el mismo que el paquete privado . Depende de lo que sea la cosa.

Los tipos de no miembros (es decir, clases, enumeraciones, interfaces y tipos de anotación no declarados dentro de otro tipo) son paquetes privados por defecto. ( JLS & # 167; 6.6.1 )
Los miembros de la clase y los constructores son de paquetes privados de forma predeterminada. ( JLS & # 167; 6.6.1 )
Los constructores de enumeración son privados por defecto . (De hecho, los enunciadores deben ser privados, y es un error tratar de hacerlos públicos o protegidos). Las constantes de enumeración son públicas y no permiten ningún especificador de acceso. Otros miembros de enums son paquetes-privados por defecto. ( JLS & # 167; 8.9 )
Todos los miembros de interfaces y tipos de anotación son públicos por defecto . (De hecho, los miembros de las interfaces y los tipos de anotación deben ser públicos, y es un error tratar de hacerlos privados o protegidos.) (JLS & # 167; 9.3 a 9.5 )

público : accesible desde cualquier parte de la aplicación.
predeterminado : accesible desde el paquete.
protegido : se puede acceder desde el paquete y las subclases en otro paquete. también
privado : solo accesible desde su clase.

Visible para el paquete. El valor por defecto. No se necesitan modificadores.

Solo visible para la clase ( privado )

Visible para el mundo ( público ).

Visible para el paquete y todas las subclases ( protegido ).

Las variables y los métodos se pueden declarar sin ningún modificador al que se llame. Ejemplos predeterminados:

String name = "john";

public int age(){
    return age;
}

Modificador de acceso privado - privado:

Los métodos, variables y constructores que se declaran privados solo se pueden acceder dentro de la clase declarada. El modificador de acceso privado es el nivel de acceso más restrictivo. La clase y las interfaces no pueden ser privadas.

Se puede acceder a las variables que se declaran privadas fuera de la clase si los métodos de obtención pública están presentes en la clase.

El uso del modificador privado es la forma principal en que un objeto se encapsula y oculta los datos del mundo exterior.

Ejemplos:

Public class Details{

    private String name;

    public void setName(String n){
        this.name = n;
    }

    public String getName(){
        return this.name;
    }
}

Modificador de acceso público - público:

Se puede acceder a una clase, método, constructor, interfaz, etc. declarados públicos desde cualquier otra clase. Por lo tanto, se puede acceder a los campos, métodos y bloques declarados dentro de una clase pública desde cualquier clase que pertenezca al universo de Java.

Sin embargo, si la clase pública a la que intentamos acceder está en un paquete diferente, la clase pública aún debe importarse.

Debido a la herencia de clase, todos los métodos y variables públicos de una clase son heredados por sus subclases.

Ejemplo:

public void cal(){

}

Modificador de acceso protegido - protegido:

Las subclases en otro paquete o cualquier clase dentro del paquete de la clase de los miembros protegidos pueden acceder a las variables, métodos y constructores que están declarados protegidos en una superclase.

El modificador de acceso protegido no se puede aplicar a la clase y las interfaces. Los métodos, los campos se pueden declarar protegidos, sin embargo, los métodos y los campos en una interfaz no se pueden declarar protegidos.

El acceso protegido le da a la subclase la oportunidad de usar el método o variable auxiliar, mientras evita que una clase no relacionada intente usarlo.

class Van{

    protected boolean speed(){

    }
}

class Car{
    boolean speed(){
    }

}

Esta página escribe bien sobre el amperio protegido ; modificador de acceso predeterminado

.... Protegido: el modificador de acceso protegido es un poco complicado y se puede decir que es un superconjunto del modificador de acceso predeterminado. Los miembros protegidos son los mismos que los miembros predeterminados en lo que respecta al acceso en el mismo paquete. La diferencia es que los miembros protegidos también son accesibles a las subclases de la clase en la que se declara al miembro que están fuera del paquete en el que está presente la clase principal.

Pero estos miembros protegidos son & # 8220; accesibles fuera del paquete solo a través de la herencia & # 8220 ;. es decir, puede acceder a un miembro protegido de una clase en su subclase presente en algún otro paquete directamente como si el miembro estuviera presente en la propia subclase. Pero ese miembro protegido no será accesible en la subclase fuera del paquete al usar la referencia de la clase principal # 8217 ;. ....

La respuesta de David proporciona el significado de cada modificador de acceso. En cuanto a cuándo usar cada una, sugeriría hacer públicas todas las clases y los métodos de cada clase que están destinados para uso externo (su API), y todo lo demás privado.

Con el tiempo, sabrá cuándo hacer que algunas clases sean privadas para el paquete y cuándo declarar ciertos métodos protegidos para su uso en subclases.

Nota: Esto es solo un suplemento para la respuesta aceptada.

Esto está relacionado con Java modificadores de acceso .

De Modificadores de acceso de Java :

Un modificador de acceso de Java especifica qué clases pueden acceder a un determinado   La clase y sus campos, constructores y métodos. Los modificadores de acceso pueden   especificarse por separado para una clase, sus constructores, campos y   metodos Los modificadores de acceso de Java también son a veces referidos en diarios.   el discurso como especificadores de acceso a Java, pero el nombre correcto es acceso a Java   modificadores Clases, campos, constructores y métodos pueden tener uno de   Cuatro modificadores de acceso Java diferentes:


elemento de lista

privado

predeterminado (paquete)

protegido

público

De Cómo controlar el acceso a los miembros de una clase tutoriales:

Los modificadores de nivel de acceso determinan si otras clases pueden usar un   Campo particular o invocar un método particular. Hay dos niveles   de control de acceso:


En el nivel superior: público o paquete privado (sin modificador explícito).

En el nivel de miembro: público, privado, protegido o paquete privado (sin modificador explícito).


Una clase puede ser declarada con el modificador public, en cuyo caso ese   La clase es visible para todas las clases en todas partes. Si una clase no tiene modificador   (el valor predeterminado, también conocido como paquete-privado), es visible solo   dentro de su propio paquete

La siguiente tabla muestra el acceso a los miembros permitido por cada   modificador.
╔═════════════╦═══════╦═════════╦══════════╦═══════╗
║ Modifier    ║ Class ║ Package ║ Subclass ║ World ║
╠═════════════╬═══════╬═════════╬══════════╬═══════╣
║ public      ║ Y     ║ Y       ║ Y        ║ Y     ║
║ protected   ║ Y     ║ Y       ║ Y        ║ N     ║
║ no modifier ║ Y     ║ Y       ║ N        ║ N     ║
║ private     ║ Y     ║ N       ║ N        ║ N     ║
╚═════════════╩═══════╩═════════╩══════════╩═══════╝
La primera columna de datos indica si la clase en sí tiene acceso a   El miembro definido por el nivel de acceso. Como puedes ver, una clase siempre.   Tiene acceso a sus propios miembros. La segunda columna indica si   clases en el mismo paquete que la clase (independientemente de su   paternidad) tienen acceso al miembro. La tercera columna indica   si las subclases de la clase declarada fuera de este paquete tienen   Acceso al miembro. La cuarta columna indica si todas las clases   tener acceso al miembro.

Los niveles de acceso te afectan de dos maneras. Primero, cuando usas clases que   provienen de otra fuente, como las clases en la plataforma Java,   Los niveles de acceso determinan qué miembros de esas clases son tuyos.   Las clases pueden usar. Segundo, cuando escribes una clase, necesitas decidir   ¿Qué nivel de acceso tiene cada variable miembro y cada método en su clase?   debería tener.

Los valores predeterminados y privados protegidos públicos son modificadores de acceso.

Están diseñados para encapsular u ocultar y mostrar los contenidos de la clase.

La clase puede ser pública o predeterminada
Los miembros de la clase pueden ser públicos, protegidos, predeterminados o privados.

Privado no es accesible fuera de la clase Por defecto es accesible solo en el paquete. Protegido en paquete así como cualquier clase que lo extienda. El público está abierto para todos.

Normalmente, las variables de los miembros se definen como privadas, pero los métodos de los miembros son públicos.

Muchas veces me he dado cuenta de que recordar los conceptos básicos de cualquier lenguaje puede ser posible mediante la creación de analogías del mundo real. Aquí está mi analogía para entender los modificadores de acceso en Java:

Supongamos que eres estudiante en una universidad y tienes un amigo que viene a visitarte durante el fin de semana. Supongamos que existe una gran estatua del fundador de la universidad en el medio del campus.

Cuando lo traes al campus, lo primero que tú y tu amigo ven es esta estatua. Esto significa que cualquier persona que camina en el campus puede mirar la estatua sin el permiso de la universidad. Esto hace que la estatua sea PÚBLICA.
Luego, quieres llevar a tu amigo a tu dormitorio, pero para eso necesitas registrarlo como visitante. Esto significa que recibe un pase de acceso (que es el mismo que el tuyo) para ingresar a varios edificios en el campus. Esto haría que su tarjeta de acceso sea PRROTECTED.
Tu amigo quiere iniciar sesión en el WiFi del campus pero no tiene las credenciales para hacerlo. La única forma en que puede conectarse es si comparte su nombre de usuario con él. (Recuerde, cada estudiante que va a la universidad también posee estas credenciales de inicio de sesión). Esto haría que sus credenciales de inicio de sesión sean SIN MODIFICADOR .
Finalmente, tu amigo quiere leer tu informe de progreso para el semestre que se publica en el sitio web. Sin embargo, cada estudiante tiene su propio inicio de sesión personal para acceder a esta sección del sitio web del campus. Esto haría que estas credenciales sean PRIVATE.

Espero que esto ayude!

Cuando piense en los modificadores de acceso, piense de esta manera (se aplica a las variables y métodos ):

public - > accesible desde cualquier lugar
privado - > accesible solo dentro de la misma clase donde se declara

Ahora surge la confusión cuando se trata de default y protected

predeterminado - > No hay palabra clave modificadora de acceso presente. Esto significa que está disponible estrictamente dentro del paquete de la clase. En ninguna parte fuera de ese paquete se puede acceder.

protected - > Un poco menos estricto que predeterminado y, aparte de las mismas clases de paquetes, se puede acceder mediante subclases fuera del paquete que se declara.

Se trata de encapsulación (o como Joe Phillips declaró, menos conocimiento ).

Comience con lo más restrictivo (privado) y vea si necesita modificadores menos restrictivos más adelante.

Todos usamos modificadores de métodos y miembros como privado, público, ... pero una cosa que muy pocos desarrolladores hacen es usar paquetes para organizar el código de manera lógica.

Por ejemplo: Puede colocar métodos de seguridad confidenciales en un paquete de 'seguridad'. Luego coloque una clase pública que acceda a algunos de los códigos relacionados con la seguridad en este paquete, pero mantenga las otras clases de seguridad paquete privado . Por lo tanto, otros desarrolladores solo podrán usar la clase disponible públicamente desde fuera de este paquete (a menos que cambien el modificador). Esta no es una función de seguridad, pero será guía de uso.

Outside world -> Package (SecurityEntryClass ---> Package private classes)

Otra cosa es que las clases que dependen mucho una de la otra pueden terminar en el mismo paquete y eventualmente podrían ser refactorizadas o combinadas si la dependencia es demasiado fuerte.

Si, por el contrario, configuras todo como público , no quedará claro a qué se debe o no se debe acceder, lo que puede llevar a escribir muchos javadoc (que no imponen nada a través del compilador ...).

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow