¿Cuál es la principal diferencia entre una clase interna y una clase anidada estática en Java? ¿El diseño / implementación juega un papel en la elección de uno de estos?
¿Cuál es la principal diferencia entre una clase interna y una clase anidada estática en Java? ¿El diseño / implementación juega un papel en la elección de uno de estos?
Respuestas:
Del tutorial de Java :
Las clases anidadas se dividen en dos categorías: estáticas y no estáticas. Las clases anidadas que se declaran estáticas simplemente se denominan clases anidadas estáticas. Las clases anidadas no estáticas se denominan clases internas.
Se accede a las clases anidadas estáticas utilizando el nombre de la clase adjunta:
OuterClass.StaticNestedClass
Por ejemplo, para crear un objeto para la clase anidada estática, use esta sintaxis:
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
Los objetos que son instancias de una clase interna existen dentro de una instancia de la clase externa. Considere las siguientes clases:
class OuterClass {
...
class InnerClass {
...
}
}
Una instancia de InnerClass solo puede existir dentro de una instancia de OuterClass y tiene acceso directo a los métodos y campos de su instancia adjunta.
Para crear una instancia de una clase interna, primero debe crear una instancia de la clase externa. Luego, cree el objeto interno dentro del objeto externo con esta sintaxis:
OuterClass outerObject = new OuterClass()
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
ver: Tutorial de Java - Clases anidadas
Para completar, tenga en cuenta que también existe una clase interna sin una instancia de cierre :
class A {
int t() { return 1; }
static A a = new A() { int t() { return 2; } };
}
Aquí, new A() { ... }
es una clase interna definida en un contexto estático y no tiene una instancia de cierre.
import OuterClass.StaticNestedClass;
después hacer referencia a la clase simplemente como OuterClass.
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
?
Terminología: las clases anidadas se dividen en dos categorías: estáticas y no estáticas. Las clases anidadas que se declaran estáticas simplemente se denominan clases anidadas estáticas. Las clases anidadas no estáticas se denominan clases internas.
En el lenguaje común, los términos "anidado" e "interno" se usan indistintamente por la mayoría de los programadores, pero usaré el término correcto "clase anidada" que cubre tanto interno como estático.
Las clases se pueden anidar hasta el infinito , por ejemplo, la clase A puede contener la clase B que contiene la clase C que contiene la clase D, etc. Sin embargo, más de un nivel de anidamiento de clase es raro, ya que generalmente es un mal diseño.
Hay tres razones por las que puede crear una clase anidada:
Hay cuatro tipos de clases anidadas en Java . En resumen, son:
Déjame elaborar en más detalles.
Las clases estáticas son las más fáciles de entender porque no tienen nada que ver con las instancias de la clase que las contiene.
Una clase estática es una clase declarada como miembro estático de otra clase. Al igual que otros miembros estáticos, tal clase es realmente una suspensión que usa la clase que contiene como su espacio de nombres, por ejemplo , la clase Goat declarada como miembro estático de la clase Rhino en el paquete pizza se conoce con el nombre pizza.Rhino.Goat .
package pizza;
public class Rhino {
...
public static class Goat {
...
}
}
Francamente, las clases estáticas son una característica bastante inútil porque las clases ya están divididas en espacios de nombres por paquetes. La única razón real concebible para crear una clase estática es que dicha clase tiene acceso a los miembros estáticos privados de su clase que contiene, pero creo que esto es una justificación bastante lamentable para que exista la característica de clase estática.
Una clase interna es una clase declarada como miembro no estático de otra clase:
package pizza;
public class Rhino {
public class Goat {
...
}
private void jerry() {
Goat g = new Goat();
}
}
Al igual que con una clase estática, la clase interna se conoce como calificada por su nombre de clase que contiene, pizza.Rhino.Goat , pero dentro de la clase que la contiene, se puede conocer por su nombre simple. Sin embargo, cada instancia de una clase interna está ligado a un caso particular de su clase que contiene: arriba, la cabra creado en Jerry , está implícitamente ligada a la Rhino ejemplo esta en Jerry . De lo contrario, hacemos explícita la instancia de Rhino asociada cuando instanciamos Goat :
Rhino rhino = new Rhino();
Rhino.Goat goat = rhino.new Goat();
(Observe que se refiere al tipo interno como solo Goat en la nueva sintaxis extraña : Java infiere el tipo que contiene de la parte de rinoceronte . Y, sí, el nuevo rinoceronte.Goat () también habría tenido más sentido para mí).
Entonces, ¿qué nos gana esto? Bueno, la instancia de la clase interna tiene acceso a los miembros de la instancia de la clase que lo contiene. Se hace referencia a estos miembros de instancia dentro de la clase interna solo a través de sus nombres simples, no a través de esto ( esto en la clase interna se refiere a la instancia de clase interna, no a la instancia de clase que contiene asociada):
public class Rhino {
private String barry;
public class Goat {
public void colin() {
System.out.println(barry);
}
}
}
En la clase interna, puede referirse a esto de la clase que lo contiene como Rhino.this , y puede usar esto para referirse a sus miembros, por ejemplo , Rhino.this.barry .
Una clase interna local es una clase declarada en el cuerpo de un método. Dicha clase solo se conoce dentro de su método contenedor, por lo que solo se puede instanciar y acceder a sus miembros dentro de su método contenedor. La ganancia es que una instancia de clase interna local está vinculada y puede acceder a las variables locales finales de su método contenedor. Cuando la instancia usa un local final de su método de contención, la variable retiene el valor que tenía en el momento de la creación de la instancia, incluso si la variable ha salido del alcance (esta es efectivamente la versión cruda y limitada de los cierres de Java).
Debido a que una clase interna local no es miembro de una clase o paquete, no se declara con un nivel de acceso. (Sea claro, sin embargo, que sus propios miembros tienen niveles de acceso como en una clase normal).
Si una clase interna local, se declara en un método de instancia, una instancia de la clase interna está ligada a la instancia en poder del método que contiene de esto en el momento de la creación de la instancia, por lo que los miembros de instancia de la clase que contiene son accesibles al igual que en una instancia clase interna Se crea una instancia de una clase interna local simplemente a través de su nombre, por ejemplo , la clase interna local Cat se instancia como nueva Cat () , no nueva this.Cat () como es de esperar.
Una clase interna anónima es una forma sintácticamente conveniente de escribir una clase interna local. Más comúnmente, una clase interna local se instancia como máximo solo una vez cada vez que se ejecuta su método de contención. Sería bueno, entonces, si pudiéramos combinar la definición de clase interna local y su instanciación única en una forma de sintaxis conveniente, y también sería bueno si no tuviéramos que pensar un nombre para la clase (cuanto menos inútil nombres que contiene su código, mejor). Una clase interna anónima permite estas dos cosas:
new *ParentClassName*(*constructorArgs*) {*members*}
Esta es una expresión que devuelve una nueva instancia de una clase sin nombre que extiende ParentClassName . No puede suministrar su propio constructor; más bien, se proporciona implícitamente uno que simplemente llama al superconstructor, por lo que los argumentos suministrados deben ajustarse al superconstructor. (Si el padre contiene múltiples constructores, el "más simple" se llama, "más simple" según lo determinado por un conjunto bastante complejo de reglas que no vale la pena aprender en detalle, solo preste atención a lo que le dicen NetBeans o Eclipse).
Alternativamente, puede especificar una interfaz para implementar:
new *InterfaceName*() {*members*}
Dicha declaración crea una nueva instancia de una clase sin nombre que extiende Object e implementa InterfaceName . De nuevo, no puede suministrar su propio constructor; en este caso, Java proporciona implícitamente un constructor sin argumentos y sin argumentos (por lo que nunca habrá argumentos de constructor en este caso).
Aunque no puede dar un constructor a una clase interna anónima, puede hacer cualquier configuración que desee utilizando un bloque inicializador (un bloque {} colocado fuera de cualquier método).
Sea claro que una clase interna anónima es simplemente una forma menos flexible de crear una clase interna local con una instancia. Si desea una clase interna local que implemente múltiples interfaces o que implemente interfaces mientras extiende alguna clase que no sea Object o que especifique su propio constructor, está atascado creando una clase interna local llamada regular.
No creo que la diferencia real se haya aclarado en las respuestas anteriores.
Primero para obtener los términos correctos:
La respuesta de Martin es correcta hasta ahora. Sin embargo, la pregunta real es: ¿Cuál es el propósito de declarar una clase anidada estática o no?
Utiliza clases anidadas estáticas si solo quieres mantener tus clases juntas si pertenecen tópicamente juntas o si la clase anidada se usa exclusivamente en la clase de cierre. No hay diferencia semántica entre una clase anidada estática y cualquier otra clase.
Las clases anidadas no estáticas son una bestia diferente. Similar a las clases internas anónimas, tales clases anidadas son en realidad cierres. Eso significa que capturan su alcance circundante y su instancia de cierre y lo hacen accesible. Quizás un ejemplo aclare eso. Ver este trozo de un contenedor:
public class Container {
public class Item{
Object data;
public Container getContainer(){
return Container.this;
}
public Item(Object data) {
super();
this.data = data;
}
}
public static Item create(Object data){
// does not compile since no instance of Container is available
return new Item(data);
}
public Item createSubItem(Object data){
// compiles, since 'this' Container is available
return new Item(data);
}
}
En este caso, desea tener una referencia de un elemento secundario al contenedor principal. Usando una clase anidada no estática, esto funciona sin algo de trabajo. Puede acceder a la instancia adjunta de Contenedor con la sintaxis Container.this
.
Más explicaciones hardcore a continuación:
Si observa los códigos de bytes de Java que el compilador genera para una clase anidada (no estática), podría ser aún más claro:
// class version 49.0 (49)
// access flags 33
public class Container$Item {
// compiled from: Container.java
// access flags 1
public INNERCLASS Container$Item Container Item
// access flags 0
Object data
// access flags 4112
final Container this$0
// access flags 1
public getContainer() : Container
L0
LINENUMBER 7 L0
ALOAD 0: this
GETFIELD Container$Item.this$0 : Container
ARETURN
L1
LOCALVARIABLE this Container$Item L0 L1 0
MAXSTACK = 1
MAXLOCALS = 1
// access flags 1
public <init>(Container,Object) : void
L0
LINENUMBER 12 L0
ALOAD 0: this
ALOAD 1
PUTFIELD Container$Item.this$0 : Container
L1
LINENUMBER 10 L1
ALOAD 0: this
INVOKESPECIAL Object.<init>() : void
L2
LINENUMBER 11 L2
ALOAD 0: this
ALOAD 2: data
PUTFIELD Container$Item.data : Object
RETURN
L3
LOCALVARIABLE this Container$Item L0 L3 0
LOCALVARIABLE data Object L0 L3 2
MAXSTACK = 2
MAXLOCALS = 3
}
Como puede ver, el compilador crea un campo oculto Container this$0
. Esto se establece en el constructor que tiene un parámetro adicional de tipo Contenedor para especificar la instancia de cierre. No puede ver este parámetro en la fuente, pero el compilador lo genera implícitamente para una clase anidada.
El ejemplo de Martin
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
sería compilado a una llamada de algo como (en bytecodes)
new InnerClass(outerObject)
En aras de la exhaustividad:
Una clase anónima es un ejemplo perfecto de una clase anidada no estática que simplemente no tiene un nombre asociado y no puede ser referenciada más tarde.
Creo que ninguna de las respuestas anteriores explica la diferencia real entre una clase anidada y una clase anidada estática en términos de diseño de aplicación:
Una clase anidada podría ser no estática o estática y en cada caso es una clase definida dentro de otra clase . Una clase anidada debe existir solo para servir es una clase de cierre , si una clase anidada es útil por otras clases (no solo el cierre), debe declararse como una clase de nivel superior.
Clase anidada no estática : está asociada implícitamente con la instancia de cierre de la clase que lo contiene, esto significa que es posible invocar métodos y acceder a variables de la instancia de cierre. Un uso común de una clase anidada no estática es definir una clase de Adaptador.
Clase anidada estática : no se puede acceder a la instancia de clase adjunta e invocar métodos en ella, por lo que se debe usar cuando la clase anidada no requiere acceso a una instancia de la clase adjunta. Un uso común de la clase anidada estática es implementar componentes del objeto externo.
Entonces, la principal diferencia entre los dos desde el punto de vista del diseño es: la clase anidada no estática puede acceder a la instancia de la clase contenedor, mientras que la estática no .
En términos simples, necesitamos clases anidadas principalmente porque Java no proporciona cierres.
Las clases anidadas son clases definidas dentro del cuerpo de otra clase adjunta. Son de dos tipos: estáticos y no estáticos.
Se tratan como miembros de la clase adjunta, por lo tanto, puede especificar cualquiera de los cuatro especificadores de acceso - private, package, protected, public
. No tenemos este lujo con clases de nivel superior, que solo se pueden declarar public
o paquetes privados.
Las clases internas, también conocidas como clases no apiladas, tienen acceso a otros miembros de la clase superior, incluso si se declaran privadas, mientras que las clases anidadas estáticas no tienen acceso a otros miembros de la clase superior.
public class OuterClass {
public static class Inner1 {
}
public class Inner2 {
}
}
Inner1
es nuestra clase interna estática y Inner2
es nuestra clase interna que no es estática. La diferencia clave entre ellos es que no puedes crear una Inner2
instancia sin un Outer donde puedes crear un Inner1
objeto de forma independiente.
¿Cuándo usarías la clase interna?
Piense en una situación en la que Class A
y Class B
están relacionados, Class B
necesita acceder a los Class A
miembros y Class B
solo está relacionado con ellos Class A
. Las clases internas entran en escena.
Para crear una instancia de clase interna, debe crear una instancia de su clase externa.
OuterClass outer = new OuterClass();
OuterClass.Inner2 inner = outer.new Inner2();
o
OuterClass.Inner2 inner = new OuterClass().new Inner2();
¿Cuándo usarías la clase interna estática?
Definiría una clase interna estática cuando sepa que no tiene ninguna relación con la instancia de la clase envolvente / clase superior. Si su clase interna no usa métodos o campos de la clase externa, es solo una pérdida de espacio, así que hágalo estático.
Por ejemplo, para crear un objeto para la clase anidada estática, use esta sintaxis:
OuterClass.Inner1 nestedObject = new OuterClass.Inner1();
La ventaja de una clase anidada estática es que no necesita un objeto de la clase que contiene / clase superior para funcionar. Esto puede ayudarlo a reducir la cantidad de objetos que su aplicación crea en tiempo de ejecución.
OuterClass.Inner2 inner = outer.new Inner2();
?
static inner
Es una contradicción en los términos.
Aquí hay diferencias y similitudes clave entre la clase interna de Java y la clase anidada estática.
¡Espero eso ayude!
Asociado con la instancia de la clase de cierre, por lo que para instanciarlo primero se necesita una instancia de la clase externa (observe el nuevo lugar de la palabra clave):
Outerclass.InnerClass innerObject = outerObject.new Innerclass();
No se puede definir cualquier miembros estáticos en sí
No se puede acceder a métodos o campos de instancia de clase externa
No está asociado con ninguna instancia de la clase de cierre. Para crear una instancia:
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
Según la documentación de Oracle, existen varias razones ( documentación completa ):
Es una forma de agrupar lógicamente clases que solo se usan en un lugar: si una clase es útil solo para otra clase, entonces es lógico incorporarla en esa clase y mantener las dos juntas. Anidar tales "clases auxiliares" hace que su paquete sea más ágil.
Aumenta la encapsulación: considere dos clases de nivel superior, A y B, donde B necesita acceso a los miembros de A que de otro modo se declararían privados. Al ocultar la clase B dentro de la clase A, los miembros de A pueden declararse privados y B puede acceder a ellos. Además, B puede ocultarse del mundo exterior.
Puede conducir a un código más legible y fácil de mantener: anidar clases pequeñas dentro de las clases de nivel superior coloca el código más cerca de donde se usa.
Creo que la convención que generalmente se sigue es esta:
Sin embargo, algunos otros puntos para recordar son:
Las clases de nivel superior y la clase anidada estática son semánticamente iguales, excepto que en el caso de la clase anidada estática puede hacer referencia estática a campos / métodos estáticos privados de su clase Outer [parent] y viceversa.
Las clases internas tienen acceso a las variables de instancia de la instancia de cierre de la clase Outer [parent]. Sin embargo, no todas las clases internas tienen instancias adjuntas, por ejemplo, las clases internas en contextos estáticos, como una clase anónima utilizada en un bloque inicializador estático, no las tienen.
La clase anónima, de manera predeterminada, amplía la clase principal o implementa la interfaz principal y no hay más cláusula para extender ninguna otra clase o implementar más interfaces. Entonces,
new YourClass(){};
medio class [Anonymous] extends YourClass {}
new YourInterface(){};
medio class [Anonymous] implements YourInterface {}
Siento que la gran pregunta que queda abierta ¿cuál usar y cuándo? Bueno, eso depende en gran medida del escenario con el que estés lidiando, pero leer la respuesta dada por @jrudolph puede ayudarte a tomar alguna decisión.
Clase anidada: clase dentro de clase
Tipos:
Diferencia:
Clase anidada no estática [Clase interna]
En la clase anidada no estática, el objeto de la clase interna existe dentro del objeto de la clase externa. Para que el miembro de datos de la clase externa sea accesible a la clase interna. Entonces, para crear objetos de clase interna, primero debemos crear objetos de clase externa.
outerclass outerobject=new outerobject();
outerclass.innerclass innerobjcet=outerobject.new innerclass();
Clase anidada estática
En la clase anidada estática, el objeto de la clase interna no necesita el objeto de la clase externa, porque la palabra "estática" indica que no es necesario crear el objeto.
class outerclass A {
static class nestedclass B {
static int x = 10;
}
}
Si desea acceder a x, escriba el siguiente método interno
outerclass.nestedclass.x; i.e. System.out.prinltn( outerclass.nestedclass.x);
La instancia de la clase interna se crea cuando se crea la instancia de la clase externa. Por lo tanto, los miembros y métodos de la clase interna tienen acceso a los miembros y métodos de la instancia (objeto) de la clase externa. Cuando la instancia de la clase externa queda fuera de alcance, también las instancias de la clase interna dejan de existir.
La clase anidada estática no tiene una instancia concreta. Simplemente se carga cuando se usa por primera vez (al igual que los métodos estáticos). Es una entidad completamente independiente, cuyos métodos y variables no tienen acceso a las instancias de la clase externa.
Las clases anidadas estáticas no están acopladas con el objeto externo, son más rápidas y no toman memoria de montón / pila, porque no es necesario crear una instancia de dicha clase. Por lo tanto, la regla general es tratar de definir una clase anidada estática, con el alcance más limitado posible (privado> = clase> = protegido> = público), y luego convertirla a clase interna (eliminando el identificador "estático") y aflojar el alcance, si es realmente necesario.
Hay una sutileza sobre el uso de clases estáticas anidadas que pueden ser útiles en ciertas situaciones.
Mientras que los atributos estáticos se instancian antes de que la clase se instancia a través de su constructor, los atributos estáticos dentro de las clases estáticas anidadas no parecen instanciarse hasta después de que se invoque el constructor de la clase, o al menos no hasta después de que los atributos se referencian por primera vez, incluso si están marcados como 'finales'.
Considere este ejemplo:
public class C0 {
static C0 instance = null;
// Uncomment the following line and a null pointer exception will be
// generated before anything gets printed.
//public static final String outerItem = instance.makeString(98.6);
public C0() {
instance = this;
}
public String makeString(int i) {
return ((new Integer(i)).toString());
}
public String makeString(double d) {
return ((new Double(d)).toString());
}
public static final class nested {
public static final String innerItem = instance.makeString(42);
}
static public void main(String[] argv) {
System.out.println("start");
// Comment out this line and a null pointer exception will be
// generated after "start" prints and before the following
// try/catch block even gets entered.
new C0();
try {
System.out.println("retrieve item: " + nested.innerItem);
}
catch (Exception e) {
System.out.println("failed to retrieve item: " + e.toString());
}
System.out.println("finish");
}
}
A pesar de que 'nested' e 'innerItem' están declarados como 'static final'. la configuración de nested.innerItem no tiene lugar hasta después de que se instancia la clase (o al menos no hasta después de que se hace referencia por primera vez al elemento estático anidado), como puede ver usted mismo comentando y descomentando las líneas a las que me refiero, encima. Lo mismo no es cierto para 'externalItem'.
Al menos esto es lo que estoy viendo en Java 6.0.
Los términos se usan indistintamente. Si desea ser realmente pedante al respecto, puede definir "clase anidada" para referirse a una clase interna estática, una que no tiene una instancia que la encierre. En código, puede tener algo como esto:
public class Outer {
public class Inner {}
public static class Nested {}
}
Sin embargo, esa no es realmente una definición ampliamente aceptada.
En el caso de crear una instancia, la instancia de la clase interna no estática se crea con la referencia del objeto de la clase externa en la que se define. Esto significa que tiene una instancia de cierre. Pero la instancia de clase interna estática se crea con la referencia de la clase externa, no con la referencia del objeto de la clase externa. Esto significa que no tiene instancia de cierre.
Por ejemplo:
class A
{
class B
{
// static int x; not allowed here…..
}
static class C
{
static int x; // allowed here
}
}
class Test
{
public static void main(String… str)
{
A o=new A();
A.B obj1 =o.new B();//need of inclosing instance
A.C obj2 =new A.C();
// not need of reference of object of outer class….
}
}
No creo que haya mucho que agregar aquí, la mayoría de las respuestas explican perfectamente las diferencias entre la clase anidada estática y las clases internas. Sin embargo, considere el siguiente problema cuando use clases anidadas vs clases internas. Como se menciona en un par de respuestas, las clases internas no se pueden instanciar sin una instancia de su clase de cierre, lo que significa que SOSTENEN un puntero a la instancia de su clase de cierre, lo que puede provocar un desbordamiento de memoria o una excepción de desbordamiento de pila debido al hecho de que el GC no podrá recolectar basura de las clases adjuntas incluso si ya no se usan. Para aclarar esto, verifique el siguiente código:
public class Outer {
public class Inner {
}
public Inner inner(){
return new Inner();
}
@Override
protected void finalize() throws Throwable {
// as you know finalize is called by the garbage collector due to destroying an object instance
System.out.println("I am destroyed !");
}
}
public static void main(String arg[]) {
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
// out instance is no more used and should be garbage collected !!!
// However this will not happen as inner instance is still alive i.e used, not null !
// and outer will be kept in memory until inner is destroyed
outer = null;
//
// inner = null;
//kick out garbage collector
System.gc();
}
Si elimina el comentario en // inner = null;
El programa aparecerá " ¡Estoy destruido! ", Pero si mantiene este comentario no lo hará.
La razón es que todavía se hace referencia a la instancia interna blanca GC no puede recopilarla y porque hace referencia (tiene un puntero a) la instancia externa no se recopila también. Tener suficientes de estos objetos en su proyecto y puede quedarse sin memoria.
En comparación con las clases internas estáticas, que no tienen un punto para la instancia de clase interna porque no está relacionada con la instancia, sino con la clase. El programa anterior puede imprimir " ¡Estoy destruido! " Si hace que la clase interna sea estática e instanciada conOuter.Inner i = new Outer.Inner();
La clase anidada es un término muy general: cada clase que no es de nivel superior es una clase anidada. Una clase interna es una clase anidada no estática. Joseph Darcy escribió una muy buena explicación sobre las clases anidadas, internas, de miembros y de alto nivel .
Ummm ... una clase interna ES una clase anidada ... ¿te refieres a clase anónima y clase interna?
Editar: Si en realidad quisiste decir interno vs anónimo ... una clase interna es solo una clase definida dentro de una clase como:
public class A {
public class B {
}
}
Mientras que una clase anónima es una extensión de una clase definida anónimamente, no se define una "clase real", como en:
public class A {
}
A anon = new A() { /* you could change behavior of A here */ };
Edición adicional:
Wikipedia afirma que hay una diferencia en Java, pero he estado trabajando con Java durante 8 años, y es la primera vez que escucho tal distinción ... sin mencionar que no hay referencias para respaldar la afirmación ... abajo línea, una clase interna es una clase definida dentro de una clase (estática o no), y anidada es solo otro término que significa lo mismo.
Hay una sutil diferencia entre la clase anidada estática y no estática ... básicamente las clases internas no estáticas tienen acceso implícito a los campos de instancia y a los métodos de la clase adjunta (por lo tanto, no se pueden construir en un contexto estático, será un compilador error). Las clases anidadas estáticas, por otro lado, no tienen acceso implícito a los campos y métodos de instancia, y PUEDEN construirse en un contexto estático.
Aprendizaje dirigido, que son novatos en Java y / o clases anidadas
Las clases anidadas pueden ser:
1. Clases anidadas estáticas.
2. Clases anidadas no estáticas. (también conocido como clases internas ) => Recuerde esto
1.Clases internas
Ejemplo:
class OuterClass {
/* some code here...*/
class InnerClass { }
/* some code here...*/
}
Las clases internas son subconjuntos de clases anidadas:
Especialidad de clase interna:
2. Clases anidadas estáticas:
Ejemplo:
class EnclosingClass {
static class Nested {
void someMethod() { System.out.println("hello SO"); }
}
}
Caso 1: Crear una instancia de una clase anidada estática de una clase que no incluye
class NonEnclosingClass {
public static void main(String[] args) {
/*instantiate the Nested class that is a static
member of the EnclosingClass class:
*/
EnclosingClass.Nested n = new EnclosingClass.Nested();
n.someMethod(); //prints out "hello"
}
}
Caso 2: Crear una instancia de una clase anidada estática de una clase adjunta
class EnclosingClass {
static class Nested {
void anotherMethod() { System.out.println("hi again"); }
}
public static void main(String[] args) {
//access enclosed class:
Nested n = new Nested();
n.anotherMethod(); //prints out "hi again"
}
}
Especialidad de clases estáticas:
Conclusión:
Pregunta: ¿Cuál es la principal diferencia entre una clase interna y una clase anidada estática en Java?
Respuesta: solo revise los detalles de cada clase mencionada anteriormente.
La clase interna y la clase estática anidada en Java son clases declaradas dentro de otra clase, conocida como clase de nivel superior en Java. En la terminología de Java, si declara una clase anidada estática, se llamará clase estática anidada en Java, mientras que las clases anidadas no estáticas simplemente se denominan Clase interna.
¿Qué es la clase interna en Java?
Cualquier clase que no sea un nivel superior o declarada dentro de otra clase se conoce como clase anidada y fuera de esas clases anidadas, las clases que se declaran no estáticas se conocen como clase interna en Java. Hay tres tipos de clases internas en Java:
1) Clase interna local: se declara dentro de un bloque de código o método.
2) Clase interna anónima: es una clase que no tiene nombre para hacer referencia e inicializada en el mismo lugar donde se crea.
3) Clase interna de miembro: se declara como miembro no estático de la clase externa.
public class InnerClassTest {
public static void main(String args[]) {
//creating local inner class inside method i.e. main()
class Local {
public void name() {
System.out.println("Example of Local class in Java");
}
}
//creating instance of local inner class
Local local = new Local();
local.name(); //calling method from local inner class
//Creating anonymous inner class in Java for implementing thread
Thread anonymous = new Thread(){
@Override
public void run(){
System.out.println("Anonymous class example in java");
}
};
anonymous.start();
//example of creating instance of inner class
InnerClassTest test = new InnerClassTest();
InnerClassTest.Inner inner = test.new Inner();
inner.name(); //calling method of inner class
}
//Creating Inner class in Java
private class Inner{
public void name(){
System.out.println("Inner class example in java");
}
}
}
¿Qué es la clase estática anidada en Java?
La clase estática anidada es otra clase que se declara dentro de una clase como miembro y se hace estática. La clase estática anidada también se declara como miembro de la clase externa y se puede hacer privada, pública o protegida como cualquier otro miembro. Uno de los principales beneficios de la clase estática anidada sobre la clase interna es que la instancia de la clase estática anidada no está asociada a ninguna instancia de cierre de la clase externa. Tampoco necesita ninguna instancia de la clase Outer para crear una instancia de clase estática anidada en Java .
1) Puede acceder a miembros de datos estáticos de clase externa, incluidos los privados.
2) La clase anidada estática no puede acceder al miembro o método de datos no estáticos (instancia) .
public class NestedStaticExample {
public static void main(String args[]){
StaticNested nested = new StaticNested();
nested.name();
}
//static nested class in java
private static class StaticNested{
public void name(){
System.out.println("static nested class example in java");
}
}
}
Ref: clase interna y clase estática anidada en Java con ejemplo
Creo que la gente aquí debería notar a Poster que: Static Nest Class solo es la primera clase interna. Por ejemplo:
public static class A {} //ERROR
public class A {
public class B {
public static class C {} //ERROR
}
}
public class A {
public static class B {} //COMPILE !!!
}
Entonces, resumir, la clase estática no depende de qué clase contiene. Entonces, no pueden en la clase normal. (porque la clase normal necesita una instancia).
Cuando declaramos una clase miembro estática dentro de una clase, se conoce como clase anidada de nivel superior o una clase anidada estática. Se puede demostrar de la siguiente manera:
class Test{
private static int x = 1;
static class A{
private static int y = 2;
public static int getZ(){
return B.z+x;
}
}
static class B{
private static int z = 3;
public static int getY(){
return A.y;
}
}
}
class TestDemo{
public static void main(String[] args){
Test t = new Test();
System.out.println(Test.A.getZ());
System.out.println(Test.B.getY());
}
}
Cuando declaramos una clase miembro no estática dentro de una clase, se conoce como clase interna. La clase interna se puede demostrar a continuación:
class Test{
private int i = 10;
class A{
private int i =20;
void display(){
int i = 30;
System.out.println(i);
System.out.println(this.i);
System.out.println(Test.this.i);
}
}
}
El siguiente es un ejemplo de static nested class
yinner class
:
OuterClass.java
public class OuterClass {
private String someVariable = "Non Static";
private static String anotherStaticVariable = "Static";
OuterClass(){
}
//Nested classes are static
static class StaticNestedClass{
private static String privateStaticNestedClassVariable = "Private Static Nested Class Variable";
//can access private variables declared in the outer class
public static void getPrivateVariableofOuterClass(){
System.out.println(anotherStaticVariable);
}
}
//non static
class InnerClass{
//can access private variables of outer class
public String getPrivateNonStaticVariableOfOuterClass(){
return someVariable;
}
}
public static void accessStaticClass(){
//can access any variable declared inside the Static Nested Class
//even if it private
String var = OuterClass.StaticNestedClass.privateStaticNestedClassVariable;
System.out.println(var);
}
}
OuterClassTest:
public class OuterClassTest {
public static void main(String[] args) {
//access the Static Nested Class
OuterClass.StaticNestedClass.getPrivateVariableofOuterClass();
//test the private variable declared inside the static nested class
OuterClass.accessStaticClass();
/*
* Inner Class Test
* */
//Declaration
//first instantiate the outer class
OuterClass outerClass = new OuterClass();
//then instantiate the inner class
OuterClass.InnerClass innerClassExample = outerClass. new InnerClass();
//test the non static private variable
System.out.println(innerClassExample.getPrivateNonStaticVariableOfOuterClass());
}
}
Creo que ninguna de las respuestas anteriores le da el ejemplo real de la diferencia entre una clase anidada y una clase anidada estática en términos de diseño de la aplicación. Y la principal diferencia entre la clase anidada estática y la clase interna es la capacidad de acceder al campo de instancia de clase externa.
Echemos un vistazo a los dos ejemplos siguientes.
Clase de anidamiento estático: un buen ejemplo del uso de clases anidadas estáticas es el patrón de construcción ( https://dzone.com/articles/design-patterns-the-builder-pattern ).
Para BankAccount utilizamos una clase anidada estática, principalmente porque
La instancia de clase de anidamiento estático podría crearse antes que la clase externa.
En el patrón del generador, el generador es una clase auxiliar que se utiliza para crear la cuenta bancaria.
public class BankAccount {
private long accountNumber;
private String owner;
...
public static class Builder {
private long accountNumber;
private String owner;
...
static public Builder(long accountNumber) {
this.accountNumber = accountNumber;
}
public Builder withOwner(String owner){
this.owner = owner;
return this;
}
...
public BankAccount build(){
BankAccount account = new BankAccount();
account.accountNumber = this.accountNumber;
account.owner = this.owner;
...
return account;
}
}
}
Clase interna: un uso común de las clases internas es definir un controlador de eventos. https://docs.oracle.com/javase/tutorial/uiswing/events/generalrules.html
Para MyClass, utilizamos la clase interna, principalmente porque:
La clase interna MyAdapter necesita acceder al miembro de la clase externa.
En el ejemplo, MyAdapter solo está asociado con MyClass. Ninguna otra clase está relacionada con MyAdapter. así que es mejor organizarlos juntos sin usar una convención de nombres
public class MyClass extends Applet {
...
someObject.addMouseListener(new MyAdapter());
...
class MyAdapter extends MouseAdapter {
public void mouseClicked(MouseEvent e) {
...// Event listener implementation goes here...
...// change some outer class instance property depend on the event
}
}
}
En primer lugar, no existe una clase llamada clase estática. El uso del modificador estático con clase interna (llamada clase anidada) dice que es un miembro estático de la clase externa, lo que significa que podemos acceder a él como con otros miembros estáticos y sin tener instancia de clase externa. (Que es el beneficio de la estática originalmente).
La diferencia entre usar la clase anidada y la clase interna regular es:
OuterClass.InnerClass inner = new OuterClass().new InnerClass();
Primero podemos crear instancias de Outerclass y luego podemos acceder a Inner.
Pero si la clase está anidada, la sintaxis es:
OuterClass.InnerClass inner = new OuterClass.InnerClass();
Que utiliza la sintaxis estática como implementación normal de la palabra clave estática.
El lenguaje de programación Java le permite definir una clase dentro de otra clase. Dicha clase se llama clase anidada y se ilustra aquí:
class OuterClass {
...
class NestedClass {
...
}
}
Las clases anidadas se dividen en dos categorías: estáticas y no estáticas. Las clases anidadas que se declaran estáticas se denominan clases anidadas estáticas. Las clases anidadas no estáticas se denominan clases internas. Una cosa que debemos tener en cuenta es que las clases anidadas no estáticas (clases internas) tienen acceso a otros miembros de la clase adjunta, incluso si se declaran privadas. Las clases anidadas estáticas solo tienen acceso a otros miembros de la clase adjunta si son estáticas. No puede acceder a miembros no estáticos de la clase externa. Al igual que con los métodos y variables de clase, una clase anidada estática está asociada con su clase externa. Por ejemplo, para crear un objeto para la clase anidada estática, use esta sintaxis:
OuterClass.StaticNestedClass nestedObject =
new OuterClass.StaticNestedClass();
Para crear una instancia de una clase interna, primero debe crear una instancia de la clase externa. Luego, cree el objeto interno dentro del objeto externo con esta sintaxis:
OuterClass.InnerClass innerObject = new OuterClass().new InnerClass();
¿Por qué usamos clases anidadas?
La diferencia es que una declaración de clase anidada que también es estática se puede instanciar fuera de la clase que la encierra.
Cuando tiene una declaración de clase anidada que no es estática, también conocida como clase interna , Java no le permitirá instanciarla, excepto a través de la clase adjunta. El objeto creado a partir de la clase interna está vinculado al objeto creado a partir de la clase externa, por lo que la clase interna puede hacer referencia a los campos de la externa.
Pero si es estático, entonces el enlace no existe, no se puede acceder a los campos externos (excepto a través de una referencia ordinaria como cualquier otro objeto) y, por lo tanto, puede crear una instancia de la clase anidada por sí misma.
Es bastante simple, comparando clases locales estáticas y clases internas no estáticas
Diferencias:
Clase local estática:
Solo puede acceder a miembros estáticos de la clase externa.
No se pueden tener inicializadores estáticos
No se puede acceder directamente desde fuera de la función donde se declara
He ilustrado varios posibles escenarios correctos y de error que pueden ocurrir en el código Java.
class Outter1 {
String OutStr;
Outter1(String str) {
OutStr = str;
}
public void NonStaticMethod(String st) {
String temp1 = "ashish";
final String tempFinal1 = "ashish";
// below static attribute not permitted
// static String tempStatic1 = "static";
// below static with final attribute not permitted
// static final String tempStatic1 = "ashish";
// synchronized keyword is not permitted below
class localInnerNonStatic1 {
synchronized public void innerMethod(String str11) {
str11 = temp1 +" sharma";
System.out.println("innerMethod ===> "+str11);
}
/*
// static method with final not permitted
public static void innerStaticMethod(String str11) {
str11 = temp1 +" india";
System.out.println("innerMethod ===> "+str11);
}*/
}
// static class not permitted below
// static class localInnerStatic1 { }
}
public static void StaticMethod(String st) {
String temp1 = "ashish";
final String tempFinal1 = "ashish";
// static attribute not permitted below
//static String tempStatic1 = "static";
// static with final attribute not permitted below
// static final String tempStatic1 = "ashish";
class localInnerNonStatic1 {
public void innerMethod(String str11) {
str11 = temp1 +" sharma";
System.out.println("innerMethod ===> "+str11);
}
/*
// static method with final not permitted
public static void innerStaticMethod(String str11) {
str11 = temp1 +" india";
System.out.println("innerMethod ===> "+str11);
}*/
}
// static class not permitted below
// static class localInnerStatic1 { }
}
// synchronized keyword is not permitted
static class inner1 {
static String temp1 = "ashish";
String tempNonStatic = "ashish";
// class localInner1 {
public void innerMethod(String str11) {
str11 = temp1 +" sharma";
str11 = str11+ tempNonStatic +" sharma";
System.out.println("innerMethod ===> "+str11);
}
public static void innerStaticMethod(String str11) {
// error in below step
str11 = temp1 +" india";
//str11 = str11+ tempNonStatic +" sharma";
System.out.println("innerMethod ===> "+str11);
}
//}
}
//synchronized keyword is not permitted below
class innerNonStatic1 {
//This is important we have to keep final with static modifier in non
// static innerclass below
static final String temp1 = "ashish";
String tempNonStatic = "ashish";
// class localInner1 {
synchronized public void innerMethod(String str11) {
tempNonStatic = tempNonStatic +" ...";
str11 = temp1 +" sharma";
str11 = str11+ tempNonStatic +" sharma";
System.out.println("innerMethod ===> "+str11);
}
/*
// error in below step
public static void innerStaticMethod(String str11) {
// error in below step
// str11 = tempNonStatic +" india";
str11 = temp1 +" india";
System.out.println("innerMethod ===> "+str11);
}*/
//}
}
}
item 22 : Favor static member classes over non static