Modificadores de acceso. Privado, protegido, predeterminado, público

¡Hola! En la conferencia de hoy nos familiarizaremos con el concepto de " modificadores de acceso " y veremos ejemplos de cómo trabajar con ellos. Aunque la palabra "vamos a conocernos" no será del todo correcta: ya estás familiarizado con la mayoría de ellas gracias a conferencias anteriores. Por si acaso, refresquemos la memoria sobre lo principal. Los modificadores de acceso suelen ser palabras clave que regulan el nivel de acceso a diferentes partes de su código. ¿Por qué "más a menudo"? Porque uno de ellos está configurado de forma predeterminada y no está indicado por una palabra clave :) Hay un total de cuatro modificadores de acceso en Java. Los enumeramos en orden desde los más estrictos hasta los más “suaves”:

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

Veamos cada uno de ellos, decidamos cuándo pueden sernos útiles y demos ejemplos :)

Modificador privado

Private- 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 conferencia sobre captadores y definidores. ¿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("¡Maullar!");
   }
}

public class Main {

   public static void main(String[] args) {

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

Lo analizamos en uno de los artículos anteriores. Aquí cometimos un grave error: abrimos nuestros datos, como resultado de lo cual los compañeros programadores tuvieron acceso directo a los campos de clase y cambiaron sus valores. Además, estos valores se asignaron sin controles, por lo que en nuestro programa es posible crear un gato con una edad de -1000 años, un nombre "" y un peso de 0. Para solucionar este problema, utiliza captadores y definidores , y también acceso limitado a los datos mediante un modificador private.

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("¡Maullar!");
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       // comprobando el parámetro de entrada
       this.name = name;
   }

   public int getAge() {
       return age;
   }

   public void setAge(int age) {
       // comprobando el parámetro de entrada
       this.age = age;
   }

   public int getWeight() {
       return weight;
   }

   public void setWeight(int weight) {
       // comprobando el parámetro de entrada
       this.weight = weight;
   }
}

En realidad, restringir el acceso a los campos e implementar getters-setters es el ejemplo más común de uso privateen el trabajo real. Es decir, implementar la encapsulación en un programa es el objetivo principal de este modificador. Por cierto, esto no sólo se aplica a los campos. Imagine que en su programa hay un método que implementa alguna funcionalidad MUY compleja. Para poner esto como ejemplo... Digamos que su método readDataFromCollider()toma una dirección con datos como entrada, lee datos del Gran Colisionador de Hadrones en formato byte, convierte estos datos en texto, los escribe en un archivo y los imprime. Incluso la descripción del método parece espeluznante, y mucho menos el código :) Para aumentar la legibilidad del código, sería bueno no escribir la lógica compleja del método en un solo lugar, sino, por el contrario, romper la funcionalidad. en métodos separados. Por ejemplo, el método readByteData()es responsable de leer datos, convertBytesToSymbols()convertir los datos leídos del colisionador en texto, saveToFile()guardar el texto resultante en un archivo e printColliderData()imprimir nuestro archivo de datos. El método readDataFromCollider()acabaría siendo mucho más sencillo:

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

       // lee datos en bytes
   }

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

       // convertir bytes a caracteres
   }

   public File saveToFile(String[] colliderData) {

       // guarda los datos leídos en un archivo
   }

   public void printColliderData(File fileWithColliderData) {

       // imprimir datos del archivo
   }
}

Sin embargo, como recordará de la conferencia sobre interfaces, el usuario sólo tiene acceso a la interfaz final. Y nuestros 4 métodos no forman parte de ello. Son auxiliares : los creamos para mejorar la legibilidad del código y evitar agrupar cuatro tareas diferentes en un solo método. No es necesario dar acceso al usuario a estos métodos. Si un usuario tiene acceso al método cuando trabaja con un colisionador convertBytesToSymbols(), lo más probable es que simplemente no entienda qué es este método y por qué es necesario. ¿Qué bytes se convierten? ¿De dónde vienen ellos? ¿Por qué convertirlos a texto? La lógica que se ejecuta en este método no forma parte de la interfaz de usuario. Sólo el método readDataFromCollider()es parte de la interfaz. ¿Qué hacer con estos cuatro métodos "internos"? ¡Bien! Restrinja el acceso a ellos con un modificador private. De esta forma pueden realizar fácilmente su trabajo dentro de la clase y no confundir al usuario, que no necesita la lógica de cada uno de ellos por separado.

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) {
       // lee datos en bytes
   }

   private String[] convertBytesToSymbols(byte[] colliderDataInBytes) {
       // convertir bytes a caracteres
   }

   private File saveToFile(String[] colliderData) {
       // guarda los datos leídos en un archivo
   }

   private void printColliderData(File fileWithColliderData) {
       // imprimir datos del archivo
   }
}

Modificador protegido

El siguiente modificador de acceso más restrictivo es protected. Los campos y métodos designados con el modificador de acceso protectedserán visibles:

