Java类成员之内部类

内部类含义：

在Java中允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

Inner class 一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。

Inner class的名字不能与包含它的外部类的类名相同。

创建内部类对象：

外部类名.内部类名变量名= new外部类名() .new内部类名();

创建静态内部类对象：

外部类名.内部类名变量名= new外部类名.内部类名();

成员内部类：

(static成员内部类和非static成员内部类)

成员内部类作为类成员用法：

1.和外部类不同，Inner class还可以声明为private或protected。

2.可以调用外部类的结构。

3.Inner class可以声明为static的，但此时就不能再使用外层类的

非static的成员变量。

成员内部类作为类用法：

1.可以在内部定义属性、方法、构造器等结构。

2.可以声明为abstract类，因此可以被其它的内部类继承。

3.可以声明为final的。

4.编译以后生成OuterClass$InnerClass.class字节码文件。

注意事项：

1.非static的成员内部类中的成员不能声明为static的。

2.只有在外部类或static的成员内部类中才可声明static成员。

3.外部类访问成员内部类的成员，需要“内部类.成员” 或“内部类对象.成员”的方式。

4.成员内部类可以直接使用外部类的所有成员，包括私有的数据。

5.当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的。

局部内部类用法：

1.只能在声明它的方法或代码块中使用，而且是先声明后使用。

除此之外的任何地方都不能使用该类。

2.但是它的对象可以通过外部方法的返回值返回使用，

返回值类型只能是局部内部类的父类或父接口类型。

局部内部类特点：

1.内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，

但是前面冠以外部类的类名和$符号，以及数字编号。

2.只能在声明它的方法或代码块中使用，而且是先声明后使用。

除此之外的任何地方都不能使用该类。

3.局部内部类可以使用外部类的成员，包括私有的。

4.局部内部类可以使用外部方法的局部变量，但是必须是final的。

这是由局部内部类和局部变量的声明周期不同所致。

5.局部内部类和局部变量地位类似，不能使用public、protected、defunct、private。

6.局部内部类不能使用static修饰，因此也不能包含静态成员。

7.要使用内部类都分成两步：定义内部类、创建内部类对象。

匿名内部类的前提：

存在一个类或者接口，这里的类可以是具体类也可以是抽象类。

匿名内部类对象格式：new 类名或者接口名() {重写方法;}

本质：是一个继承了类或者实现了接口的子类匿名对象

匿名内部类对象的使用：调用单个方法

匿名内部类特点：

1.匿名内部类必须继承父类或实现接口

2.匿名内部类只能有一个对象

3.匿名内部类对象只能使用多态形式引用

匿名内部类注意：

1.匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。

2.一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

 public class AnonymousInner {

   public static void main(String[] args) {

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

    //可以把两步骤合成一步

     //匿名内部类
      new Outer(); //匿名对象

     //定义一个匿名类对象
    new InnerObj() {
        //实现接口的方法
        public void test() {
          System.out.println("anonymous inner");
        }
     };

    //针对普通类，创建匿名内部类对象
     new InnerObject(10) {
       public void testObj() {
         System.out.println("testObj");
       }
     };

     //匿名内部类对象的使用
     new InnerObject(10) {
       public void testObj() {
         System.out.println("testObj");
       }
     }.testObj();

     //如果调用两次
     new InnerObject(10) {
       @Override
       public void testObj() {
         System.out.println("testObj");
       }
     }.testObj();

     InnerObject obj = new InnerObject(10) {
       @Override
       public void testObj() {
         System.out.println("testObj");
       }

       public void myOwn() {
         System.out.println("my own");
       }
     };
     obj.doWork();
     obj.testObj();

     //匿名内部类的弊端
     new InnerObject(10) {
       @Override
       public void testObj() {
         System.out.println("testObj");
       }

       public void myOwn() {
         System.out.println("my own");
       }
     }.myOwn();

   }

 }

 class Outer {
   class Inner {
     int i;
   }
 }

 interface InnerObj {
   void test();
 }
 class InnerObject{
   int i;
   public InnerObject(int i) {
     this.i = i;
   }
   public void testObj() {
     System.out.println("testObj");
   }

   public void doWork() {
     System.out.println("dowork");
   }
 }
 class Obj extends InnerObject{
   public Obj(int i) {
     super(i);
   }
   public void testObj() {
     System.out.println("test test");
   }
 }

 public class SyntaxDemo {
   public static void main(String[] args) {
     //测试外部类访问内部类成员
     OuterClass outerClass = new OuterClass();
     outerClass.testInnerAccess();
     OuterClass.StaticInner staticInner = new OuterClass.StaticInner();
   }
 }

 class OuterClass {
   private int i;
   private static double k;
   public void testInnerAccess() {
     //创建内部类对昂
     InnerClass innerClass = new InnerClass();
     System.out.println(innerClass.j);
   }

   public static void testAccessFromStaicInner() {
     int m = 100;
     System.out.println("testAccessFromStaicInner");
   }
   //通过给成员位置内部类加private权限修饰符,让内部类只能被外部类访问到

   private class InnerClass {
     int j = 100;
     //定义一个方法来测试一下
     public void testOuterPrivate() {
       System.out.println(i);
     }
   }

        //被static权限修饰符所修饰
   static class StaticInner {
      //静态上下文不能访问非静态的成员变量和成员方法
     // private  int j = i;

     public void testAccess() {
       //静态上下文不能访问非静态的成员变量和成员方法

       //访问外部类的静态成员
       System.out.println(k);

       //访问外部类中的静态方法
       testAccessFromStaicInner();
     }
   }
 }