Modificadores de acceso en Java

¡Hola! En la lección de hoy, nos familiarizaremos con el concepto de modificadores de acceso y consideraremos ejemplos de cómo trabajar con ellos. Por supuesto, decir 'conocer' no es del todo correcto: ya estás familiarizado con la mayoría de ellos de lecciones anteriores. Por si acaso, refresquemos nuestra memoria del punto más importante. Los modificadores de acceso suelen ser palabras clave que regulan el acceso a diferentes partes de su código. ¿Por qué 'la mayoría de las veces'? Porque uno de ellos está configurado de forma predeterminada sin el uso de una palabra clave :) Java tiene cuatro modificadores de acceso. Los enumeramos en orden de los más restrictivos a los más "permisivos":

• privado;
• predeterminado (paquete visible);
• protegido;
• público.

Echemos un vistazo a cada uno de ellos e identifiquemos cuándo pueden ser útiles. Y daremos ejemplos :)

El modificador privado

private es el modificador de acceso más restrictivo. Limita la visibilidad de datos y métodos dentro de una sola clase. Conoces este modificador de la lección sobre getters y setters. ¿Recuerdas este ejemplo?

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }
}

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       cat.name = "";
       cat.age = -1000;
       cat.weight = 0;
   }
}

Lo consideramos en una lección anterior. Cometimos un grave error aquí: hacemos públicos nuestros datos, lo que permitió a otros programadores acceder a los campos directamente y cambiar sus valores. Es más... estos valores se asignaron sin ningún control. Esto significa que nuestro programa podría crear un gato llamado "" con una edad de -1000 años y un peso de 0. Para resolver este problema, usamos getters y setters, y también usamos el modificador privado para limitar el acceso a los datos.

public class Cat {

   private String name;
   private int age;
   private int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       // input parameter check
       this.name = name;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       // input parameter check
       this.age = age;
   }

   public int getWeight() {
       return weight;
   }

   public void setWeight(int weight) {
       // input parameter check
       this.weight = weight;
   }
}

Básicamente, limitar el acceso a los campos e implementar getters y setters son los ejemplos más comunes de cómo privadose utilizaría en el trabajo real. En otras palabras, el propósito principal de este modificador es lograr la encapsulación en un programa. Por cierto, esto no se aplica solo a los campos. Imagina que en tu programa hay un método que implementa alguna funcionalidad MUY compleja. ¿Qué podemos sugerir como ejemplo? Digamos que su método readDataFromCollider() acepta como entrada una dirección de datos, lee datos del Gran Colisionador de Hadrones en formato de bytes, convierte estos datos en texto, los escribe en un archivo y los imprime. Incluso una descripción del método da miedo, por no hablar del código :) Para que el código sea más legible, sería mejor no escribir toda la lógica compleja del método en un solo lugar. En cambio, deberíamos dividir la funcionalidad en métodos separados. Por ejemplo, readByteData()es responsable de leer los datos, el método convertBytesToSymbols() convierte los datos leídos del colisionador en texto, el método saveToFile() guarda el texto recibido en un archivo y el método printColliderData() imprime nuestro archivo de datos. Al final, nuestro método readDataFromCollider() será mucho más simple:

public class ColliderUtil {

   public void readDataFromCollider(Path pathToData) {
       byte[] colliderData = readByteData(pathToData);
       String[] textData = convertBytesToSymbols(colliderData);
       File fileWithData = saveToFile(textData);
       printColliderData(fileWithData);
   }

   public byte[] readByteData(Path pathToData) {

       // Reads data in bytes
   }

   public String[] convertBytesToSymbols(byte[] colliderDataInBytes) {

       // Converts bytes to characters
   }

   public File saveToFile(String[] colliderData) {

       // Saves read data to a file
   }

   public void printColliderData(File fileWithColliderData) {

       // Prints data from the file
   }
}

Sin embargo, como recordará de la lección sobre interfaces, el usuario solo tiene acceso a la interfaz externa. Y nuestros 4 métodos no son parte de eso. Son métodos auxiliares: los creamos para mejorar la legibilidad del código y no meter cuatro tareas diferentes en un solo método. No es necesario que le dé al usuario acceso a estos métodos. Si los usuarios tienen acceso al método convertBytesToSymbols() cuando trabajan con el colisionador, lo más probable es que simplemente se sientan confundidos por el método y se pregunten para qué sirve. ¿Qué bytes se convierten? ¿De dónde vienen ellos? ¿Por qué convertirlos a texto? La lógica ejecutada en este método no es parte de la interfaz expuesta al usuario. Solo readDataFromCollider()El método es parte de la interfaz. Entonces, ¿qué hacemos con estos cuatro métodos 'internos'? ¡Bien! Use el modificador privado para limitar el acceso a ellos. Hacer esto les permite realizar tranquilamente su trabajo dentro de la clase sin confundir al usuario, quien no necesita conocer la lógica de cada método individual.

public class ColliderUtil {

   public void readDataFromCollider(Path pathToData) {
       byte[] colliderData = readByteData(pathToData);
       String[] textData = convertBytesToSymbols(colliderData);
       File fileWithData = saveToFile(textData);
       printColliderData(fileWithData);
   }

   private byte[] readByteData(Path pathToData) {
       // Reads data in bytes
   }

