Modificadores de Java

Modificadores: A estas alturas, ya estamos bastante familiarizados con

la palabra clave public que aparece en casi todos los ejemplos:

public class Main

La palabra clave public es un modificador de acceso, lo que significa

que se usa para establecer el nivel de acceso para clases, atributos,
métodos y constructores.

Dividimos los modificadores en dos grupos:

Modificadores de acceso: Controlan el nivel de acceso.

Modificadores sin acceso: No controlan el nivel de acceso, pero

proporcionan otras funciones.

Modificadores de acceso: Para las clases, se puede usar public o

default (por defecto).
1. Modificador: public

Descripción: La clase es accesible por cualquier otra clase.

Ejemplo:
public class Main {

public static void main(String[] args) {

System.out.println("Hello World");

2. Modificador: default

Descripción: Solo las clases del mismo paquete pueden acceder a la

clase. Esto se usa cuando no se especifica un
modificador.

Ejemplo:
class MyClass {

public static void main(String[] args) {

System.out.println("Hello World");

Para atributos, métodos y constructores, se puede utilizar uno de los

siguientes modificadores:
3. Modificador: public

Descripción: El código es accesible para todas las clases.

Ejemplo:

Main.java

public class Main {

public String fname = "John";

public String lname = "Doe";

public String email = "john@doe.com";

public int age = 24;

Second.java

class Second {

public static void main(String[] args) {

Main myObj = new Main();

System.out.println("Name: " + myObj.fname + " " + myObj.lname);

System.out.println("Email: " + myObj.email);

System.out.println("Age: " + myObj.age);

Modificador: private

Descripción: El código solo es accesible dentro de la clase declarada.

Ejemplo:
public class Main {

private String fname = "John";

private String lname = "Doe";

private String email = "john@doe.com";

private int age = 24;

public static void main(String[] args) {

Main myObj = new Main();

System.out.println("Name: " + myObj.fname + " " + myObj.lname);

System.out.println("Email: " + myObj.email);

System.out.println("Age: " + myObj.age);

Modificador: default

Descripción: Solo se puede acceder al código en el mismo paquete.

Esto se usa cuando no se especifica un modificador.

Ejemplo:
class Person {

String fname = "John";

String lname = "Doe";

String email = "john@doe.com";

int age = 24;

public static void main(String[] args) {

 Person myObj = new Person();

System.out.println("Name: " + myObj.fname + " " + myObj.lname);

System.out.println("Email: " + myObj.email);

System.out.println("Age: " + myObj.age);

Modificador: protected

Descripción: El código es accesible en el mismo paquete y

subclases.

Ejemplo:
class Person {

protected String fname = "John";

protected String lname = "Doe";

protected String email = "john@doe.com";

protected int age = 24;

class Student extends Person {

private int graduationYear = 2018;

public static void main(String[] args) {

Student myObj = new Student();

System.out.println("Name: " + myObj.fname + " " + myObj.lname);

System.out.println("Email: " + myObj.email);

System.out.println("Age: " + myObj.age);

 System.out.println("Graduation Year: " + myObj.graduationYear);

Modificadores sin acceso: Para las clases, se puede usar final o

abstract.

Modificador: final

Descripción: La clase no puede ser heredada por otras clases.

Ejemplo:
final class Vehicle {

protected String brand = "Ford";

public void honk() {

System.out.println("Tuut, tuut!");

class Main extends Vehicle {

private String modelName = "Mustang";

public static void main(String[] args) {

Main myFastCar = new Main();

myFastCar.honk();

System.out.println(myFastCar.brand + " " + myFastCar.modelName);

}
}

Modificador: abstract

Descripción: La clase no se puede usar para crear objetos (para

acceder a una clase abstracta, debe ser heredada de
otra clase).

Ejemplo:
Main.java

// abstract class

abstract class Main {

public String fname = "John";

public String lname = "Doe";

public String email = "john@doe.com";

public int age = 24;

public abstract void study(); // abstract method

// Subclass (inherit from Person)

class Student extends Main {

public int graduationYear = 2018;

public void study() {

System.out.println("Studying all day long");

Second.java
class Second {

public static void main(String[] args) {

// create an object of the Student class (which inherits attributes and

methods from Main)

Student myObj = new Student();

System.out.println("Name: " + myObj.fname + " " + myObj.lname);

System.out.println("Email: " + myObj.email);

System.out.println("Age: " + myObj.age);

System.out.println("Graduation Year: " + myObj.graduationYear);

myObj.study(); // call abstract method

Para los atributos y métodos, puede utilizar uno de los siguientes:

Modificador: final

Descripción: Los atributos y métodos no se pueden anular /

modificar.

Modificador: static

Descripción: Los atributos y métodos pertenecen a la clase, más que

a un objeto
Modificador: abstract

Descripción: Solo se puede usar en una clase abstracta y en

métodos. El método no tiene cuerpo, por ejemplo,
abstract void run ();. El cuerpo lo proporciona la
subclase (heredado de).

Modificador: transient

Descripción: Los atributos y métodos se omiten al serializar el objeto

que los contiene.

Modificador: synchronized

Descripción: Solo se puede acceder a los métodos por un hilo a la

vez.

Modificador: volatile

Descripción: El valor de un atributo no se almacena en caché de

forma local por subprocesos y siempre se lee desde la
"memoria principal".
Final

Si no se desea tener la capacidad de anular los valores de los atributos

existentes, se deben declarar los atributos como final.

Ejemplo:

public class Main {

final int x = 10;

final double PI = 3.14;

public static void main(String[] args) {

Main myObj = new Main();

myObj.x = 50; // will generate an error

myObj.PI = 25; // will generate an error

System.out.println(myObj.x);

Estático

Un método static significa que se puede acceder a él sin crear un objeto

de la clase, a diferencia de public:
Un ejemplo para demostrar las diferencias entre los métodos static y
public:

public class Main {

// Static method

static void myStaticMethod() {

System.out.println("Static methods can be called without creating

objects");

// Public method

public void myPublicMethod() {

System.out.println("Public methods must be called by creating

objects");

// Main method

public static void main(String[] args) {

myStaticMethod(); // Call the static method

Main myObj = new Main(); // Create an object of MyClass

myObj.myPublicMethod(); // Call the public method

}
Resumen

Un método abstract pertenece a una clase abstract y no tiene cuerpo.

El cuerpo lo proporciona la subclase:

Ejemplo:

Main.java:

// abstract class

abstract class Main {

public String fname = "John";

public int age = 24;

public abstract void study(); // abstract method

// Subclass (inherit from Main)

class Student extends Main {

public int graduationYear = 2018;

public void study() { // the body of the abstract method is provided here

System.out.println("Studying all day long");

}
Second.java:

class Second {

public static void main(String[] args) {

// create an object of the Student class (which inherits attributes and

methods from Main)

Student myObj = new Student();

System.out.println("Name: " + myObj.fname);

System.out.println("Age: " + myObj.age);

System.out.println("Graduation Year: " + myObj.graduationYear);

myObj.study(); // call abstract method