Java内部类的基本解析

内部类

内部类的基本概念

　　所谓的内部类也就是在一个类的内部进行其他类结构的嵌套操作。

为什么要使用内部类？

　　这就要引用一句十分著名的一本书叫《Think in java》中的一句名言了——每个内部类都能独立的继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都是没有影响的。

　　因为内部类拥着类的一些基本特征，所以在实际问题中我们会遇到一些接口无法解决或者难以解决的问题，此时我们可以使用内部类继承某个具体的或者抽象的类，间接解决类无法多继承引起的一系列问题。

内部类的优点

优点：

• 内部类与外部类可以方便的访问彼此的私有域（包括私有方法和私有属性）
• 内部类是另外一种封装，对外部的其他类隐藏（出了外围类，其他类不可访问）
• 内部类可以实现java的单继承局限
• 内部类可以使用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
• 创建内部类对象的时刻并不依赖于外围对象的创建。

内部类的分类

从广义上讲，java内部类可以分成四大类：成员内部类，静态内部类，匿名内部类，局部内部类（方法内部类），一个一个来

成员内部类

• 成员内部类可以无条件访问外部类所有成员属性和成员方法（包括private成员和static成员）
• 成员内部类内部不允许任何ststic变量或者方法，正如方法中不能有任何的静态属性（成员对象与方法相关，静态属性和类有关），但可以定义常量。
• 当成员内部类拥有和外部类同名的成员变量或者方法的时，默认情况下访问的是内部类的成员和方法，如果需要访问外部类的同名成员，需要以一下的形式进行访问
• 外部类.this.成员变量
• 外部类.this.成员方法
• 在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过这个指向这个对象的引用来访问。
  
• 成员内部类是依附外部类的，要创建成员内部类的对象，前提是必须存在一个外部类的对象。
• 第一种方式：

  Outter outter = new Outter();
  Outter.Inner inner = outter.new Inner();
  //必须通过Outter对象来创建

• 第二种方式：

  Outter.inner inner = outter.getinnerinstance();

• 内部类可以拥有private访问权限、protected访问权限、public访问权限、默认访问权限以及包访问权限。如用private修饰，则只能在外部类的内部访问了。

 1 public class Outer {
 2     
 3     private int age = 99;
 4     String name = "Coco";
 5     public class Inner{
 6         String name = "Jayden";
 7         public void show() {
 8             System.out.println(Outer.this.name);
 9             System.out.println(name);
10             System.out.println(age);
11         }
12     }
13     public Inner getInnerClass() {
14         return new Inner();
15     }
16     public static void main(String[] args) {
17         Outer o = new Outer();
18         Inner in = o.new Inner();
19         in.show();
20     }
21 }

运行之后的结果是：

需要提醒的是编译上面的程序后，会发现产生了两个class文件

静态内部类

• 也是定义在另一个类里面的类，只不过在类前面加上一个static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，但可以通过 new 外部类().成员 的方式访问 。
• 静态内部类与非静态内部类有些不同，没有保存指向创建它的外部类的引用。这就是说明：
• 静态内部类的创建不需要依赖外部类可以直接创建，可以直接创建 内部类 对象名 = new 内部类();。
• .静态内部类不可以使用任何外部类的非static类（包括属性和方法），但可以存在自己的成员变量。
• 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；
• 如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

 1 public class Outer{
 2             private int age = 99;
 3             static String name = "Coco";
 4             public static class Inner{
 5                 String name = "Jayden";
 6                 public void show(){
 7                     System.out.println(Outer.name);
 8                     System.out.println(name);                  
 9                 }
10             }
11             public static void main(String[] args){
12                 Inner i = new Inner();
13                 i.show();
14             }
15         }

运行结果如下：

 方法内部类（局部内部类）

• 方法内部类不允许使用访问权限修饰符（public、private、protected）均不允许
• 方法内部类对外部是完全隐藏的，除了创建这个类的方法可以访问外，其他地方均不能访问（其他方法或者类都不知道有这个类的存在）。
• 方法内部类如果想要使用方法形参，该形参必须使用final声明（JDK8形参变为隐式final声明）
• 无法创建静态信息
• 可以直接访问方法内的局部变量和参数（有限制），但是不能更改
• 可以随意的访问外部类的任何信息。

   1 public class Outer {
   2 
   3     // 属性和方法
   4     private int outerVariable = 1;
   5     // 外部类定义的属性
   6     private int commonVariable = 2;
   7     // 静态的信息
   8     private static int outerStaticVariable = 3;
   9 
  10     // 成员外部方法
  11     public void outerMethod() {
  12         System.out.println("我是外部类的outerMethod方法");
  13     }
  14 
  15     // 静态外部方法
  16     public static void outerStaticMethod() {
  17         System.out.println("我是外部类的outerStaticMethod静态方法");
  18     }
  19 
  20     // 程序的入口
  21     public static void main(String[] args) {
  22         Outer outer = new Outer();
  23         outer.outerCreatMethod(100);
  24     }
  25 
  26     // 成员方法，内部定义局部内部类
  27     public void outerCreatMethod(int value) {
  28         // 女性
  29         boolean sex = false;
  30         // 局部内部类，类前不能有访问修饰符
  31         class Inner {
  32             private int innerVariable = 10;
  33             private int commonVariable = 20;
  34 
  35             // 局部内部类方法
  36             public void innerShow() {
  37                 System.out.println("innerVariable:" + innerVariable);
  38                 // 局部变量
  39                 System.out.println("是否男性:" + sex);
  40                 System.out.println("参数value:" + value);
  41                 // 调用外部类的信息
  42                 System.out.println("outerVariable:" + outerVariable);
  43                 System.out.println("内部的commonVariable:" + commonVariable);
  44                 System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
  45                 System.out.println("outerStaticVariable:" + outerStaticVariable);
  46                 outerMethod();
  47                 outerStaticMethod();
  48             }
  49         }
  50         // 局部内部类只能在方法内使用
  51         Inner inner = new Inner();
  52         inner.innerShow();
  53     }
  54 }

  运行后的结果是：

匿名内部类

• 一般使用匿名内部类的方法来编写时间监听代码
• 匿名内部类也是不能有访问修饰符和static修饰符的
• 匿名内部类是唯一一种没有构造器的类
• 是一种没有名字的方法内部类，因此特征和方法和方法内部类是一致的。
• 匿名内部类必须继承一个抽象类或者一个借口

定义一个借口

public interface IAnimal {
    
    void speak();
}

匿名内部类的使用

 1 public class Outer {
 2 
 3     public static IAnimal getInnerInstance(String speak) {
 4         return new IAnimal() {
 5             @Override
 6             public void speak() {
 7                 // TODO Auto-generated method stub
 8                 System.out.println(speak);
 9             }};
10     }
11     public static void main(String[] args) {
12         Outer.getInnerInstance("小猫喵喵喵").speak();
13     }
14 }

内部类与外部类的关系

• 对于非静态的内部类，内部类的创建依赖外部类的实例对象，在没有外部类实例之前是无法创建内部类的。
• 内部类可以直接访问外部类的元素（包括私有域）—外部类在内部类之前创建，创建内部类时会将外部类的对象传入
• 外部类可以通过内部类的引用间接访问内部类元素 – -要想访问内部类属性，必须先创建内部类对象
• 内部类是一个相对独立的个体，与外部类没有关系。

内部类的运行原理

。。饿了。。吃饭先。。