   private String[] convertBytesToSymbols(byte[] colliderDataInBytes) {
       // Converts bytes to characters
   }

   private File saveToFile(String[] colliderData) {
       // Saves read data to a file
   }

   private void printColliderData(File fileWithColliderData) {
       // Prints data from the file
   }
}

El modificador protegido

El siguiente modificador más restrictivo está protegido . Los campos y métodos marcados por el modificador de acceso protegido serán visibles:

• dentro de todas las clases incluidas en el mismo paquete que el nuestro;
• dentro de todas las clases que heredan nuestra clase.

Al principio, es difícil imaginar cuándo podría ser necesario. No se sorprenda: hay muchos menos casos de uso para protected que para private y son muy específicos. Imagine que tenemos una clase abstracta AbstractSecretAgent que representa a un agente secreto en algún servicio de inteligencia, así como un paquete top_secret que contiene esta clase y sus descendientes. Clases concretas como FBISecretAgent , MI6SecretAgent , MossadSecretAgent , etc. lo heredan. Dentro de la clase abstracta, queremos implementar un contador de agentes. Aumentará cuando se cree un nuevo agente en algún lugar del programa. paquete top_secret;

public abstract class AbstractSecretAgent {

   public static int agentCount = 0;
}

¡Pero nuestros agentes son secretos! Esto significa que ellos y nadie más debe saber cuántos de ellos existen. Podemos agregar fácilmente el modificador protected al campo agent_counter . Luego, las instancias de otras clases de agentes secretos y otras clases ubicadas en nuestro paquete top_secret pueden obtener su valor.

public abstract class AbstractSecretAgent {

   protected static int agent_counter = 0;
}

Y ese es el tipo de tarea especializada que requiere el modificador protected :)

El modificador visible del paquete

El siguiente en la lista es el modificador predeterminado , también conocido como el modificador visible del paquete . No está indicado por una palabra clave, ya que Java lo aplica por defecto a todos los campos y métodos. Si escribes lo siguiente en tu código:

int x = 10

la variable x tendrá acceso visible a este paquete . Es fácil recordar lo que hace. Básicamente, por defecto = herencia protegida :) Al igual que el modificador protected , su aplicación es limitada. La mayoría de las veces, el acceso predeterminado se usa en un paquete que tiene algunas clases de utilidades que no implementan la funcionalidad de todas las demás clases en el paquete. Demos un ejemplo. Imagine que tenemos un paquete de 'servicios'. Contiene varias clases que trabajan con una base de datos. Por ejemplo, hay una clase UserService que lee los datos del usuario de la base de datos, un CarServiceclase que lee datos de automóviles de la misma base de datos y otras clases, cada una de las cuales trabaja con tipos específicos de objetos y lee los datos correspondientes de la base de datos.

package services;

public class UserService {
}

package services;

public class CarService {
}

Pero sería fácil que los datos de la base de datos estuvieran en un formato y los necesitamos en otro. Imagine que las fechas de nacimiento de los usuarios en la base de datos se almacenan como <TIMESTAMP WITH TIME ZONE>...

2014-04-04 20:32:59.390583+02

...y en su lugar necesitamos el objeto más simple: un java.util.Date . Para resolver este problema, dentro del paquete de servicios , podemos crear una clase Mapper especial . Será responsable de convertir los datos de la base de datos en nuestros objetos Java familiares. Una clase auxiliar simple. Por lo general, declaramos todas las clases como clase pública ClassName , pero esto no es un requisito. Podemos declarar nuestra clase auxiliar simplemente como class Mapper . En este caso, todavía hace su trabajo, ¡pero no es visible para nadie fuera del paquete de servicios !

package services;

class Mapper {
}


package services;

public class CarService {

   Mapper mapper;
}

Y aquí está el razonamiento básico: ¿por qué alguien fuera de un paquete necesitaría ver una clase auxiliar que solo funciona con las clases de ese paquete?

El modificador público

Y por último, pero no menos importante, ¡el modificador público ! Conoció este modificador en su primer día de estudio en CodeGym la primera vez que ejecutó public static void main(String[] args) . Ahora que has estudiado la lección sobre interfaces, su propósito es obvio para ti :) Después de todo, el modificador público fue creado para dar algo a los usuarios. Por ejemplo, la interfaz de su programa. Suponga que ha escrito un programa traductor que puede traducir texto del ruso al inglés. Creó un método translate(String textInRussian) que implementa toda la lógica necesaria. Marcaste este método con la palabra public y ahora es parte de la interfaz:

public class Translator {

   public String translate(String textInRussian) {

       // Translates text from Russian to English
   }
}

Puede vincular este método al botón 'Traducir' en la pantalla y ¡listo! Cualquiera puede usarlo. Las partes del código marcadas con el modificador público están destinadas al usuario final. Proporcionando un ejemplo de la vida real, privado es para todos los procesos que ocurren dentro de un televisor, pero público es para los botones del control remoto que se usan para administrar el televisor. Además, el usuario no necesita saber cómo está construido o funciona el televisor. El control remoto es el conjunto de métodos públicos : on() , off() , nextChannel() , previousChannel() , IncreaseVolume() , DisminuirVolume() etc. Para reforzar lo que aprendió, le sugerimos que vea una lección en video de nuestro Curso de Java