内部类

内部类

　　内部类（inner class）是定义在另一个类中的类，为什么要使用内部类呢？其主要原因有以下三点：

　　1.内部类方法可以访问外部类的所有数据。

　　2.内部类可以对同一个包中的其他类隐藏起来。

　　3.当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷。

1.使用内部类访问对象状态

 （1）内部类调用外部类，访问外部类中与内部类同名的实例变量用 外部类名.this.变量名                            

 若不同名可以直接访问。

　　只有内部类可以被private修饰，常规类只能被public default修饰

　　内部类的对象有一个隐式引用（这个引用在内部类的定义中是不可见的），它引用了实例化该内部类对象的外围类对象。

 编译器为了引用外部类，生成了一个附加的实例域this$0。

　　编译器在外围类添加静态方法access$100。

　　这样内部类与常规类比起来就具有了额外的访问特权，而虚拟机对此并不了解。

2.内部类的特殊语法规则

　　使用外围类引用的正规语法：

　　OuterClass.this

　　可以采用下列语法格式更加明确地编写内部对象的构造器：

　　OuterObject.new InnerClass(construction parameters)

　　在外围类的作用域之外，可以这样引用内部类：

　　OuterClass.InnerClass

4.局部内部类

 不需要修饰

　　可以在一个方法中定义局部类。

　　局部类不能用public或private访问说明符进行声明，它的作用域被限定在声明该局部类的块中。

 局部类优势1对外部完全隐藏2能访问外围类和局部变量，但局部变量必须被声明为final

5.匿名内部类

　　假如只创建这个类的一个对象，就不必为它命名了，这种类被称为匿名内部类。

　　通常的语法格式为：

　　new SuperType(construction parameters)　{　}

　　SuperType可以是类也可以是接口。

　　所以匿名类不能有构造器。

6.静态内部类

　　有时候使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围类对象。为此，可以将内部类声明为static，以便取消产生的引用。

 静态内部类可以用public,protected,private修饰静态内部类中可以定义静态或者非静态的成员

　　即public static class ClassName

　　只有内部类可以声明为static。

　　静态内部类的对象除了没有外围类对象的引用特权外，与其他内部类完全一样。

　　注意，声明在接口中的内部类自动成为public和static。

静态内部类1

public class Outer{

 private static String info="hello world";

 private int i=5;

static class Inner{

 //private int j=i; 静态内部类不能访问外部类中的非静态成员

 int i1=new Outer().i; //但可以通过外部类的实例访问

 public static void print(){

  System.out.println(info);//静态成员被直接调用

 }

}

public void fun(){

 Inner.print();//也可以 new Inner().print()同级函数可以直接new同级内部类的对象

 

}

public static void main(String a[]){

 Outer.Inner inner=new Outer.Inner(); //调用静态内部类的方法

 inner.print();

}

}

静态内部类2

class Person{

  private static  String name="Person";

  private int i=1;

  static class Body{

   private static String name="body";

   static class Heart{

    private static String name="heatt";

    static class HeartRoom{

     private static String name="heartroom";

    public static void show(){

     System.out.println("name="+new Person().i+name);

    }     }      }    }   } 

class Demo102{

public static void main(String a[]){

 Person.Body.Heart.HeartRoom.show();

}

}

局部内部类

public class Outerr{

 private String info="hello world";

 private int i=5;

 public void fun(final int temp){

  public class Inner{

   int i1=i;

   public void print(){

    System.out.println(info);

    System.out.println(temp);

    System.out.println(i1);

   }

  }

  new Inner().print();

 }

 public static void main(String a[]){

  Outerr outer=new Outerr();

  outer.fun(200);

 }

}

局部内部类2

class TestPartClassDemo05{

 public void show(final String name){

  final int i=5;

  class Inner{

   //private String name="inner";

   public void display(){

    //String name="display";

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

    //System.out.println("this.name="+this.name);

    //在内部类中访问外部类的局部变量时，这个局部变量必须声明为常量

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

   }

  }

  new Inner().display();//重要

 }

 public static void main(String[] args){

  TestPartClassDemo05 tpcd=new TestPartClassDemo05();

  tpcd.show("张三");

 }

}