文章目录

面向对象的内部类

山外有山，天外有天，类中还有类~~今天让我们来学习一下类中类。

1、java内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。
2、内部类分为： 成员内部类、局部内部类 、 静态嵌套类 、匿名内部类 。

一、成员内部类

1.可以等同看作是成员变量
2.成员内部类中不能够声明有静态方法、变量
3.成员内部类可以访问外部类所有的数据
4.成员内部类是最普通的内部类，它的定义为位于另一个类的内部

public class numberInner {

  // 静态变量
  public static String s1 = "A";
  // 成员变量
  public String s2 = "B";

  // 静态方法
  public static void m1() {
    System.out.println("static's m1 method execute!");
  }

  // 成员方法
  public void m2() {
    System.out.println("m2 method execute!");
  }

  * 成员内部类
  // 可以访问控制权限的修饰符修饰
  // public、protected、private、缺省
   class InnerClass {

    /*
     *  错误： Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
  Type mismatch: cannot convert from staticInner.InnerClass to numberInner.InnerClass
  at 内部类.numberInner$InnerClass.main(numberInner.java:52)
    
    public static void m3() {
      System.out.println(s1);
      // System.out.println(s2);
      // Cannot make a static reference to the non-static field s2
      m1();
      // m2();
      // Cannot make a static reference to the non-static method m2() from
      // the type staticInner
    }
        */
    // 成员方法
    public void m4() {
      System.out.println(s1);
      System.out.println(s2);
      m1();
      m2();
    }
  }
   
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    //创建外部类对象
     numberInner number = new numberInner();
     //通过外部类对象创建内部类对象
     InnerClass inner = number.new InnerClass();
     //调用内部类方法m4();
     inner.m4();
  } 
}

​​返回顶部​​

二、局部内部类

1.局部内部类等同于局部变量
2.局部内部类不能用访问控制权限修饰符修饰
3.局部内部类中不能有静态声明
4.当局部内部类访问局部变量的时候，局部变量要是最终形态 final
5.局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

public class localInner {
     //方法
   public void m1(){
       //局部变量
  final int i = 100;
     //局部内部类
     class InnerClass{
         //内部类方法  
       public void m2(){
         //Cannot refer to a non-final variable i inside an inner class defined in a different method
         System.out.println(i);
       }
     }
     InnerClass inner = new InnerClass();
     inner.m2();
   }
   
   public static void main(String[] args) {
     localInner i = new localInner();
     i.m1();
  }
}
结果：
100

​​返回顶部​​

三、静态嵌套类

1.可以等同看作是静态变量
2.静态内部类的重要作用：可以访问外部类中私有的数据
3.静态内部类只能直接访问外部类中的静态数据，无法直接访问成员数据

public class staticInner {

  // 静态变量
  public static String s1 = "A";
  // 成员变量
  public String s2 = "B";

  // 静态方法
  public static void m1() {
    System.out.println("static's m1 method execute!");
  }

  // 成员方法
  public void m2() {
    System.out.println("m2 method execute!");
  }

  // 静态内部类
  // 可以访问控制权限的修饰符修饰
  // public、protected、private、缺省
  static class InnerClass {

    // 定义静态方法
    public static void m3() {
      System.out.println(s1);
      // System.out.println(s2);
      // Cannot make a static reference to the non-static field s2
      m1();
      // m2();
      // Cannot make a static reference to the non-static method m2() from
      // the type staticInner
    }

    // 成员方法
    public void m4() {
      System.out.println(s1);
      m1();
    }

    public static void main(String[] args) {
      // 访问内部类的静态方法m3()
      staticInner.InnerClass.m3();
      // 访问内部类的成员方法，需要创建对象
      InnerClass inner = new staticInner.InnerClass();
      inner.m4();
    }
  }
}
结果：
A
static's m1 method execute!
A
static's m1 method execute!

​​返回顶部​​

四、匿名内部类

1.指的是类没有名字
2.优点：少些一个接口实现类
缺点：无法重复使用！

public class anonymousInner {
    //静态方法
    public static void test(customer cs){
        cs.logOut();
    }
    //入口
    public static void main(String[]) {
        //使用调用方法
        //test(new customerImpl());
        
        //使用匿名内部类
        //" new customer(){} " 即为匿名内部类
        test(new customer(){
            public void logOut(){
                System.out.println("程序已经退出了！");
            }
        });
    }
}
//接口
interface customer{
    //退出
    void logOut();
}
//编写接口实现类
/*
class customerImpl implements customer{
    public void logOut(){
        System.out.println("程序已经退出了！");
    }
}
 */

​​返回顶部​​