Java基础 - 内部类

内部类

如果一个事物的内部包含另外一个事物,那么这就是一个类内部包含另一个类
例如：身体和心脏的关系，又如汽车和发动机的关系

加端端老师vx领取最新Java资料哦

成员内部类

修饰符 class 外部类名称{
    修饰符 class 内部类名称{
            //...
    }
     //...
}

注意：

内用外，随意访问,外用内,需要借助内部类对象
外部类的文件名是 内部类$内部类

使用成员内部类的俩个方法:

1.在外部类的方法当中，使用内部类;然后main只是调用外部类的方法。
2.直接方式,公式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

public class Body{ //外部类

    public class Heart{ //成员内部类
        //内部类的方法
        public void beat(){
            System.out.println("心脏跳动");
            System.out.println("我叫" + name); //正确写法
        }
    }

    //外部类的成员变量
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private String name;
    //外部类的方法
    public void methodBody(){
        System.out.println("外部类的方法");
        Heart heart = new Heart();
        heart.beat();
    }

}
public class InnerClass {
    public static void main(String[] args) {
        Body body = new Body();
        //通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
        body.methodBody();

        System.out.println("========================");
        Body.Heart heart = new Body().new Heart();
    }
}

内部类的同名变量访问：

如果出现了重名现象，那么格式是：外部类.this.成员变量名。
内部类可以直接访问外部类的成员,包括私有
外部类要访问内部类的成员,必须创建对象

public class Outer {
    int num = 10;//外部类的成员变量

    public class Inner{
        int num = 20;//内部类的成员变量

        public void methodInn(){
            int num = 30; //内部类方法的局部变量
            System.out.println(num);//局部变量，就近原则
            System.out.println(this.num);//内部类的成员变量
            System.out.println(Outer.this.num);//外部类的成员变量
        }
    }
}

public class InnerClass {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.methodInn();
    }
}

注意事项：

私有内部类,只能在外部类中使用
静态内部类创建格式：外部类.内部类 对象名 = new 外部类.内部类()
静态成员内部类中的静态方法：外部类名.内部类名.方法名();

局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。 “局部”:只是当前所属的方法才能使用它，出了这个方法外面就不能用了。该类可以直接访问外部类的成员,也可以访问方法内的局部变量

格式

修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名称(参数列表){
        class 局部内部类名称{
            //...
        }
    }
}

定义一个类的时候，权限修饰符规则：
1.外部类：public / (default)
2.成员内部类： public / protected / (default) / private
3.局部内部类：什么都不能写

局部内部类的final问题：
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。

匿名内部类【重点】

概述

匿名内部类本质上是一个特殊的局部内部类(定义在方法内部),

前提条件

需要存在一个接口或类

格式

new 类名或者接口名(){
重写方法;
}

public interface MyInterface {
    void method(); //抽象方法
}

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void method() {
        System.out.println("实现类覆盖重写了方法！");
    }
}

public class TestMain {
    public static void main(String[] args) {
        // MyInterface obj = new MyInterfaceImpl();
        // obj.method();
        //使用匿名内部类，但不是匿名对象，对象名就叫obj
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法！");
            }
        };

        obj.method();

        //使用匿名内部类，而且省略了对象名称，也是匿名对象
        System.out.println("===============================");
        new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法！");
            }
        }.method();
    }
}

理解

匿名内部类的理解：将继承\实现,方法重写,创建对象,放在了一步进行。

注意事项

1.对格式“new 接口名称(){…}”进行解析
1.new代表创建对象的动作
2.接口名称就是匿名内部类需要实现哪个接口
3.{…}这才是匿名内部类的内容
2.匿名内部类，在【创建对象的时候】，只能使用唯一一次。
3.如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了
4.匿名对象，在【调用方法】的时候，只能调用唯一一次，如果希望同一个对象，调用多次方法，那么必须给对象取个名字。
5.匿名内部类是省略了【实现类/子类的名称】,但是匿名对象是省略了【对象名称】。