1.内部类

1.概念

把类定义在另一个类的内部，该类就被称为内部类。广义上我们将内部类分为四种:成员内部类、静态内部类、方法（局部）内部类、匿名内部类。

/**
*	我是一个外部类（外部是相对内部而言）
*/
public class Outer{
	/**
	*	我是一个内部类
	*/
	class Inner{
	//...
	}
}

java内部类有什么好处？为什么需要内部类？

每个内部类都能独立继承一个（接口的）实现，所有无论外围类是否已经继承了某个（接口的）实现，对内部类都没有影响。

也就是说内部类拥有类的基本特征。

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

2.成员内部类

位于外部类成员位置的类

特点可以使用外部类中所有的成员变量和成员方法（包括private）。

class Outer {
      private int age = 20;
      
      class Inner {
          public void show() {
              System.out.println(age);
          }
      }
}
class Test {
      public static void main(String[] ages) {
      Outer.Inner oi = new Outer().new Inner();
          oi.show();
      }
  }

**注意：**如果我们的内部类不想被轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的方法来访问，要想访问只需要在外部类中定义一个public修饰的方法，间接调用。

**好处：**我们可以在这个public方法中增加一些判断语句，起到数据安全的作用。

class Outer {
      private class Inner {
          public void show() {
              System.out.println(“密码备份文件”);
          }
      }
      //使用getXxx()获取成员内部类，可以增加校验语句（文中省略）
      public Inner getInner() {
          return new Inner();
      }
     }

    public static void main(String[] args) {
          Outer outer = new Outer();
          Outer.Inner inner = outer.getInner();
          inner.show();
      }

3.静态内部类

这种被static所修饰的内部类，按位置分，属于成员内部类，但也可以称作静态内部类，也常叫嵌套内部类。不能使用外部类的非static成员变量和成员方法。

public class Outter {
      int age = 10;
      static int  age2 = 20;
      public Outter() {        
      }
       
      static class Inner {
          public void method() {
              System.out.println(age);//错误
              System.out.println(age2);//正确
          }
      }
  }
public class Test {
      public static void main(String[] args)  {
          Outter.Inner inner = new Outter.Inner();
          inner.method();
      }
  }

4.局部内部类

定义在一个方法或者一个作用域里面的类

特点：主要是作用域发生了变化，只能在自身所在方法和属性中被使用。

class Outer {
      private int age = 20;
      public void method() {
          final int age2 = 30;
          class Inner {
              public void show() {
                  System.out.println(age);
                  //从内部类中访问方法内变量age2，需要将变量声明为最终类型。
                  System.out.println(age2);
              }
          }
                    Inner i = new Inner();
                              i.show();
      }
  }

5.匿名内部类

一个没有名字的类，是内部类的简化写法。

java语言提供了一个没有名字的类,实现接口,创建了一个没有名字的类的对象。

interface Inner {
      public abstract void show();
}  
 
  class Outer {
      public void method(){
          new Inner() {
              public void show() {
                  System.out.println("HelloWorld");
              }
          }.show();
      }
  }
class Test {
      public static void main(String[] args)  {
          Outer o = new Outer();
                   o.method();
      }
  }

6.内部类的特点

内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否为 private 的。
内部类声明成静态的，就不能随便访问外部类的成员变量，仍然是只能访问外部类的静态成员变量。

意义：

  1. 封装性
  2. 实现多继承
  3. 用匿名内部类实现回调功能
    我们用通俗讲解就是说在Java中，通常就是编写一个接口，然后你来实现这个接口，然后把这个接口的一个对象作以参数的形式传到另一个程序方法中， 然后通过接口调用你的方法，匿名内部类就可以很好的展现了这一种回调功能
public interface Demo {
      void demoMethod();
  }
  
  public class MyDemo{
      public test(Demo demo){
          System.out.println("test method");
      }
}



public static void main(String[] args) {
          MyDemo md = new MyDemo();
           md.test(new Demo){
              public void demoMethod(){
                  System.out.println("具体实现接口")
              }
          }
      }
  }