Java学习（十三）内部类

内部类的作用：

1、内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。

2、内部类成员可以直接访问外部类的私有数据，因为内部类被当成外部类成员，同一个类的成员之间可以相互访问。但外部类不能访问内部类的实现细节，例如内部类的属性。

3、匿名内部类适合用于创建哪些仅需要一次使用的类。

4、只要把一个类放在另一个类内部定义就是内部类，包括类中的任何位置，甚至在方法中也可以定义内部类（方法里定义的内部类被称为局部内部类）。局部内部类和匿名内部类不是类成员，一般内部类都被作为成员内部类，它是一种与属性、方法、构造器和初始化代码块相似的类成员。

5、成员内部类分为静态内部类和非静态内部类。

6、非静态内部类中不能有静态属性、静态方法、静态代码块，否则会引发编译错误。

7、如果使用static来修饰一个内部类，则这个内部类变成是外部类类相关的，属于整个外部类，而不是单独属于外部类的某个对象。(static关键字的作用是把类的成员变成类相关，而不是实例相关，即static修饰成员是属于整个类，而不是属于单个对象。外部类的上一级程序单元是包，所以不可使用static修饰外部类；而内部类的上一级程序单元是外部类，使用static修饰可以讲内部类变成外部类相关，而不是外部类实例相关。因此static关键字不可以修饰外部类，可以修饰内部类)

8、因为非静态内部类的对象必须寄存在外部类的对象里，因此创建非静态内部类对象之前，必须先创建其外部类的对象。在外部类以外的地方创建非静态内部类实例的语法如下：

OutClass.InnerClass in = new OutClass().new InnerClass();

9、局部内部类的上一级程序单元是方法，因此局部内部类不可以用static修饰，也不可以有任何权限修饰符修饰。

10、匿名内部类适合创建只需要一次使用的类，创建匿名内部类时会立即创建一个该类的实例，这个类定义立即消失，匿名内部类不能重复使用。

1）匿名内部类必须继承一个父类，获实现一个接口，但最多只能继承一个父类，获实现一个接口；

2）匿名内部类不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建匿名内部类的对象。因此不允许将匿名内部类定义成抽象类；

3）匿名内部类不能定义构造器，因为匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以定义实例化初始化快，通过实例化初始化完成构造器需要完成的事情。

例子1：非静态内部类访问外部类的实例属性
package cn.com.postel.wbb.crazyJava.innerClass;

public class Cow {
       private double weight ;
      
       public Cow() {}
      
       public Cow(double weight) {
             this.weight = weight;
      }
      
       public void test() {
            CowLeg cl = new CowLeg(1.12, "黑白相间" );
            cl.info();
      }
      
       public static void main(String[] args) {
            Cow cow = new Cow(378.9);
            cow.test();
      }
      
       //非静态内部类
       private class CowLeg {
             private double length ;
             private String color ;
             public CowLeg(){}
            
             public CowLeg(double length, String color) {
                   this.length = length;
                   this.color = color;
            }
            
             public double getLength() {
                   return length ;
            }
            
             public void info() {
                  System. out.println("当前牛腿的颜色是：" + color + ",高：" + length);
                   //访问外部类属性
                  System. out.println("本牛腿所在奶牛重：" + weight);
            }
            
             public void setLength( double length) {
                   this.length = length;
            }
             public String getColor() {
                   return color ;
            }
             public void setColor(String color) {
                   this.color = color;
            }
      }
}


例子2：区分外部类、内部类、局部变量同名的变量
class OutClass
{
    private String val = " 外部类属性 ";
    class InnerClass
    {
        private String val = "内部类属性 ";
        public void info()
       {
           String val = "局部变量" ;
            //访问外部类属性使用类名 .this.属性名
           System. out.println(OutClass.this.val);
            //访问内部类属性使用this.属性名
           System. out.println(this.val);
            //访问局部变量
           System. out.println(val);
       }
    }
    public void test()
    {
       InnerClass in = new InnerClass();
       in.info();
    }
    
    public static void main(String[] args)
    {
       OutClass out = new OutClass();
       out.test();
    }
}

例子3：外部类访问非静态内部类类成员
package cn.com.postel.wbb.crazyJava.innerClass;

public class OutAcessInner {
       private String outParam = "HAHA";

       class Inner {
             private String name = "wbb";

             private void info() {
                   // 非静态内部类可以直接访问外部类的成员
                  System. out.println("外部类成员变量outParam的属性值：" + outParam);
            }
      }

       public static void main(String[] args) {
            Inner inner = new OutAcessInner().new Inner();
             // 外部类不可直接访问内部类的成员，下列输出语句将发生变异错误
             // System.out.println(name);
             // 外部类访问非静态内部类类成员必须显示创建内部类对象(首先要创建外部类的对象)
            System. out.println("内部类成员变量name的属性值：" + inner.name);
            inner.info();
      }
}

例子4：静态内部类不能访问外部类的实例成员，只能访问外部类的类成员。
package cn.com.postel.wbb.javaextends;

public class TestStaticInnerClass {
    private int param1 = 1;
    private static int param2 = 2;

    static class StaticInnerClass {
        // 静态内部类可以包含静态属性
        private static int param3 = 3;

        // 访问外部类属性
        public void accessOuterParam() {
            // 静态内部类可以访问外部类的静态属性
           System. out.println(param2);
            // 静态内部类不可以访问外部类的实例属性
            // System.out.println(param1);
            // 静态内部类访问外部类的实例属性需要通过实例访问
           System. out.println(new TestStaticInnerClass().param1);
       }
    }
}