Modificadores de Java

Java proporciona muchos modificadores, que se dividen principalmente en dos categorías siguientes:

• modificadores de acceso

• Modificadores no de acceso

Los modificadores se utilizan para definir clases, métodos o variables, generalmente ubicados al principio de la declaración. A continuación, se muestra un ejemplo para ilustrar:

public　class　ClassName　{
　　　//　...
}
private　boolean　myFlag;
static　final　double　weeks　=　9.5;
protected　static　final　int　BOXWIDTH　=　42;
public static void main(String[] arguments) {
　　　//　Cuerpo del método
}

modificadores de control de acceso

En Java, se pueden usar modificadores de acceso para proteger el acceso a clases, variables, métodos y constructores. Java admite 4 distintos permisos de acceso.

• default (es decir, predeterminado, sin escribir nada): Visible dentro del mismo paquete, sin usar ningún modificador. Uso: clases, interfaces, variables, métodos.

• private : Visible dentro de la misma clase. Uso: variables, métodos. Nota: No se puede modificar una clase (clase externa)

• public : Visible para todas las clases. Uso: clases, interfaces, variables, métodos

• protected : Visible para las clases del mismo paquete y todas las subclases. Uso: variables, métodos. Nota: No se puede modificar una clase (clase externa)。

Podemos explicar los permisos de acceso con la siguiente tabla:

Control de acceso

modificador de acceso predeterminado-No usar ninguna palabra clave

Las variables y métodos declarados con el modificador de acceso predeterminado son visibles para las clases del mismo paquete. Las variables en las interfaces se declaran implícitamente como public static final, y los métodos en las interfaces tienen permiso de acceso público por defecto.

Como se muestra en el siguiente ejemplo, la declaración de variables y métodos puede no usar ningún modificador.

package　defaultPackage;
class　Logger　{
　　　　void　message(){
　　　　　　　　System.out.println("This　is　a　message");
　　　　}
}

En este caso, la clase Logger tiene el modificador de acceso predeterminado. Y esta clase es visible para todas las clases del paquete defaultPackage. Pero, si intentamos usar la clase Logger en otra clase fuera del paquete defaultPackage, obtendremos un error de compilación.

modificador de acceso privado-private

El modificador de acceso privado es el nivel de acceso más estricto, por lo que los declarados como private los métodos, variables y constructores solo pueden ser accedidos por la clase que los contiene, y las clases e interfaces no pueden ser declaradas como private。

Las variables declaradas como de acceso privado solo pueden ser accedidas desde el exterior de la clase a través de métodos getter públicos de la clase.

El uso del modificador de acceso privado se utiliza principalmente para ocultar los detalles de implementación de la clase y proteger los datos de la clase.

La siguiente clase utiliza el modificador de acceso privado:

public class Logger {
　　　private String format;
　　　public String getFormat() {
　　　　　　return this.format;
　　　}
　　　public void setFormat(String format) {
　　　　　　this.format = format;
　　　}
}

En el ejemplo, la variable format de la clase Logger es una variable privada, por lo que otras clases no pueden obtener y establecer el valor de esta variable directamente. Para permitir que otras clases operen esta variable, se definen dos métodos public: getFormat() (que devuelve el valor de format) y setFormat(String) (que establece el valor de format)

modificador de acceso público-public

Las clases, métodos, constructores y interfaces declarados como public pueden ser accedidos por cualquier otra clase.

Si varios clases publicos que se访问 se distribuyen en diferentes paquetes,则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

Las siguientes funciones utilizan el control de acceso público:

public static void main(String[] arguments) {
　　　//　...
}

El método main() del programa Java debe establecerse como público, de lo contrario, el intérprete de Java no podrá ejecutar la clase.

modificador de acceso protegido-protected

protected debe analizarse y explicarse desde dos puntos de vista:

• La subclase y la clase base están en el mismo paquete: las variables, métodos y constructores declarados como protected pueden ser accedidos por cualquier otra clase en el mismo paquete;

• La subclase y la clase base no están en el mismo paquete: entonces en la subclase, la instancia de la subclase puede acceder a los métodos protected heredados de la clase base, pero no puede acceder a los métodos protected de la instancia de la clase base.

