21. 内部类

/*
内部类：
    
    成员内部类（在外部类声明成员的地方创建一个类）

                
        创建对象方式：
                
            1）在外部类中定义一个方法并创建内部类对象

                a.在另一个类中创建外部类的对象，并调用那个创建内部类对象的方法

            2）在另一个类中创建内部类对象

                a.外部类.内部类  变量名 = new 外部类().new 内部类()
            
        
        注意：
            1）如果是静态内部类在其他类中创建对象的访问方式为：外部类.内部类 变量名 = new 外部类.内部类()
            2）如果成员内部类中出现了静态的成员，那么内部类必须用static修饰
            3）如果成员内部类是私有的，那么创建内部类对象只能在外部类中提供方法创建
        
        访问成员：

            1）内部类访问外部类的变量

                a.外部类和内部类不存在相同的成员变量

                    访问的是外部类的成员变量
                
                b.外部类和内部类存在相同的成员变量
                    
                    默认访问的是内部类的成员变量

                    访问外部类成员变量的格式为：外部类.this.变量名
                        


    局部内部类（在外部类方法里面创建一个类）

        注意：如果局部内部类访问了局部变量，那么该变量需要使用final修饰（原因：因为生命周期不一致）


    匿名内部类（没有类名的类）    
        
        匿名内部类使用的前提：必须继承一个父类或者是实现一个接口

        格式：
            new 父类(父接口){
                
                匿名内部类的成员
            }

        注意：

            1）如果只调用一个方法可以直接在创建内部类后面写  .方法名

                a.格式：
                    new 父类(父接口){
                
                        匿名内部类的成员
                    }.方法名

                b.可以直接调用内部类特有的方法


            2）如果调用多个方法
                
                a.第一个方法设置一个返回值，并返回这个对象
                    //抽象方法定义
                    abstract public AbsClass run();
                    

                    匿名内部类中返回对象

                    public void sleep(){
                        System.out.println("狗在睡觉~~");
                        return this;
                    }


                b.给对象一个变量名在调用
                    
                    格式：

                        父类(父接口) 变量名 = new 父类(父接口){
                
                            匿名内部类的成员
                        }
                        
                    变量名.方法     

*/
//外部类
import java.util.*;




abstract class AbsClass{

    abstract public void run();

    //abstract public AbsClass run();
    abstract public void sleep();
}
class Outer{
    

    /*
    String str1 = "外部类的str1";
    String str2 = "外部类的str2";

    public Outer(){}

    
    
    定义一个方法并且创建内部类对象
    public  void newInner(){
        Inner inner = new Inner();
        inner.innerFuntion();
    }
    
    
    //内部类
    static class Inner{

        String str2 = "内部类的str2";
        public Inner(){}
        public void innerFuntion(){
            System.out.println("我是内部类。。。。");
            
            System.out.println(str1);
            System.out.println(Outer.this.str2);
            
        }
    }

    */

    public void outerFun(){
    
        /*
        new AbsClass(){
            public void run(){
                System.out.println("狗在跑。。。。");
            }
            
            public void sleep(){
                System.out.println("狗在睡觉~~");
            }

        }.sleep();

        */
        /*
        new AbsClass(){
            public AbsClass run(){
                System.out.println("狗在跑。。。。");
                //返会对象
                return this;
            }
            
            public void sleep(){
                System.out.println("狗在睡觉~~");
            }

        }.run().sleep();

        */

        AbsClass absclass = new AbsClass(){

            public void run(){
                System.out.println("狗在跑。。。。");
            }
            
            public void sleep(){
                System.out.println("狗在睡觉~~");
            }

        };

        absclass.run();
        absclass.sleep();
    }

    

}


class Demo1 {
    public static void main(String[] args) {
        /*
        Outer outer = new Outer();
        outer.newInner();
        */

        
        /*
        Outer.Inner inner = new Outer().new Inner();
        inner.innerFuntion();
        */
        
        /*
        Outer.Inner inner = new Outer.Inner();
        inner.innerFuntion();
        */

        Outer outer = new Outer();
        outer.outerFun();

    }
}