Java 内部类

内部类
    类体中还有一个类的声明
当一个事务的内部,还有一个部分需要一个完整的结构进行描述,一般只是为了让外部类使用
而内部类还有一个作用,可以发访问外部类的私有化属性
分类:
       成员变量---成员内部类/普通内部类
    静态变量---静态内部类
    局部变量---局部内部类
    形参/实参--匿名内部类
    
    成员内部类可以等同看作成员变量,类体中不需要static修饰
    可以使用权限控制修饰符
    成员内部类中不能有静态声明
    成员内部类中可以直接访问外部类的所有属性
    内部类名 : 外部类$内部类 _01_OuterClass$InnerClass
    -----------

public class _01_OuterClass {
private static String s1="A";
private String s2 = "B";
class InnerClass{
    //不能有静态声明
    public void m2(){
        System.out.println(s1);
        System.out.println(s2);
    }
}
public static void main (String[]args){
    //1创建外部类对象
    _01_OuterClass out = new _01_OuterClass();
    //2创建内部类对象:外部类对象.new 内部类();
    InnerClass inerClass = out.new InnerClass();
    //3属性调用 
    inerClass.m2();
}
}

------------------
静态内部类 等同看作静态变量
可以使用权限控制修饰符
静态内部类中,可以声明所有属性,静态和成员都可以
静态内部类中,可以直接访问外部类的静态属性,不能直接访问成员属性
---------

public class _02_OuterClass {
private static String s1 = "A"; 
private String s2 = "B";
static class InnerClass{
    public static void m1(){
    System.out.println(s1);
    //System.out.println(s2);
    System.out.println(new _02_OuterClass().s2);
    //不能直接访问成员属性,但是有对象就可以    
    }
    public void m2(){
        System.out.println(s1);
        //虽然m2是成员方法,但还是不能直接访问外部类的成员属性
        //因为m2在InnerClass里,想要执行m2必须创建InnerClass对象
        //但是创建InnerClass对象的时候,不需要依赖于外部类对象
        //System.out.println(s2);
    }
    public static void main(String[]args){
        //外部类.内部类
        _02_OuterClass.InnerClass.m1();
        //new 外部类.内部类();
        InnerClass innerClass = new _02_OuterClass.InnerClass();
        innerClass.m2();
        //当前类中 类名可以忽略
         InnerClass.m1();
        innerClass = new InnerClass();
    }    
}
}

----------------------
局部内部类
局部内部类等同于局部变量
局部内部类中,不能有静态声明
局部内部类中不能使用static修饰符
如果外部方法是静态方法,则局部内部类不能直接访问外部类的成员属性
如果外部方法是成员方法,则局部内部类能直接访问外部类的所有属性
局部内部类中如果要使用外部方法中的局部变量,该变量必须使用final修饰(1.8开始final可以省略)
-----

public class _03_OuterClass {
    private static String s1 = "A"; 
    private String s2 = "B";
    //静态方法
    public static void m1 (){
        int i = 10;
        class InnerClass{
            //不能有静态声明
            public void m3(){
                System.out.println(s1);
    //因为外部方法是静态方法 所以不能直接访问外部类的成员属性
    //System.out.println(s2);
    //访问局部变量,需要使用final,但是1.8后可以忽略
                System.out.println(i);
            }
        }
        //使用内部类
        InnerClass innerClass = new InnerClass();
        innerClass.m3();
        }
        //成员方法
    public void m2(){
        int i = 2;
        class InnerClass{
            public void m3(){
                System.out.println(s1);
                //因为外部方法是成员方法,所以可以直接使用外部类中的所有属性
                System.out.println(s1);
                System.out.println(s2);
                System.out.println(i);                
            }
        }
        //使用内部类
        InnerClass innerClass = new InnerClass();
        innerClass.m3();        
    }
        public static void main (String[] args){
            m1();
            _03_OuterClass out = new _03_OuterClass();
            out.m2();
        }
}

--------------------------
匿名内部类
   :在方法调用时,需要传入一个类的对象,这个时候可以直接传入一个匿名内部类
   一般该对象,是接口的实现类对象,匿名内部类 等于是子类,可以使用super关键字
   语法: 方法( new 父类/接口(){类体});
   匿名内部类,会自动创建一个对象传入
   好处 少定义一个类,缺点 无法重复使用
 

 public class _04_OuterClass {
public static void main (String[]args){
    test(new UserLogin(){
        @Override
        public void login(String username, String password) {
    if(username.equals("admin")){
        if(password.equals("root")){
            System.out.println("登陆成功");
        }else{
            System.out.println("密码错误");
        }
    }else{
        System.out.println("用户名不正确");
    }            
        }    
    });
    }
public static void test(UserLogin userLogin){
    }
}
interface UserLogin{
    public void login(String username,String password);
}

--------------------------------------