7.1.7 Java内部类

7.1.7 Java内部类

内部类就是在一个类的内部再定义一个类，比如A类中定义一个B类，那么B类相对A类来说就成为内部类，而A类相对B类来说就是外部类了。

1. 成员内部类

   内部类可以直接访问外部类的一些属性。比如内部类是可以访问外部类的私有变量。

   成员内部类实例

   package com.baidu.www.oop.demo10;
   
   public class Outer {
       private  int id=10;
       public void out(){
           System.out.println("这是成员外部类的方法");
       }
       public class Inner{
           public void in(){
               System.out.println("这是成员内部类的方法");
           }
           //获得外部类的私有属性，也就是能够操作这些私有属性和私有方法
           public void getID(){
               System.out.println(id);
           }
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17

   成员内部类主程序实例

   package com.baidu.www.oop;
   
   
   import com.baidu.www.oop.demo10.Outer;
   
   public class Application {
       public static void main(String[] args) {
           Outer outer = new Outer();
           //内部类的使用需要通过外部类的实例化内部类
           Outer.Inner inner = outer.new Inner();
           inner.in();
           inner.getID();
       }
   }
   /*
   *这是成员内部类的方法
   10
   
   Process finished with exit code 0 */
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19

2. 静态内部类

   在成员内部类前加上static关键字修饰就变成了静态内部类，一旦加上static变成静态内部类后，这个内部类就无法操作外部类的私有属性了，这是因为静态类是一开始就已经加载到内存中了，而属性则需要在对象实例化后才生成，如果想要操作也需要将属性变成静态变量。

   静态内部类实例

   package com.baidu.www.oop.demo10;
   
   public class Outer {
       private  int id=10;
       public void out(){
           System.out.println("这是成员外部类的方法");
       }
       public static class Inner{
           public void in(){
               System.out.println("这是成员内部类的方法");
           }
           /**
            * 获得外部类的私有属性，也就是能够操作这些私有属性和私有方法
            *         public void getID(){
            *             System.out.println(id);
            *         }
            */
           
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20

   静态内部类主程序实例

   package com.baidu.www.oop;
   
   
   import com.baidu.www.oop.demo10.Outer;
   
   public class Application {
       public static void main(String[] args) {
           Outer outer = new Outer();
           //内部类的使用需要通过外部类的实例化内部类
           //Outer.Inner inner = outer.new Inner();
           //inner.in();
           //inner.getID();
       }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

3. 局部内部类

   这跟局部变量一样，在方法中定义的变量就是局部变量

   局部内部类实例

   package com.baidu.www.oop.demo10;
   
   public class Outer {
       //局部内部类
      public void method(){
          class Inner{
              public void in(){
   
              }
          }
      }
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

4. 匿名内部类

   也就是说有些类实例化之后不需要名字就能实现出来。

   匿名内部类实例

   package com.baidu.www.oop.demo10;
   
   public class Text {
       public static void main(String[] args) {
           new Apple().eat();//没有名字初始化类,不用将实例保存到变量中
           new UserService(){
   
               @Override
               public void hello() {
   
               }
           };//这个方法可以返回一个UserService对象，也就是实现接口的类，但是实现这个接口的类没有名字
       }
   }
   class Apple{
       public void eat(){
           System.out.println("1");
       }
   }
   interface UserService{
       void hello();
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22

这里我们还需要知道一个Java类中可以有多个class类，但是只能有一个public class，以上的这些内部类我们知道怎么用，但是不建议这样去玩。