Day11 - 内部类

内部类：

在一个类里面还有一个类，Outer外部类、Inner内部类

内部类的访问规则：

内部类可以直接访问外部类中的成员、包括私有。
能够访问的原因是：内部类中持有一个外部类的引用。
格式：外部类名.this
外部类要访问内部类、必须建议内部类对象。

当内部类定义在外部类的成员位置上时，并且非私有，可以在外部其他类中访问，格式为：
外部类名.内部类名 变量名 = 外部类对象.内部类对象
Outer.Inner in = new Outer().new Inner();

内部类可以放在成员位置上，既然是成员就可以被成员修饰符修饰。
private：将内部类在外部类中进行封装。
static：修饰后内部类就具有静态的特性。
当内部类被static修饰后，在内部类中只能访问外部类中的静态，出现了访问限制。

在外部其他类中，如何访问静态内部类额非静态成员呢？
new Outer.Inner().show();
在外部其他类中，如何访问静态内部类中的静态成员？
Outer.Inner.show();

代码示例

class Demo{// 外部其他类
    public static void main(String[] args){
        /*
        Outer out = new Outer();
        out.show();*/
        /*
        Outer.Inner in = new Outer().new Inner();// 格式    
        in.method();*/
        //Outer.Inner inner = new Outer.Inner();  inner.method(); 等价于下面的   
        new Outer.Inner().method();
        Outer.Inner.methodA();
    }
}
class Outer{// 外部类
    private int num = 10;
    private  static int price = 100;
    public void show(){
        /*
        System.out.println(this.num);
        Inner in = new Inner();
        in.method();
        */
    }   
    /*private*/ static class Inner{// 内部类
        public void method(){
            price = 300;
            System.out.println(price);
        }
        public static void methodA(){
            System.out.println(price+1000);
        }   
    }
}

注意：
1. 当内部类中定义了静态成员、那么该内部类必须是静态的。
2. 当外部类中的静态方法访问内部类时、内部类也必须是静态的。

代码示例

class Demo1{// 外部其他类
    public static void main(String[] args){ 
    }
}
class Outer{// 外部类
    private int num = 10;
    private static int price = 100;
    
    public static void show(){
        new Inner().method();
    }
    static class Inner{// 内部类
        public void method(){
            System.out.println(price);
        }
    }
}

内部类定义原则：

当描述事物时，事物的内部还有事物，该事物用内部类来描述，这样的设计更优秀，因为内部事物在使用外部事物的内部。
如：人体和心脏，心脏应该使用私有修饰，并提供方法供外界访问。

代码示例

class Demo2{// 外部其他类
    public static void main(String[] args){
        Body body = new Body();
        body.broken();
        body.treat("doctor");
    }   
}
class Body{// 外部类
    private int hand = 2;
    private int foot = 2;
    private int finger = 10;
    public void broken(){
        new Heart().broken();
    }
    public  void treat(String work){
        if(work.equals("doctor")){
            new Heart().jump();
        }
        System.out.println("滚犊子。。。");
    }
    private class Heart{// 内部类
        String leftHeartRoom = "左心室";
        String leftHeart = "左心房";
        String rightHeart = "右心房";
        int num = 0;
        public void jump(){
            while(true){
                if(num==10){
                    num=0;
                }
                System.out.println("boom..."+num);
                num++;
                try{
                    Thread.sleep(500);
                }catch(Exception e){
                    System.out.println("---");
                }
            }
        }
        public void broken(){
            System.out.println("伤了一下下");
        }
    }
}

匿名内部类： 没有名字的内部类

1. 匿名内部类的格式：
   new 父类或者接口(){
   //定义子类的内容
   }
2. 定义匿名内部类的前提：
   内部类必须继承一个类或者实现一个接口。
3. 从代码上直观的看其实匿名内部类就是一个匿名子类对象。该对象带了一对大括号，可以理解为带内容的对象。
   4.开发中匿名内部类使用场景： 继承抽象类 或者实现接口 、重写抽象类的抽象方法或重写接口中的所有抽象方法。

代码示例

/*
abstract class Animal{
    public abstract void eat();
    public abstract void work();
    public abstract void sleep();
}*/
interface Animal{
    Animal eat();
}
class Person{
    /*
    private Person(){   
    }*/
    public void eat(){  
    }
}
class Demo3{
    public static void main(String[] args){
        
        /*
        Animal a1 =  new Animal(){
            public void eat(){
                System.out.println("吃啊吃 咋不撑死你。。。");
            }
            public void work(){
                System.out.println("工作啊工作 你能不能懂点生活。。。");
            }
            public void sleep(){
                System.out.println("赶紧洗洗睡吧");
            }
        };
        a1.eat();
        a1.work();
        a1.sleep();*/
        /*
        new Animal(){
            public void eat(){
                System.out.println("吃啊吃 咋不撑死你。。。111");
            }
            public void work(){
                System.out.println("工作啊工作 你能不能懂点生活。。。");
            }
            public void sleep(){
                System.out.println("赶紧洗洗睡吧");
            }
        }.eat();
        */
        /*
        new Animal(){
            public Animal eat(){
                System.out.println("吃啊吃 吃了一只老虎 吐出来");
                return this;
            }
        }.eat().eat().eat();// 链式调用 开发中不要这么干
        */
        new Person(){   
        };  
        System.out.println(
        new Object(){
            public int hashCode(){
                return 1314;
            }
            public String toString(){
                return "520";
            }
        }.toString());
    }   
}