• dentro de todas las clases que están en el mismo paquete que el nuestro;
• dentro de todas las clases sucesoras de nuestra clase.

Inmediatamente resulta difícil imaginar cuándo podría ser necesario esto. No te sorprendas: protectedhay muchos menos casos de aplicación que private, y son específicos. Imaginemos que tenemos una clase abstracta AbstractSecretAgentque denota un agente secreto de alguna agencia de inteligencia, así como un paquete top_secretque contiene esta clase y sus descendientes. Las clases concretas ( ,, FBISecretAgentetc. ) se heredan de él. Dentro de la clase abstracta queremos implementar un contador de agentes. Cuando se crea un nuevo objeto agente en algún lugar del programa, aumentará. MI6SecretAgentMossadSecretAgent

package top_secret;

public abstract class AbstractSecretAgent {

   public static int agentCount = 0;
}

¡Pero nuestros agentes son secretos! Esto significa que sólo ellos y nadie más deben conocer su número. Podemos agregar fácilmente un modificador protectedal campo agentCounty luego los objetos de otras clases de agentes secretos o aquellas clases que se encuentran en nuestro paquete "secreto" pueden obtener su valor top_secret.

public abstract class AbstractSecretAgent {

   protected static int agentCount = 0;
}

Es para tareas tan específicas que se necesita un modificador protected:)

modificador visible del paquete

El siguiente en nuestra lista es el modificador defaulto, como también se le llama, package visible. No se indica mediante una palabra clave porque está configurado de forma predeterminada en Java para todos los campos y métodos. Si escribes en tu código -

int x = 10;

... la variable xtendrá este mismo package visibleacceso. Si un método (o variable) no está marcado con ningún modificador, se considera que está marcado con el "modificador predeterminado". Las variables o métodos con dicho modificador (es decir, sin ninguno) son visibles para todas las clases del paquete en el que están declarados. Y sólo a ellos. Sus usos son limitados, al igual que el modificador protected. Muy a menudo, default-access se utiliza en un paquete donde hay algunas clases de utilidad que no implementan la funcionalidad de todas las demás clases de este paquete. Pongamos un ejemplo. Imaginemos que tenemos un paquete de " servicios ". En su interior hay varias clases que trabajan con la base de datos. Por ejemplo, hay una clase UserServiceque lee datos de usuario de una base de datos, una clase CarServiceque lee datos sobre automóviles de la misma base de datos y otras clases, cada una de las cuales trabaja con su propio tipo de objetos y lee datos sobre ellos de la base de datos.

package services;

public class UserService {
}

package services;

public class CarService {
}

Sin embargo, puede ocurrir fácilmente una situación en la que los datos de la base de datos están en un formato, pero los necesitamos en otro. Imagine que la fecha de nacimiento del usuario en la base de datos está almacenada en el formato TIMESTAMP CON ZONA HORARIA...

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

...en su lugar necesitamos el objeto más simple: java.util.Date. Para ello, podemos crear servicesuna clase especial dentro del paquete Mapper. Será responsable de convertir los datos de la base de datos en los objetos Java con los que estamos familiarizados. Una clase de ayuda simple. Normalmente creamos todas las clases como public class ClassName, pero esto no es necesario. 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 services!

package services;

class Mapper {
}


package services;

public class CarService {

   Mapper mapper;
}

Y esta, de hecho, es la lógica correcta: ¿por qué alguien fuera del paquete vería una clase auxiliar que funciona sólo con clases del mismo paquete?

modificador público

Y por último en la lista, pero no menos importante, ¡el modificador public! Lo conociste el primer día de estudios en JavaRush, lanzando public static void main(String[] args). Ahora que ha estudiado las conferencias sobre interfaces, su propósito es obvio :) Después de todo, publicfue creado para dar algo a los usuarios. Por ejemplo, la interfaz de su programa. Digamos que usted escribió un programa de traducción y éste puede traducir textos del ruso al inglés. Ha creado un método translate(String textInRussian)dentro del cual se implementa la lógica necesaria. Marcaste este método con la palabra publicy ahora pasará a formar parte de la interfaz:

public class Translator {

   public String translate(String textInRussian) {

       // traduce texto del ruso al inglés
   }
}

Puede asociar una llamada a este método con el botón "traducir" en la pantalla del programa, ¡y listo! Cualquiera puede usarlo. Partes del código marcadas con el modificador publicestán destinadas al usuario final. Para dar un ejemplo de la vida, privateestos son todos los procesos que ocurren dentro del televisor cuando está funcionando, y publicestos son los botones del control remoto del televisor con los que el usuario puede controlarlo. Al mismo tiempo, no necesita saber cómo funciona el televisor y cómo funciona. El control remoto es un conjunto publicde métodos: on(), off(), nextChannel(), previousChannel(), increaseVolume(), decreaseVolume()etc.