java之内部类

一、分类：

1、静态内部类

2、成员内部类

3、局部内部类

4、匿名内部类

二、静态内部类

1、静态内部类可以等同看作静态变量

内部类重要的作用：可以访问外部类中静态的数据

2、静态内部类可以直接访问外部类的静态数据，无法访问成员

举个栗子：

public class Test{
    //静态变量
    private static String s1 = "a";
    
    //成员变量
    private String s2 = "B";
    
    
    //静态方法
    private static void m1() {
        System.out.println("static m1 method execute!   ");
    }
    
    //成员方法
    private void m2() {
        System.out.println("m2 method execute!  ");
    }
    
    //静态内部类
    //可以用访问权限的修饰符修饰
    //public,protected,private,缺省
    static class InnerClass{
        //静态方法
        public static void m3() {
            System.out.println(s1); // 静态变量
            m1(); // 静态方法
            
//          System.out.println(s2);  非静态变量，成员变量
//          m2(); 非静态方法，成员方法
        }
        
        //成员方法
        public void m4() {
            System.out.println(s1);
            m1();
            
//          System.out.println(s2);
//          m2();
        }
    }
    
    // 入口
    public static void main(String [] args) {
        // 执行m3
        Test.InnerClass.m3(); // static m1 method execute!
        
        // 执行m4
        InnerClass inner = new Test.InnerClass (); // 注意，特殊一点
        inner.m4(); // static m1 method execute!
    }
}

输出：

a
static m1 method execute!   
a
static m1 method execute!   

三、成员内部类

1、成员内部类可以等同看作静态变量

2、成员 内部类中不能有静态声明

3、成员内部类可以访问外部所有的数据

举个栗子：

ublic class Test{
    //静态变量
    private static String s1 = "a";
    
    //成员变量
    private String s2 = "b";
    
    
    //静态方法
    private static void m1() {
        System.out.println("static m1 method execute!   ");
    }
    
    //成员方法
    private void m2() {
        System.out.println("m2 method execute!  ");
    }
    
    //静态内部类
    //可以用访问权限的修饰符修饰
    //public,protected,private,缺省
     class InnerClass{
        //静态方法
//      public static void m3() {}
        
        //成员方法
        public void m4() {
            System.out.println(s1);
            m1();
            
            System.out.println(s2);
            m2();
        }
    }
    
    // 入口
    public static void main(String [] args) {
        
        // 创建外部类对象
        Test t = new Test();
        
        InnerClass inner = t.new InnerClass();
        
        inner.m4();
    }

}

输出：

a
static m1 method execute!   
b
m2 method execute!  

四、*局部内部类

局部内部类等同于局部变量

重点：局部内部类在访问局部变量的时候，局部变量必须使用final修饰

举个栗子：

public class Test{
    
    public void m1() {
        // 局部变量
        final int i = 10;
        
        // 局部内部类
        // 局部内部类不能用访问控制权限修饰符修饰
        class InnerClass{
            //局部内部类不能有静态声明
//          public static void m1() {}
            
            //成员方法
            public void m2() {
                System.out.println(i); // 10
            }
        }
        
        //不能更改i，否则出现矛盾，所以用final修饰i
        
        //调用m2
        InnerClass inner = new InnerClass();
        inner.m2();
    }
    
    
    // 入口
    public static void main(String [] args) {
        Test t = new Test();
        t.m1(); // 10
    }
}

输出：

10

五、*匿名内部类

指类没有名字

优点：少定义一个类

缺点：无法重复使用

举个栗子：

public class Test{
    // 静态方法
    public static void t(CustomerService1 cs) {
        cs.logout();
    }
    
    // 入口
    public static void main(String [] args) {
        // 调用t方法
//      Test.t(new CustomerServiceImpl1());
        
        // 使用匿名内部类的方式执行t方法
        t(new CustomerService1() {

            @Override
            public void logout() {
                // TODO Auto-generated method stub
                System.out.println("系统已经安全退出");
               }
            });
    }

}
// 接口
interface CustomerService1{
    // 退出系统
    void logout();
}

//编写一个类实现CustomerService1接口
//class CustomerServiceImpl1 implements CustomerService1{
//
//  @Override
//  public void logout() {
//      // TODO Auto-generated method stub
//      System.out.println("系统已经安全退出");
//  }
//  
//}

输出：

系统已经安全退出