protected puede modificar miembros de datos, métodos de construcción, métodos miembros,No se puede modificar una clase (excepto las clases internas)。

Las variables y métodos miembros de una interfaz no pueden declararse como protected.

La subclase puede acceder a los métodos y variables declarados con el modificador protected, lo que permite proteger que clases no relacionadas utilicen estos métodos y variables.

La clase padre utiliza el modificador de acceso protected, y la subclase sobrescribe el método openSpeaker() de la clase padre.

class AudioPlayer {
　　　protected boolean openSpeaker(Speaker sp) {}}
　　　　　　//　Detalles de implementación
　　　}
}
　
class StreamingAudioPlayer extends AudioPlayer {
　　　protected boolean openSpeaker(Speaker sp) {}}
　　　　　　//　Detalles de implementación
　　　}
}

Si declaramos el método openSpeaker() como private, no podrán acceder al método todas las clases excepto AudioPlayer.

Si declaramos openSpeaker() como public, todos los tipos de clase podrán acceder al método.

Si solo queremos que el método sea visible para la subclase de la clase en la que se encuentra, declaramos el método como protected.

Protected es el modificador de acceso de miembro de clase Java más difícil de entender.

Control de acceso y herencia

Por favor, tenga en cuenta las siguientes reglas de herencia de métodos:

• Los métodos declarados como public en la clase padre también deben ser public en la subclase.

• Los métodos declarados como protected en la clase padre en la subclase deben declararse como protected o public, no pueden declararse como private.

• Los métodos declarados como private en la clase padre no pueden ser heredados.

Modificadores no de acceso

Para implementar algunas otras funciones, Java también proporciona muchos modificadores no de acceso.

El modificador static se utiliza para modificar métodos y variables de clase.

El modificador final se utiliza para modificar clases, métodos y variables, la clase modificada con final no puede ser heredada, el método modificado no puede ser redefinido por la clase heredada, la variable modificada es una constante y no puede modificarse.

El modificador abstract se utiliza para crear clases abstractas y métodos abstractos.

Los modificadores synchronized y volatile, se utilizan principalmente en la programación de hilos.

Modificador static

• Variables estáticas:

  La palabra clave static se utiliza para declarar variables estáticas independientes del objeto, independientemente de cuántos objetos se ejemplifique un clase, sus variables estáticas tienen solo una copia. Las variables estáticas también se conocen como variables de clase. Las variables locales no pueden declararse como variables estáticas.

• Métodos estáticos:

  La palabra clave static se utiliza para declarar métodos estáticos independientes del objeto. Los métodos estáticos no pueden usar variables no estáticas de la clase. Los métodos estáticos obtienen datos de la lista de parámetros, luego calculan estos datos.

El acceso a variables de clase y métodos puede realizarse directamente classname.variablename y classname.methodname de la manera.

Como se muestra en el siguiente ejemplo, el modificador static se utiliza para crear métodos y variables de clase.

public class InstanceCounter {
　　　private static int numInstances = 0;
　　　protected static int getCount() {}}
　　　　　　return numInstances;
　　　}
　
　　　private static void addInstance() {
　　　　　　numInstances++;
　　　}
　
　　　InstanceCounter() {
　　　　　　InstanceCounter.addInstance();
　　　}
　
　　　public static void main(String[] arguments) {
　　　　　　System.out.println("Desde ",　+
　　　　　　InstanceCounter.getCount()　+　"comienzan 0 instancias");
　　　　　　for (int i = 0; i <　500;　++i){
　　　　　　　　　new InstanceCounter();
　　　　　　　　　　}
　　　　　　System.out.println("Created ",　+
　　　　　　InstanceCounter.getCount()　+　"instancias");
　　　}
}

El resultado de ejecutar el ejemplo anterior es el siguiente:

Desde 0 instancias
Crear　500 instancias

Modificador final

Variable final:

Final significa "último, definitivo", una vez que se asigna un valor a una variable final, no se puede reasignar. Las variables que se marcan con final deben especificar explícitamente un valor inicial.

El modificador final se utiliza comúnmente junto con el modificador static para crear constantes de clase.

