内部类的区分

内部类分别有成员内部类、局部内部类、匿名内部类、静态内部类，接下来将分别介绍。

成员内部类

  • 就是位于外部类成员位置的类。与外部类的属性、方法并列。
  • 成员内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为private，但是对于处于其内部的内部类还是可见的。）
  • 用成员内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。
    注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

  1. 代码例子

    1. public class Demo1 {
    2.  innerclass in=new innerclass(); //在成员内部类所在的外类中实例化成员内部类
    3.  public void outf() {
    4.      in.inf();  //因为in是成员内部类的实例化，所以才可以调用
    5.  }
    6.  class innerclass{//成员内部类
    7.      int y=0;
    8.      public innerclass() {//成员内部类的构造方法
    10.      }
    11.      public void inf() {
    12.          System.out.println("内部类方法y="+y);
    13.      }
    14.  }
    15.  public static void main(String[] args) {
    16.      Demo1 iDemo1=new Demo1();
    17.      iDemo1.outf();
    19.      Demo1.innerclass j= iDemo1.new innerclass();  //非外部类位置成员内部类实例化的方法（即首先要实例化一个外部类）
    20.      Demo1.innerclass k=new Demo1().new innerclass(); //实例化外部类和构造内部类一起写
    21.      j.inf();
    22.  }
    23. }

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

    局部内部类

  • 定义在一个方法或者一个作用域里面的类。
  • 局部内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的。
  1. 代码例子 ```java public class Demo2 { public outinterface action(String x) {//要把这个类返回出去，就需要通过接口，因为内部类在外部作用域中不存在
    1.  class innerclass2 implements outinterface{
    2.      public innerclass2(String s) {
    3.          s = x;
    4.          System.out.println(s);
    5.      }
    6.  }
    7.  return new innerclass2("do");
    } public static void main(String[] args) {
    1.  Demo2 demo2=new Demo2();
    2.  demo2.action("局部内部类");
    } } interface outinterface{ //专门用来给局部内部类做向上转型的父接口的操作

}

  1. 局部内部类只能在所在的方法体作用域内进行实例化，而如果要在所在方法体返回该类，就要通过接口向上转型的操作。（如同上处代码）<br />2. 作用<br />在某些情况下，某些业务逻辑需要临时处理，这些业务逻辑只在这里使用又可以封装成一个类的话，而又没必要重新建个文件，所以可以这写一个局部内部类来处理。然后，在我的记忆中，java代理模式中有用到局部内部类，在方法中直接实现接口，返回代理对象，简单而又方便。
  2. <a name="60fc1783"></a>
  3. ### 静态内部类
  4. 静态字段的内部类，和静态方法并列。
  6. 1. 代码例子
  7. ```java
  8. public class Demo3 {
  9.     static int x=100; 
  10.     static class innerclass3 {
  11.         void action() {
  12.             x=1;  //x必须是静态字段
  13.         }
  14.         public static void main(String[] args) {
  15.             System.out.println("我是静态内部类");
  16.         }
  17.     }
  18. }
  1. 作用
    提供调试作用。我将main方法写在静态内部类中，生成.class文件后，调试代码在静态内部类当中，当我删除静态内部类后，其他人仍然可以使用我的外部类。

    匿名内部类

  • 一个没有名字的类，是内部类的简化写法。
  • 本质：其实是继承该类或者实现接口的子类匿名对象。

  1. 代码例子

    1. //代码示例一
    2. public class Demo4 {
    3.  public Outinterface2 action() {
    4.      return new Outinterface2() {   //②
    5.          private int i = 0;
    6.          public int getvalue() {
    7.              return i;
    8.          }
    9.      };
    10.  }
    11. }
    12. interface Outinterface2 {
    13. }
    14. class innerclass2 implements Outinterface2{//①
    15.  private int i = 0;
    16.  public int getvalue() {
    17.      return i;
    18.  }
    19. }
    1. //代码示例二
    2. interface Inner {
    3.    public abstract void show();
    4. }
    6. class Outer {
    7.    public void method(){
    8.        new Inner() {
    9.            public void show() {
    10.                System.out.println("HelloWorld");
    11.            }
    12.        }.show();
    13.    }
    14. }
    16. class Test {
    17.    public static void main(String[] args)  {
    18.        Outer o = new Outer();
    19.        o.method();
    20.    }
    21. }
    22. //如果匿名内部类中有多个方法又该如何调用呢？    
    23. Inter i = new Inner() {  //多态，因为new Inner(){}代表的是接口的子类对象
    24.    public void show() {
    25.    System.out.println("HelloWorld");
    26.    }
    27. };

    上述代码①和②的作用是相同的。由此也可以解释一下匿名内部类的作用。

  2. 作用
    我们在开发的时候，会看到抽象类，或者接口作为参数。而这个时候，实际需要的是一个子类对象。如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

    为什么使用内部类

    一、封装性

    作为一个类的编写者，我们很显然需要对这个类的使用访问者的访问权限做出一定的限制，我们需要将一些我们不愿意让别人看到的操作隐藏起来，如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个public修饰的方法，间接调用。

    1. public interface Demo {
    2.    void show();
    3. }
    5. class Outer {
    6.    private class test implements Demo {
    7.        public void show() {
    8.            System.out.println("密码备份文件");
    9.        }
    10.    }
    12.    public Demo getInner() {
    13.        return new test();
    14.    }
    16. }

    二、实现多继承

    我们之前的学习知道，java是不可以实现多继承的，一次只能继承一个类，我们学习接口的时候，有提到可以用接口来实现多继承的效果，即一个接口有多个实现，但是这里也是有一点弊端的，那就是，一旦实现一个接口就必须实现里面的所有方法，有时候就会出现一些累赘，但是使用内部类可以很好的解决这些问题。

    1. public class Demo1 {
    2.    public String name() {
    3.        return "BWH_Steven";
    4.    }
    5. }
    7. public class Demo2 {
    8.    public String email() {
    9.        return "xxx.@163.com";
    10.    }
    11. }
    13. public class MyDemo {
    14.    private class test1 extends Demo1 {
    15.        public String name() {
    16.            return super.name();
    17.        }
    18.    }
    20.    private class test2 extends Demo2  {
    21.        public String email() {
    22.            return super.email();
    23.        }
    24.    }
    26.    public String name() {
    27.        return new test1().name();
    28.    }
    30.    public String email() {
    31.        return new test2().email();
    32.    }
    34.    public static void main(String args[]) {
    35.        MyDemo md = new MyDemo();
    36.        System.out.println("我的姓名:" + md.name());
    37.        System.out.println("我的邮箱:" + md.email());
    38.    }
    39. }

    我们编写了两个待继承的类Demo1和Demo2，在MyDemo类中书写了两个内部类，test1和test2两者分别继承了Demo1和Demo2类，这样MyDemo中就间接的实现了多继承。

    三、用匿名内部类实现回调功能

    我们用通俗讲解就是说在Java中，通常就是编写一个接口，然后你来实现这个接口，然后把这个接口的一个对象作以参数的形式传到另一个程序方法中， 然后通过接口调用你的方法，匿名内部类就可以很好的展现了这一种回调功能。

    1. public interface Demo {
    2.    void demoMethod();
    3. }
    5. public class MyDemo{
    6.    public test(Demo demo){
    7.        System.out.println("test method");
    8.    }
    10.    public static void main(String[] args) {
    11.        MyDemo md = new MyDemo();
    12.        //这里我们使用匿名内部类的方式将接口对象作为参数传递到test方法中去了
    13.        md.test(new Demo){
    14.            public void demoMethod(){
    15.                System.out.println("具体实现接口")
    16.            }
    17.        }
    18.    }
    19. }

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

    编写一个接口Demo

    1. public interface Demo {
    2.    void test();   
    3. }

    编写一个类 MyDemo

    1. public class MyDemo {
    3.    public void test() {
    4.        System.out.println("父类的test方法");
    5.    }
    7. }

    两者的方法名字都是test，下面编写一个测试类；

    1. public class DemoTest extends MyDemo implements Demo {
    2.    public void test() {
    3.    }
    4. }

    这样的话我就有点懵了，这样如何区分这个方法是接口的还是继承的，所以我们使用内部类解决这个问题 ```java public class DemoTest extends MyDemo {

  1.   private class inner implements Demo {
  2.       public void test() {
  3.           System.out.println("接口的test方法");
  4.       }
  5.   }
  7.   public Demo getIn() {
  8.       return new inner();
  9.   }
  12.   public static void main(String[] args) {
  13.       //调用接口而来的test()方法
  14.       DemoTest dt = new DemoTest();
  15.       Demo d = dt.getIn();
  16.       d.test();
  18.       //调用继承而来的test()方法
  19.       dt.test();
  20.   }

}

//运行结果 接口的test方法 父类的test方法 ```