Java - Clases internas
En este capítulo, discutiremos las clases internas de Java.
Clases anidadas
En Java, al igual que los métodos, las variables de una clase también pueden tener otra clase como miembro. Java permite escribir una clase dentro de otra. La clase escrita dentro se llama clase anidada , y la clase que contiene la clase interna se llama clase externa .
Sintaxis
La siguiente es la sintaxis para escribir una clase anidada. Aquí, la clase Outer_Demo es la clase externa y la clase Inner_Demo es la clase anidada.
class Outer_Demo {
class Inner_Demo {
}
}
Las clases anidadas se dividen en dos tipos −
-
Clases anidadas no estáticas − Estos son los miembros no estáticos de una clase.
-
Clases estáticas anidadas − Estos son los miembros estáticos de una clase.
Clases internas (clases anidadas no estáticas)
Las clases internas son un mecanismo de seguridad en Java. Sabemos que una clase no se puede asociar con el modificador de acceso privado , pero si tenemos la clase como miembro de otra clase, entonces la clase interna puede hacerse privada. Y esto también se usa para acceder a los miembros privados de una clase.
Las clases internas son de tres tipos dependiendo de cómo y dónde las defina. Ellos son −
- Clase Interna
- Clase interna local de método
- Clase interna anónima
Clase Interna
Crear una clase interna es bastante simple. Solo necesita escribir una clase dentro de una clase. A diferencia de una clase, una clase interna puede ser privada y una vez que declara privada una clase interna, no se puede acceder a ella desde un objeto fuera de la clase.
A continuación se muestra el programa para crear una clase interna y acceder a ella. En el ejemplo dado, hacemos que la clase interna sea privada y accedemos a la clase a través de un método.
Ejemplo
Demostración en vivo
class Outer_Demo {
int num;
// inner class
private class Inner_Demo {
public void print() {
System.out.println("This is an inner class");
}
}
// Accessing he inner class from the method within
void display_Inner() {
Inner_Demo inner = new Inner_Demo();
inner.print();
}
}
public class My_class {
public static void main(String args[]) {
// Instantiating the outer class
Outer_Demo outer = new Outer_Demo();
// Accessing the display_Inner() method.
outer.display_Inner();
}
}
Aquí puedes observar que Outer_Demo es la clase externa, Inner_Demo es la clase interna, display_Inner() es el método dentro del cual estamos instanciando la clase interna, y este método se invoca desde el principal método.
Si compila y ejecuta el programa anterior, obtendrá el siguiente resultado −
Salida
This is an inner class.
Acceso a los miembros privados
Como se mencionó anteriormente, las clases internas también se usan para acceder a los miembros privados de una clase. Supongamos que una clase tiene miembros privados para acceder a ellos. Escriba una clase interna en él, devuelva los miembros privados de un método dentro de la clase interna, por ejemplo, getValue() , y finalmente desde otra clase (desde la cual desea acceder a los miembros privados) llame al método getValue() de la clase interna.
Para crear una instancia de la clase interna, inicialmente debe crear una instancia de la clase externa. A partir de entonces, utilizando el objeto de la clase externa, la siguiente es la forma en que puede instanciar la clase interna.
Outer_Demo outer = new Outer_Demo(); Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
El siguiente programa muestra cómo acceder a los miembros privados de una clase usando la clase interna.
Ejemplo
Demostración en vivo
class Outer_Demo {
// private variable of the outer class
private int num = 175;
// inner class
public class Inner_Demo {
public int getNum() {
System.out.println("This is the getnum method of the inner class");
return num;
}
}
}
public class My_class2 {
public static void main(String args[]) {
// Instantiating the outer class
Outer_Demo outer = new Outer_Demo();
// Instantiating the inner class
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
System.out.println(inner.getNum());
}
}
Si compila y ejecuta el programa anterior, obtendrá el siguiente resultado −
Salida
This is the getnum method of the inner class: 175
Clase interna local de método
En Java, podemos escribir una clase dentro de un método y este será de tipo local. Al igual que las variables locales, el alcance de la clase interna está restringido dentro del método.
Una clase interna local de método solo se puede instanciar dentro del método donde se define la clase interna. El siguiente programa muestra cómo usar una clase interna local de método.
Ejemplo
Demostración en vivo
public class Outerclass {
// instance method of the outer class
void my_Method() {
int num = 23;
// method-local inner class
class MethodInner_Demo {
public void print() {
System.out.println("This is method inner class "+num);
}
} // end of inner class
// Accessing the inner class
MethodInner_Demo inner = new MethodInner_Demo();
inner.print();
}
public static void main(String args[]) {
Outerclass outer = new Outerclass();
outer.my_Method();
}
}
Si compila y ejecuta el programa anterior, obtendrá el siguiente resultado −
Salida
This is method inner class 23
Clase interna anónima
Una clase interna declarada sin un nombre de clase se conoce como clase interna anónima . En el caso de clases internas anónimas, las declaramos y las instanciamos al mismo tiempo. Por lo general, se utilizan siempre que necesite anular el método de una clase o una interfaz. La sintaxis de una clase interna anónima es la siguiente −
Sintaxis
AnonymousInner an_inner = new AnonymousInner() {
public void my_method() {
........
........
}
};
El siguiente programa muestra cómo anular el método de una clase usando una clase interna anónima.
Ejemplo
Demostración en vivo
abstract class AnonymousInner {
public abstract void mymethod();
}
public class Outer_class {
public static void main(String args[]) {
AnonymousInner inner = new AnonymousInner() {
public void mymethod() {
System.out.println("This is an example of anonymous inner class");
}
};
inner.mymethod();
}
}
Si compila y ejecuta el programa anterior, obtendrá el siguiente resultado −
Salida
This is an example of anonymous inner class
De la misma manera, puede anular los métodos de la clase concreta, así como la interfaz usando una clase interna anónima.
Clase interna anónima como argumento
Generalmente, si un método acepta un objeto de una interfaz, una clase abstracta o una clase concreta, podemos implementar la interfaz, extender la clase abstracta y pasar el objeto al método. Si es una clase, podemos pasarla directamente al método.
Pero en los tres casos, puede pasar una clase interna anónima al método. Esta es la sintaxis de pasar una clase interna anónima como argumento de método −
obj.my_Method(new My_Class() {
public void Do() {
.....
.....
}
});
El siguiente programa muestra cómo pasar una clase interna anónima como argumento de método.
Ejemplo
Demostración en vivo
// interface
interface Message {
String greet();
}
public class My_class {
// method which accepts the object of interface Message
public void displayMessage(Message m) {
System.out.println(m.greet() +
", This is an example of anonymous inner class as an argument");
}
public static void main(String args[]) {
// Instantiating the class
My_class obj = new My_class();
// Passing an anonymous inner class as an argument
obj.displayMessage(new Message() {
public String greet() {
return "Hello";
}
});
}
}
Si compila y ejecuta el programa anterior, obtendrá el siguiente resultado −
Salida
Hello, This is an example of anonymous inner class as an argument
Clase anidada estática
Una clase interna estática es una clase anidada que es un miembro estático de la clase externa. Se puede acceder a ella sin instanciar la clase externa, usando otros miembros estáticos. Al igual que los miembros estáticos, una clase anidada estática no tiene acceso a las variables de instancia ni a los métodos de la clase externa. La sintaxis de la clase anidada estática es la siguiente −
Sintaxis
class MyOuter {
static class Nested_Demo {
}
}
Crear una instancia de una clase anidada estática es un poco diferente de crear una instancia de una clase interna. El siguiente programa muestra cómo usar una clase anidada estática.
Ejemplo
Demostración en vivo
public class Outer {
static class Nested_Demo {
public void my_method() {
System.out.println("This is my nested class");
}
}
public static void main(String args[]) {
Outer.Nested_Demo nested = new Outer.Nested_Demo();
nested.my_method();
}
}
Si compila y ejecuta el programa anterior, obtendrá el siguiente resultado −
Salida
This is my nested class
Java