疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

四种java内部类总结


 

         第一 成员内部类

  定义在另一个类的内部,而且与成员方法和属性平级叫成员内部类。

  1成员内部类中不能存在static关键字,即,不能声明静态属性、静态方法、静态代码块等。

  2在成员内部类中访问外部类的成员方法和属性,要使用“外部类名.this.成员方法”和“外部类名.this.成员属性”的形式

  3创建成员内部类的实例使用“外部类名.内部类名 实例名 = 外部类实例名.new 内部类构造方法(参数)”的形式。在创建内部类实例之前需要先创建外部类的实例对象。

  Java代码

  package test5;

  public class MyTest {

  public static void main(String[] args) {

  Outer outer=new Outer("test");

  Outer.Inner inner = outer.new Inner(20);

  }

  }

  class Outer{

  Outer(String str){

  }

  protected class Inner{

  public Inner(int a){

  }

  }

  }

  4成员内部类可以可以使用public,protected,default,private,static,final,abstract来修饰.当然了,被static修饰的内部类,是静态内部类。

  5内部类在编译之后生成一个单独的class文件,里面包含该类的定义,所以内部类中定义的方法和变量可以跟父类的方法和变量相同。例如上面定义的三个类的class文件分别是:MyTest.class、Outer.class和Outer$Inner.class三个文件。内部类的定义文件名形式是“外部类定义名$内部类定义名”,即Outer$Inner.class。该文件反编译之后的代码是:

  Java代码

  package test5;

  public class Outer$Inner

  {

  public Outer$Inner(Outer paramOuter, int a)

  {

  }

  }

  6外部类无法直接访问成员内部类的方法和属性,只能通过“内部类实例名.方法名(参数)”和“内部类实例名.属性名”的形式访问内部类的方法和属性

  Java代码

  package test5;

  public class MyTest {

  public static void main(String[] args) {

  Outer outer=new Outer("test");

  outer.test();

  }

  }

  class Outer{

  private Inner inner;

  Outer(String str){

  //创建内部类实例

  inner = new Inner(10);

  }

  public void test(){

  //只能通过实例访问方法和属性

  inner.print();

  }

  protected class Inner{

  public Inner(int a){

  }

  public void print(){

  System.out.println("Inner");

  }

  }

  }

  7与外部类平级的类继承内部类时,其构造方法中需要传入父类的实例对象。且在构造方法的第一句调用“外部类实例名.super(内部类参数)”。

  如:

  Java代码

  package test5;

  public class MyTest {

  public static void main(String[] args) {

  Outer outer = new Outer("test");

  new Extender(outer,10);

  }

  }

  class Outer{

  Outer(String str){}

  protected class Inner{

  public Inner(int a){

  }

  }

  }

  class Extender extends Outer.Inner{

  public Extender(Outer outer,int a){

  //外部类实例名.super(内部类参数列表)

  outer.super(a);

  }

  }

  第二 静态内部类

  使用static修饰的成员内部类叫静态内部类。

  1静态内部类更外部类没有任何关系,只是在生成类名和类定义时有影响。静态内部类可以看做是与外部类平级的类。使用方式与外部类平级的类完全相同。

  2静态内部类不能访问外部类的非静态的属性和方法。外部类不能访问内部类的非静态的属性和方法。

  3静态内部类创建实例的形式:外部类名.内部类名 实例名 = new外部类名.内部类名(参数)

  第三 局部内部类

  定义在代码块、方法体内、作用域(使用花括号“{}”括起来的一段代码)内的类叫局部内部类。

  1局部内部类只能在代码代码块、方法体内和作用域中使用(创建对象和使用类对象).

  如:

  Java代码

  package test5;

  public class MyTest {

  public static void main(String[] args) {

  }

  }

  class Outer{

  Outer(String str){}

  {

  class Inner{

  public Inner(int a){

  }

  }

  System.out.println("Inner.class.getName()=="+Inner.class.getName());

  }

  public void test(){

  //这是错误的,局部内部类只在本作用域中可见

  //System.out.println("Inner.class.getName()=="+Inner.class.getName());

  }

  }

  2局部内部类访问外部类的属性和方法使用“外部类名.this.属性名”和“外部类名.this.方法名(参数)”的形式

  3局部内部类访问作用域内的局部变量,该局部变量需要使用final修饰。

  4局部内部类的定义可以使用abstract修饰,声明为抽象类。

  第四 匿名内部类

  1匿名内部类定义和实例化形式如下:

  new父类构造方法(参数){

  //注:该方法名必须在父类中已经存在

  修饰符 返回参数类型 方法名(参数列表){

  }

  }

  2匿名内部类只能和new连用,用于创建一个实例。匿名内部类只能使用一次,创建实例之后,类定义会立即消失(想要多次使用就要用到反射的知识了)。

  3匿名内部类必须继承一个类(抽象的、非抽象的都可以)或者实现一个接口。如果父类(或者父接口)是抽象类,则匿名内部类必须实现其所有抽象方法。

  如:

  Java代码

  public class InnerClassTest {

  public static void main(String[] args) {

  //定义一个匿名内部类,并实例化对象

  Test test = new Test(){

  @Override

  public void print() {

  System.out.println("匿名内部类实现父类所有的抽象方法!");

  }

  };

  test.print();

  System.out.println("匿名内部类的类名:test.getClass().getName()=="+test.getClass().getName());

  System.out.println("父类的类名:Test.class.getName()=="+Test.class.getName());

  System.out.println("test.getClass().equals(Test.class)=="+test.getClass().equals(Test.class));

  System.out.println("test.getClass().getSuperclass().equals(Test.class)=="+test.getClass().getSuperclass().equals(Test.class));

  }

  }

  abstract class Test{

  public abstract void print();

  }

  运行结果:

  Java代码

  匿名内部类实现父类所有的抽象方法!

  匿名内部类的类名:test.getClass().getName()==test5.InnerClassTest$1

  父类的类名:Test.class.getName()==test5.Test

  test.getClass().equals(Test.class)==false

  test.getClass().getSuperclass().equals(Test.class)==true

  InnerClassTest$1.class文件反编译之后的结果如下,证明它确实是继承了父类:

  Java代码

  class InnerClassTest$1 extends Test

  {

  public void print()

  {

  System.out.println("匿名内部类实现父类所有的抽象方法!");

  }

  }

  4匿名内部类不能是抽象类,因为匿名内部类在定义之后,会立即创建一个实例。

  5匿名内部类不能定义构造方法,匿名内部类没有类名,无法定义构造方法,但是,匿名内部类拥有与父类相同的所有构造方法。

  6匿名内部类中可以定义代码块,用于实例的初始化,但是不能定义静态代码块。

  如下:

  Java代码

  public class InnerClassTest {

  public static void main(String[] args) {

  //定义一个匿名内部类,并实例化对象

  Test test = new Test(){

  {

  System.out.println("匿名内部类的代码块");

  }

  public void print(){

  System.out.println("匿名内部类的print方法");

  }

  };

  test.print();

  }

  }

  class Test{

  public void print(){

  System.out.println("class Test的print方法");

  }

  }

  输出结果为:

  Java代码

  匿名内部类的代码块

  匿名内部类的print方法

  7匿名内部类中可以定义新的方法和属性(不能使用static修饰),但是无法显式的通过“实例名.方法名(参数)”的形式调用,因为使用new创建的是“上转型对象”。

  注:

  上转型对象特点:

  <!--[if !supportLists]-->① <!--[endif]-->父类声明指向子类对象,形式:

  父类名(父接口名) 上转型实例名 = new 子类构造方法(参数);

  <!--[if !supportLists]-->② <!--[endif]-->子类可以重写父类的方法,上转型实例调用的方法只能是子类重写父类的方法或者父类的方法,不能调用子类独有的方法。

  <!--[if !supportLists]-->③ <!--[endif]-->上转型对象可以强制转换成子类对象:形式:子类名 实例名 = (子类名)上转型对象;

  转换成子类对象之后,与“new 子类构造方法(参数)”形式定义的对象无区别。

  虽然不能通过“实例名.方法名(参数)”的形式调用子类独有的方法,但是可以通过反射来调用:

  Java代码

  package test5;

  import java.lang.reflect.InvocationTargetException;

  import java.lang.reflect.Method;

  public class InnerClassTest {

  public static void main(String[] args)

  throws SecurityException, NoSuchMethodException,

  IllegalArgumentException, IllegalAccessException,

  InvocationTargetException {

  //定义一个匿名内部类,并实例化对象

  Test test = new Test(){

  //匿名内部类中可以定义属性

  private int a;

  //匿名内部类中可以定义方法

  public void xxx() {

  System.out.println("xxx方法");

  }

  //匿名内部类中可以重写父类的方法

  public void print() {

  a = 10;

  }

  };

  //通过反射调用子类方法

  Class c = test.getClass();

  Method m = c.getMethod("xxx");

  m.invoke(test);

  }

  }

  class Test{

  public void print(){

  System.out.println("父类方法");

  }

  }

  8匿名内部类访问外部类的局部变量,则该局部变量需要使用final声明。匿名内部类中访问外部类的成员方法和属性使用“外部类名.this.方法名(参数)”和“内部类名.this.属性名”的形式。

  Java代码

  package test5;

  public class InnerClassTest {

  private int a;

  public static void main(String[] args) {

  new InnerClassTest().go();

  }

  public void go(){

  a = 100;

  //外部类的局部变量

  final int b=10;

  Test test = new Test(){

  public void print() {

  //匿名内部类访问外部类的属性

  System.out.println("InnerClassTest.this.a=="+InnerClassTest.this.a);

  //匿名内部类中访问外部类的局部变量

  System.out.println("b=="+b);

  }

  };

  test.print();

  }

  }

  abstract class Test{

  public abstract void print();

  }

  9匿名内部类不能重写父类的静态方法。