java嵌套类
java有四种嵌套类：
静态内部类，成员内部类，局部内部类，匿名内部类
1)静态内部类：
（1）类的申明加上staitc关键字。一般用public修饰
（2）只能访问外部类的静态变量和静态方法。不能访问成员变量和成员方法。
（3）生成静态类对象的方式：
OuterClass.InnerClass inner = new OuterClass.InnerClass();
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）成员内部类：
外部类的成员，必须先创建了外部类，才能创建成员内部类
1）可以访问外部类的所有成员和方法，不管是静态或者非静态。
2）不能有static的变量和方法。
3）在外部类里面创建成员内部类的实例：
this.new Innerclass();
在外部类之外创建内部类的实例：
(new Outerclass()).new Innerclass();
在内部类里访问外部类的成员：
Outerclass.this.member
package com.learnjava.innerclass;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）局部内部类：
定义在方法里面，
(1)不能有public，private，protect，和static修饰。
(2)只能访问外部类的fina局部变量。
(3)局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。
package com.learnjava.innerclass;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)匿名类：
(1)没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。
(2)匿名内部类使用得比较多，通常是作为一个方法参数。
package com.learnjava.innerclass;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);
}
}
参考资料：
(1)http://android.blog.51cto.com/268543/384844
(2)http://www.cnblogs.com/mengdd/archive/2013/02/08/2909307.html
以上是 java嵌套类 的全部内容， 来源链接： utcz.com/z/393996.html
