El papel de la clase interna: se puede lograr indirectamente múltiples de herencia
de clases internas en Java se divide en cuatro categorías:
- clases internas estáticas clase interna estática (también llamada clase anidada)
- Los miembros de la clase interna miembro de la clase interna
- clase clase local internas locales interior
- Anónimo clases internas clase interna anónima
1, las clases internas estáticas
La forma más simple de las clases internas.
Cuando la definición de clase, más la palabra clave static .
Y clases externas no pueden tener el mismo nombre.
Se compilan en un nombre de archivo .class completamente separada es en forma de OuterClass $ InnerClass.class.
Se puede acceder sólo a los miembros estáticos y métodos estáticos de la clase externa , incluidos los miembros y métodos privados estáticas.
Generación de una clase interna manera objeto estático:
OuterClass.InnerClass OuterClass.InnerClass interior = new ();
clases internas estáticas utilizando el código:
package com.learnjava.innerclass;
class StaticInner
{
private static int a = 4;
// 静态内部类
public static class Inner
{
public void test()
{
// 静态内部类可以访问外部类的静态成员
// 并且它只能访问静态的
System.out.println(a);
}
}
}
public class StaticInnerClassTest
{
public static void main(String[] args)
{
StaticInner.Inner inner = new StaticInner.Inner();
inner.test();
}
}
2, los miembros de la clase interna
Los miembros de la clase interna se define en otra clase, pero no modifican la definición de estática.
Los miembros de la clase interna y clases internas estáticas se pueden comparar para variables miembro no estáticos y variables miembro estáticas.
Los miembros de la clase interna como una variable de instancia.
Se tiene acceso a todas sus variables y métodos de la clase externa miembro, ya sea estático o no estático pueden ser.
Crear una instancia de miembros de la clase en el interior de la parte interior de la clase externa:
this.new Innerclass ();
Crear una instancia de la clase interna fuera de la clase externa:
. (Nuevo Outerclass ()) nuevo Innerclass ();
miembros externos de acceso de la clase dentro de la clase:
Outerclass.this.member
Para más detalles, ver ejemplos de código:
class MemberInner
{
private int d = 1;
private int a = 2;
// 定义一个成员内部类
public class Inner2
{
private int a = 8;
public void doSomething()
{
// 直接访问外部类对象
System.out.println(d);
System.out.println(a);// 直接访问a，则访问的是内部类里的a
// 如何访问到外部类里的a呢？
System.out.println(MemberInner.this.a);
}
}
}
public class MemberInnerClassTest
{
public static void main(String[] args)
{
// 创建成员内部类的对象
// 需要先创建外部类的实例
MemberInner.Inner2 inner = new MemberInner().new Inner2();
inner.doSomething();
}
}
3, una clase interna parcial
definición de clase local interno en el método, es también menor que el alcance del método. Un tipo es la clase menos interno utilizado.
Al igual que las variables locales no pueden ser modificados públicos, protegidos, privados y estáticos.
Las variables locales sólo pueden ser el último tipo de métodos de acceso definidos.
definición de clase local interno en el método, que sólo se puede utilizar en el método, es decir, se genera solamente una instancia de clase interna parcial en la que el método y llamar a sus métodos.
class LocalInner
{
int a = 1;
public void doSomething()
{
int b = 2;
final int c = 3;
// 定义一个局部内部类
class Inner3
{
public void test()
{
System.out.println("Hello World");
System.out.println(a);
// 不可以访问非final的局部变量
// error: Cannot refer to a non-final variable b inside an inner
// class defined in a different method
// System.out.println(b);
// 可以访问final变量
System.out.println(c);
}
}
// 创建局部内部类的实例并调用方法
new Inner3().test();
}
}
public class LocalInnerClassTest
{
public static void main(String[] args)
{
// 创建外部类对象
LocalInner inner = new LocalInner();
// 调用外部类的方法
inner.doSomething();
}
}
4, una clase interna anónima
Anónimo clase interna no es el nombre de las clases internas locales, no utilizan la clase de palabras clave, se extiende, implementos, ningún constructor.
Clases internas anónimas heredan implícitamente una clase padre o implementan una interfaz.
Anonymous clases internas utilizan con más frecuencia, por lo general como un parámetro del método.
import java.util.Date;
public class AnonymouseInnerClass
{
@SuppressWarnings("deprecation")
public String getDate(Date date)
{
return date.toLocaleString();
}
public static void main(String[] args)
{
AnonymouseInnerClass test = new AnonymouseInnerClass();
// 打印日期：
String str = test.getDate(new Date());
System.out.println(str);
System.out.println("----------------");
// 使用匿名内部类
String str2 = test.getDate(new Date()
{
});// 使用了花括号，但是不填入内容，执行结果和上面的完全一致
// 生成了一个继承了Date类的子类的对象
System.out.println(str2);
System.out.println("----------------");
// 使用匿名内部类，并且重写父类中的方法
String str3 = test.getDate(new Date()
{
// 重写父类中的方法
@Override
@Deprecated
public String toLocaleString()
{
return "Hello: " + super.toLocaleString();
}
});
System.out.println(str3);
}
}
