Java基础第二遍-08-面向对象-内部类

转载

mob604757001c56 2021-10-26 23:50:00

内部类

将一个类定义在另外一个类的里面，对里面的那个类就称为内部类
内部类可以直接访问外部类的成员，包括私有成员
外部类想要访问内部类中的成员需要建立内部类对象，通过对象进行访问

访问内部类

三种内部类形式

普通内部类，普通成员
静态内部类，普通成员
静态内部类，静态成员

package com.bixiangdong.oop;
class Out{
    class Inner{
        void run(){
            System.out.println("Inner run---");
        }
    }
    static class Inner1{
        void run1(){
            System.out.println("Inner1 run1---");
        }
    }
    static class Inner2{
        static void run2(){
            System.out.println("Inner2 run2---");
        }
    }
}
public class Demo08 {
    public static void main(String[] args) {
        //访问内部类中的成员
        Out.Inner in = new Out().new Inner();
        in.run();
        //访问静态内部类中的成员
        //一个静态内部类就相当于一个外部类
        Out.Inner1 in1 = new Out.Inner1();
        in1.run1();
        //如果内部类是静态的，成员也是静态的
        //成员如果是静态的，那么内部类也必须是静态内部类
        Out.Inner2.run2();
    }
}

为什么内部类可以直接访问外部类的成员

因为内部类持有了外部类的引用
使用方式：外部类名.this.属性（函数）

内部类可以定义在局部位置上

局部代码的生命周期很短，只存在于{}，其中的变量也是运行结束就消失
此时内部类的生命周期更长，如果要访问局部代码中的变量，他又消失了，就不能访问，
所以解决办法就是将他定义为常量，永不更改这样内部类可以将其值存储起来，方便之后的使用
局部代码中的内部类不能直接使用外部类进行访问

package com.bixiangdong.oop;
class Out1{
    Object method(final int y){
        //局部代码的生命周期很短，只存在于{}，其中的变量也是运行结束就消失
        //此时内部类的生命周期更长，如果要访问局部代码中的变量，他又消失了，就不能访问，
        // 所以解决办法就是将他定义为常量，永不更改这样内部类可以将其值存储起来，方便之后的使用
        //局部代码中的内部类不能直接使用外部类进行访问
        final int x=0;
        class Inner1{
            void run(){
                System.out.println("Inner1 run"+x);
            }
        }
        return new Inner1();
    }
    class Inner2{

    }
}
public class Demo09 {
    public static void main(String[] args) {
        Object in1 = new Out1().method(1);
    }
}

匿名内部类

通俗：匿名内部类就是内部类的简写格式
前提：内部类必须继承或实现一个外部类或接口
案例1：

package com.bixiangdong.oop;

abstract class Fu3{
    abstract void show();
}
class Outer{
    int num=9;
    //常规方式：
    //创建子类继承父类
    //new 创建子类对象 调用方法
    class Inner3 extends Fu3{
        @Override
        void show() {
            System.out.println("这是一个普通内部类");
        }
    }
    Fu3 x=new Fu3() {
        @Override
        void show() {

        }
    };
    //匿名内部类 
    //直接new一个父类，重写方法 ，调用方法
    //相当于直接新建了一个子类对象
    public void method(){
        new Fu3(){
            @Override
            void show() {
                System.out.println("这是一个匿名内部类");
            }
        }.show();
    }
}
public class Demo10 {
    public static void main(String[] args) {
        new Outer().method();
    }
}

案例2：
Java基础第二遍-08-面向对象-内部类_ide_02