java学习中，成员内部类、匿名内部类（java 学习中的小记录）

 1 package study;
 2 
 3 class Outer {
 4     
 5     int i = 10;//自带的成员变量 外部类
 6     
 7     //定义一个内部类
 8     //成员内部类
 9     class Inner{
10         
11         int i = 20;//内部类的变量
12         
13         public void print() {
14             System.out.println("这个是内部类"+i);//打印的是20
15             System.out.println("这个是内部类"+Outer.this.i);//访问的是外部类的属性
16         }
17     }
18     //创建一个方法来创建内部类对象(方式1)
19 /*    public void instantce(){
20         //创建内部类对象
21         Inner inner = new Inner();
22         inner.print();    
23     }*/
24 }
25 //其他类
26 public class star {
27     public static void main(String[] args) {    
28 /*        //在其他类中访问内部类(方式1)
29         Outer outer= new Outer();
30         outer.instantce();*/
31         
32         //其他类中直接访问：(方式2)
33         Outer.Inner inner = new Outer().new Inner();
34         inner.print();
35         
36    }
37 }

 1 class Outer{
 2     String name = "外部类的name";
 3     int i = 20; 
 4     
 5     public void test() {
 6         
 7         final int i = 30;//局部变量 出了这个方法就消失。
 8         //为什么要用final来修饰？
 9         /*test方法执行完，变量i 立马从内存中消失，而inner对象在方法执行完之后，没有消失的，这里再使用i就好比把i的生命周期延迟了，与局部变量的定义不符。
10          *所以用final修饰，相当于把i设置了一个复制品给test方法使用，真实的i已经消失。
11          * */
12         
13         //局部内部类
14         class Inner{
15             public void print(){
16                 /*int i = 10; 注销之后研究拿到30这个i*/
17                 System.out.println("这个是局部内部类的方法"+i);//打印的是10
18             }
19         }
20         //创建局部对象
21         Inner inner = new Inner();//test走完，这个对象可能还存在（它是由java虚拟机决定消除的，不知道是什么时候），存在的话相当于给 i 的生命周期延迟了。
22         inner.print();
23     }    
24 }
25 
26 public class Star {
27 
28     public static void main(String[] args) {
29         //在其他类中访问局部内部类
30         Outer out = new Outer();
31         out.test();
32         
33         //下面是错误的写法
34         /*Outer.Inner inner = new Outer().new Inner();
35         inner.print();*/
36     }
37 }

abstract class Animal{
    public abstract void run();
    public abstract void sleep();
}

//外部类
//在Outer里面创建一个Dog的内部类
class Outer{
    
    //不用匿名
    /*class Dog extends Animal{
        public void run() {
            System.out.println("狗在跑");
        }
        public void sleep() {
            System.out.println("狗在睡觉");
        }
    }*/
    

    public void print(){
        //Dog d = new Dog();
        //d.run();
        
        //匿名的Dog（通过父类来完成创建）
        //匿名内部类：只是没有名字，其它的和普通的类没什么不一样
        Animal a = new Animal(){//不是父类创建对象 匿名内部类（子类）
            //具体实现
            public void run(){
                System.out.println("狗在跑");
            };
            public void sleep(){
                System.out.println("狗在睡觉");
            };
        };
        a.run();
        a.sleep();
    };
}
 
public class Star {

    public static void main(String[] args) {
        Outer out = new Outer();
        out.print();
        
    }
}