java 嵌套类 继承_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);

}

}

参考资料：