java-day10-内部类

10.9 概述

内部类：其实将类定义到了另一个类的内部

A类要直接访问B类中的成员时，可以将A类定义到B类中。作为B类的内部类存在。

class Outer{
    int num = 4;
    
    class Inner{
        void show(){
            System.out.println(num);
        }
    }
}

访问规则

• 内部类可以直接访问外部类中的成员
• 外部类想要访问内部类，需要创建内部类的对象来访问。

非静态，非私有的内部类访问方式

class Outer{

    int num = 4;
    
    class Inner{ //内部类，相当于外部类中的一个成员
        void show(){
            System.out.println(num);
        }
    }
    public void method(){
        Inner in = new Inner();
        in.show();
    }
}

public class Test {
    public static void main(String[] args){

        Outer out = new Outer();
        out.method();  //输出4
    }

}

10.10 访问格式_非静态内部类

内部类 相当于外部类中的一个成员。它就可以被成员修饰符所修饰：public、static、private。
如果内部类权限是非私有，就可以在外部其他程序中访问到，就可以通过创建外部类对象完成。

非静态，非私有

class Outer{
    int num = 4;
    class Inner{ //内部类，相当于外部类中的一个成员
        void show(){
            System.out.println(num);
        }
    }
}

public class Test {
    public static void main(String[] args){

		// 1.先创建外部类对象
        Outer out = new Outer();
        // 2.再创建内部类对象
        Outer.Inner in = out.new Inner();
        in.show(); //输出4
    }

}

10.11 访问格式_静态内部类

静态内部类，相当于外部类。

静态，非私有的内部类访问方式，访问非静态成员。

class Outer{

    private static int num = 4;
    
    class Inner{ //内部类，相当于外部类中的一个成员
        void show(){
            System.out.println(num);
        }
    }

    static class Inner2{   //相当于外部类
        void show2(){
            System.out.println("show2____"+num);
        }
    }
    public void method(){
        Inner in = new Inner();
        in.show();
    }
}
class Demo{}
public class Test {
    public static void main(String[] args){

        /*Outer out = new Outer();
        Outer.Inner in = out.new Inner();
        in.show();*/
        // 直接创建了内部类对象
        Outer.Inner2 in2 = new Outer.Inner2();
        in2.show2(); //输出show2____4
    }

}

静态，非私有的内部类访问方式2，访问静态成员。

class Outer{
    private static int num = 4;
    class Inner{ //内部类，相当于外部类中的一个成员
        void show(){
            System.out.println(num);
        }
    }

    static class Inner2{
        void show2(){
            System.out.println("show2____"+num);
        }
        static void show3(){
            System.out.println("show3____"+num);
        }
    }
    public void method(){
        Inner in = new Inner();
        in.show();
    }
}
class Demo{}
public class Test {
    public static void main(String[] args){

        /*Outer out = new Outer();
        Outer.Inner in = out.new Inner();
        in.show();*/
        /*Outer.Inner2 in2 = new Outer.Inner2();
        in2.show2();*/
		
		//直接使用 类名.函数名 调用
        Outer.Inner2.show3();
    }

}

10.12 内部类细节&匿名内部类

为什么内部类就可以直接访问外部类中的成员。
那是因为内部类持有外部类的引用。外部类名.this

class Outer{
    int num = 2;

    class Inner{
        int num = 3;
        void show(){
            int num = 4;
            System.out.println("show.."+num);//输出show..4
            System.out.println("show.."+this.num);//输出show..3
            System.out.println("show.."+Inner.this.num);//输出show..3
            System.out.println("show.."+Outer.this.num);//输出show..2
        }
    }

    public void method(){
        Inner in = new Inner();
        in.show();
    }
}

public class Test {
    public static void main(String[] args){

        new Outer().method();
    }

}

匿名内部类： 简化书写的内部类
前提：内部类需要继承外部的类，或者实现接口
格式：new 父类 or 接口名() { 子类的内容 }

匿名类其实就是一个子类对象。

普通的内部类形式：

class Outer{
    private int num = 4;
    class Inner{
        public void show(){
            System.out.println("show.."+num);
        }
    }

    public void method(){
        new Inner().show();
    }

}
public class Test {
    public static void main(String[] args){

        new Outer().method();
    }

}

改写成匿名内部类：

abstract class Demo{
    abstract void show();
}
class Outer{
    private int num = 4;
    /*class Inner{
        public void show(){
            System.out.println("show.."+num);
        }
    }*/

    public void method(){
        //new Inner().show();
        new Demo(){
            //覆盖Demo中的抽象方法
            public void show(){
                System.out.println("show.."+num);
            }
        }.show();
    }

}
public class Test {
    public static void main(String[] args){

        new Outer().method();
    }

}

10.13 匿名内部类2

interface Inter{
    void show1();
    void show2();
}

class Outer{
    private int num = 2;
    /*class Inner implements Inter{
        public void show1(){}
        public void show2(){}
    }*/
    public void method(){
        /*Inner in = new Inner();
        in.show1();
        in.show2();*/
        
        Inter in = new Inter(){
            public void show1(){}
            public void show2(){}
        };
        in.show1();
        in.show2();
    }
}
public class Test {
    public static void main(String[] args){

        new Outer().method();
    }

}

10.4 练习

class Outer{
    /*class Inner{

    }*/
    public void method(){

        //写法一： 编译可以通过
        new Object(){
            public void show(){
                System.out.println("show run");
            }
        }.show();

        //写法二：编译不通过
        Object obj = new Object(){ 
        //Object obj 指向了自己的子类对象，对象提升为了Object。就不能调用子类的特有方法。
            public void show(){
                System.out.println("show run");
            }
        };
        obj.show();
    }
}
public class Test {
    public static void main(String[] args){

        new Outer().method();
    }

}