当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。

1、什么是内部类

Java中允许将一个类A声明在另一个类B中,则类A就是内部类,类B就是外部类.

  1. class Person{
  2.     String name = "李雷";
  3.     int age;
  5.     //静态成员内部类
  6.     static class Dog{
  7.         String name;
  8.         int age;
  10.         public void show(){
  11.             System.out.println("卡拉是条狗");
  12.         }
  13.     }
  15.     //非静态成员内部类
  16.     class Bird{
  17.         String name = "杜鹃";
  18.         public Bird(){
  19.         }
  20.         public void sing(){
  21.             System.out.println("我是一只猫头鹰");
  22.             Person.this.eat();//调用外部类的非静态属性
  24.             System.out.println(age);
  25.         }
  26. }

2、内部类的分类

成员内部类 和 局部内部类 （方法内、代码块内、构造器内）

3、成员内部类能干什么？

3.1、作为外部类的成员

  • 调用外部类的结构
  • 可以被static修饰

  • 可以被4种权限修饰符修饰

    3.2、作为一个类

  • 类内可以定义属性、方法、构造器

  • 可以被final修饰，表示此类不能被继承。言外之意，不使用final就可以被继承

  • 可以被abstract修饰

    4、内部类关注的问题

    4.1、如何实例化成员内部类的对象

    1. public class InnerClassTest {
    2.   public static void main(String[] args) {
    3.       //创建Dog实例(静态的成员内部类)
    4.       Person.Dog dog = new Person.Dog();
    5.       dog.show();
    7.       //创建Bird实例(非静态的成员内部类)
    8.       Person p = new Person(); //先将
    9.       Person.Bird bird = p.new Bird();
    10.       bird.sing();
    11.       System.out.println();    
    12.       bird.display("喜鹊");
    13.   }

    4.2、如何在成员内部类中区分调用外部类的结构

    方法中的形参：直接形参名
    内部类的属性：this.属性名
    外部类的属性：外部类名.this.属性名 ```java public class InnerClassTest { public static void main(String[] args) {

    1.   //创建Dog实例(静态的成员内部类)
    2.   Person.Dog dog = new Person.Dog();
    3.   dog.show();
    5.   //创建Bird实例(非静态的成员内部类)

    // Person.Bird bird = new Person.Bird();

    1.   Person p = new Person();
    2.   Person.Bird bird = p.new Bird();
    3.   bird.sing();
    5.   System.out.println();
    7.   bird.display("喜鹊");

    } } class Person{ String name = “李雷”; int age;

    public void eat(){

    1.   System.out.println("人，吃饭");

    }

    //静态成员内部类 static class Dog{

    1.   String name;
    2.   int age;
    4.   public void show(){
    5.       System.out.println("卡拉是条狗");

    // eat();

    1.   }

    }

    //非静态成员内部类 class Bird{

    1.   String name = "杜鹃";
    2.   public Bird(){
    4.   }
    6.   public void sing(){
    7.       System.out.println("我是一只猫头鹰");
    8.       Person.this.eat();//调用外部类的非静态属性
    9.       eat();
    10.       System.out.println(age);
    11.   }
    13.   public void display(String name){
    14.       System.out.println(name);    //方法的形参
    15.       System.out.println(this.name);    //内部类的属性
    16.       System.out.println(Person.this.name);    //外部类的属性
    17.   }

    } public void method(){

    1.   //局部内部类
    2.   class AA{
    4.   }

    }

    {

    1.   //局部内部类
    2.   class BB{
    4.   }

    }

    public Person(){

    1.   //局部内部类
    2.   class CC{
    4.   }

    } }

  1. <a name="pSihN"></a>
  2. ## 4.3、开发中局部内部类的使用 见《InnerClassTest1.java》
  3. ```java
  4. public class InnerClassTest1 {
  6. //    开发中很少见
  7.     public void method(){
  8. //        局部内部类
  9.         class AA{
  11.         }
  12.     }
  14. //    返回一个实现了Comparable接口的类的对象
  15.     public Comparable getComparable(){
  17. //        创建一个实现了Comparable接口的类:局部内部类
  18.         //方式一：
  19. //        class MyComparable implements Comparable{
  20. //
  21. //            @Override
  22. //            public int compareTo(Object o) {
  23. //                return 0;
  24. //            }
  25. //            
  26. //        }
  27. //        
  28. //        return new MyComparable();
  30.         //方式二：
  31.         return new Comparable(){
  34.             @Override
  35.             public int compareTo(Object o) {
  36.                 return 0;
  37.             }
  39.         };
  41.     }
  42. }

5、匿名内部类

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。
一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

  1. /*
  2.  * 1.匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。
  3.  * 一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
  4.  * 
  5.  * 2.格式：
  6.  *         new 父类构造器（实参列表）|实现接口(){
  7.  *                 //匿名内部类的类体部分
  8.  *         }
  9.  * 
  10.  * 3.匿名内部类的特点
  11.  *         > 匿名内部类必须继承父类或实现接口
  12.  *         > 匿名内部类只能有一个对象
  13.  *         > 匿名内部类对象只能使用多态形式引用
  14.  */
  15. interface Product{
  16.     public double getPrice();
  17.     public String getName();
  18. }
  19. public class AnonymousTest{
  20.     public void test(Product p){
  21.         System.out.println("购买了一个" + p.getName() + "，花掉了" + p.getPrice());
  22.     }
  23.     public static void main(String[] args) {
  24.         AnonymousTest ta = new AnonymousTest();
  25.         //调用test方法时，需要传入一个Product参数，
  26.         //此处传入其匿名实现类的实例
  27.         ta.test(new Product(){
  28.             public double getPrice(){
  29.                 return 567.8;
  30.             }
  31.             public String getName(){
  32.                 return "AGP显卡";
  33.             }
  34.         });
  35.     }
  36. }
  1. public class InnerClassTest {
  3. //    public void onCreate(){
  4. //    
  5. //    int number = 10;
  6. //    
  7. //    View.OnClickListern listener = new View.OnClickListener(){
  8. //        
  9. //        public void onClick(){
  10. //            System.out.println("hello!");
  11. //            System.out.println(number);
  12. //        }
  13. //        
  14. //    }
  15. //    
  16. //    button.setOnClickListener(listener);
  17. //    
  18. //}
  20.     /*
  21.      * 在局部内部类的方法中(比如:show)如果调用局部内部类所声明的方法(比如：method)中的局部变量(比如：num)的话,
  22.      * 要求此局部变量声明为final的。
  23.      * 
  24.      * jdk 7及之前版本：要求此局部变量显式的声明为final的
  25.      * jdk 8及之后的版本：可以省略final的声明
  26.      * 
  27.      */
  28.     public void method(){
  29.         //局部变量
  30.         int num = 10;
  32.         class AA{
  34.             public void show(){
  35. //                num = 20;    //Local variable num defined in an enclosing scope must be final or effectively final
  36.                 System.out.println(num);
  37.             }
  38.         }
  39.     }
  40. }