JavaSE---内部类

内部类

什么是内部类

把类定义在另一个类的内部，该类就被称为内部类。

如果在类 Outer 的内部再定义一个类 Inner，此时类 Inner 就称为内部类（或称为嵌套类），而类 Outer 则称为外部类（或称为宿主类）。

内部类的分类

内部类一般来说包括这四种：

成员内部类包括私有内部类和静态内部类

1.成员内部类

成员内部类——就是位于外部类成员位置的类

/*
外部类
 */
public class Outer {
    //外部类成员
    private int age = 20;
    //成员内部类
    class Inner {
        int num = 10;
        public void show() {
            System.out.println(age);
            //在内部类中可以直接使用外部类中成员变量，方法，以至于私有的成员
            System.out.println(num);
        }
    }
    
//TEST    
    public class Test {
    public static void main(String[] args) {
        //如何让创建内部类对象，先创建外部类对象
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

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

private修饰内部类

如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个public修饰的方法，间接调用。这样做的好处就是，我们可以在这个public方法中增加一些判断语句，起到数据安全的作用。

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

//TEST
    public static void main(String[] args) {
          Outer outer = new Outer();//创建外部类对象
          Outer.Inner inner = outer.getInner();
          inner.show();
      }

2.静态内部类

这种被 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);//正确
          }
      }
  }

//TEST
  public class Test {
      public static void main(String[] args)  {
          Outter.Inner inner = new Outter.Inner();
          inner.method();
      }
  }

3.局部内部类

局部内部类——就是定义在一个方法或者一个作用域里面的类
特点：主要是作用域发生了变化，只能在自身所在方法和属性中被使用

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();
      }
  }

4.匿名内部类

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

interface Inner {
      public abstract void show();
}  //接口
 
  class Outer {
      public void method(){
          new Inner() {//java为接口，抽象类提供了一个没有名字的类，让这个类实现接口或继承抽象类
              @Override
              public void show() {
                  System.out.println("HelloWorld");
              }
          }.show();
      }
  }

//TEST
 class Test {
      public static void main(String[] args)  {
          Outer o = new Outer();
                   o.method();
      }
  }

内部类的特点

内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。

内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否为 private 的。

内部类声明成静态的，就不能随便访问外部类的成员变量，仍然是只能访问外部类的静态成员变量。

内部类的意义

1.封装性

我们将一些实现细节,封装到内部类中,不能随便访问,内部类可以直接访问外部类的成员.

2.实现多继承

java语言不能直接多继承

支持继承的传递性

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("具体实现接口")
              }
          }
      }
  }

4.解决继承及实现接口出现同名方法的问题

//编写一个接口 
Demo  public interface Demo {
      void test();
  }
//编写一个类 
MyDemo 
 public class MyDemo {
      public void test() {
          System.out.println("父类的test方法");
      }
      
  }

public class DemoTest extends MyDemo  {

      private class inner implements Demo {
          public void test() {
              System.out.println("接口的test方法");
          }
      }

     public Demo getIn() {
          return new inner();
      }
}