public class Test{
　　final int value =　10;
　　//　A continuación se muestra un ejemplo de declaración de constantes
　　public static final int BOXWIDTH =　6;
　　static final String TITLE = "Manager";
　
　　public void changeValue(){
　　　　　value =　12;　//Generará un error
　　}
}

Método final

Los métodos finales en la clase padre pueden ser heredados por la clase hija, pero no pueden ser sobrescritos por la clase hija.

El principal objetivo de declarar un método final es evitar que su contenido se modifique.

Como se muestra a continuación, se declara un método utilizando el modificador final.

public class Test{
　　　　public final void changeName(){
　　　　　　　//　Cuerpo del método
　　　　}
}

Clase final

Las clases finales no pueden ser heredadas, ninguna clase puede heredar cualquier característica de una clase final.

public final class Test {
　　　//　Cuerpo de la clase
}

Modificador abstract

Clase abstracta:

Las clases abstractas no se pueden utilizar para instanciar objetos, el único propósito de declarar una clase abstracta es para ampliarla en el futuro.

Una clase no puede estar simultáneamente modificada por abstract y final. Si una clase contiene métodos abstractos, entonces la clase debe declararse como abstracta, de lo contrario se producirá un error de compilación.

Una clase abstracta puede contener métodos abstractos y no abstractos.

abstract class Caravan{
　　　private double price;
　　　private String model;
　　　private String year;
　　　public abstract void goFast();　//Método abstracto
　　　public abstract void changeColor();
}

Método abstracto

Un método abstracto es un método sin ninguna implementación, y su implementación específica se proporciona por la subclase.

Los métodos abstractos no pueden ser declarados como final y static.

Cualquier subclase que herede de una clase abstracta debe implementar todos los métodos abstractos del padre, a menos que también sea una clase abstracta.

Si una clase contiene varios métodos abstractos, entonces la clase debe declararse como abstracta. La clase abstracta puede no contener métodos abstractos.

La declaración de un método abstracto termina con un punto y coma, por ejemplo:public abstract sample();。

public abstract class SuperClass{
　　　　abstract void m();　//Método abstracto
}
　
class SubClass extends SuperClass{
　　　　　//Implementar el método abstracto
　　　　　　void m(){
　　　　　　　　　　.........
　　　　　　}
}

Modificador synchronized

El método declarado con la palabra clave synchronized puede ser accedido por un solo hilo a la vez. El modificador synchronized puede aplicarse a cuatro modificadores de acceso.

public synchronized void showDetails(){
.......
}

Modificador transient

Cuando un objeto serializado contiene una variable ejemplo transient, el JVM (Java Virtual Machine) salta sobre esa variable específica.

Este modificador se incluye en la declaración de definición de variables para preprocesar el tipo de datos de la clase y las variables.

public transient int limit =;　55;　　　//　No se persistirá
public int b;　//　Persistencia

Modificador volatile

Los miembros de variables修饰的volatile se leen forzadamente desde la memoria compartida cada vez que se accede a ellos por un hilo. Además, cuando un miembro de variable cambia, se forza a que el hilo escriba el valor cambiado de vuelta a la memoria compartida. De esta manera, en cualquier momento, dos hilos diferentes siempre ven el mismo valor de un miembro de variable.

Una referencia a un objeto volatile puede ser null.

public class MyRunnable implements Runnable
{
　　　　private volatile boolean active;
　　　　public void run()
　　　　{
　　　　　　　　active = true;
　　　　　　　　while (active)　//　la primera línea
　　　　　　　　{
　　　　　　　　　　　　//　código
　　　　　　　　}
　　　　}
　　　　public void stop()
　　　　{
　　　　　　　　active = false;　//　la segunda línea
　　　　}
}

En circunstancias normales, en una línea de código que llama al método run() (en el hilo iniciado por Runnable), en otra línea de código se llama al método stop(). si la primera línea si el valor de active en el búfer se utiliza, entonces en la segunda línea El valor de active será false y el bucle no se detendrá.

Pero en el código anterior hemos utilizado la palabra clave volatile para modificar active, por lo que el bucle se detendrá.