内部类（重点）

最新推荐文章于 2023-05-25 19:02:12 发布

崔可夫

最新推荐文章于 2023-05-25 19:02:12 发布

阅读量190

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_43278882/article/details/124480242

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

基本介绍

一个类的内部又嵌套了另一个类的结构。被嵌套的类被称为内部类，嵌套其他类的类叫做外部类。
类的五大成员：属性方法构造器代码块内部类
内部类的最大特点是可以直接访问私有属性，并且可以体现类和类之间的包含关系。

基本语法

在这里插入图片描述
四种内部类

定义在外部类局部位置上（比如方法内）

局部内部类（有类名）
匿名内布类（没有类名，重点）

定义在外部类的成员位置上

成员内部类（没有static修饰）
静态内部类（使用static修饰）

局部内部类
是定义在外部类的局部位置，比如方法中，并且有类名。

可以直接访问外部类的所有成员，包含私有的
不能添加修饰符，但是可以使用final修饰
作用域只能在定义它的方法或代码块中
局部内部类可以直接访问外部类的成员
外部类只能在方法中创建内部类的对象实例然后调用方法
外部其他类不能访问内部类（外部其他类不能创建内部类的实例对象）
内部类和外部类成员重名是，默认遵守就近原则，如果想访问外部类的成员，则使用（外部类名.this.成员）去访问

public class LocalInnerClass {//
    public static void main(String[] args) {
        //演示一遍
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println("outer02的hashcode=" + outer02);
    }
}


class Outer02 {//外部类
    private int n1 = 100;
    private void m2() {
        System.out.println("Outer02 m2()");
    }//私有方法
    public void m1() {//方法
        //1.局部内部类是定义在外部类的局部位置,通常在方法
        //3.不能添加访问修饰符,但是可以使用final 修饰
        //4.作用域 : 仅仅在定义它的方法或代码块中
        final class Inner02 {//局部内部类(本质仍然是一个类)
            //2.可以直接访问外部类的所有成员，包含私有的
            private int n1 = 800;
            public void f1() {
                //5. 局部内部类可以直接访问外部类的成员，比如下面 外部类n1 和 m2()
                //7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
                //   使用 外部类名.this.成员）去访问
                //   老韩解读 Outer02.this 本质就是外部类的对象, 即哪个对象调用了m1, Outer02.this就是哪个对象
                System.out.println("n1=" + n1 + " 外部类的n1=" + Outer02.this.n1);
                System.out.println("Outer02.this hashcode=" + Outer02.this);
                m2();
            }
        }
        //6. 外部类在方法中，可以创建Inner02对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }

}

匿名内部类的使用

本质是类
内部类
该类没有名字
同时还是一个对象
说明：本质不是没有名字，是看不到，系统分配的名字
基本语法

package com.hspedu.innerclass;


/**
 * 演示匿名内部类的使用
 */
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}

class Outer04 { //外部类
    private int n1 = 10;//属性
    public void method() {//方法
        //基于接口的匿名内部类
        //老韩解读
        //1.需求： 想使用IA接口,并创建对象
        //2.传统方式，是写一个类，实现该接口，并创建对象
        //3.老韩需求是 Tiger/Dog 类只是使用一次，后面再不使用
        //4. 可以使用匿名内部类来简化开发
        //5. tiger的编译类型 ? IA
        //6. tiger的运行类型 ? 就是匿名内部类  Outer04$1
        /*
            我们看底层 会分配 类名 Outer04$1
            class Outer04$1 implements IA {
                @Override
                public void cry() {
                    System.out.println("老虎叫唤...");
                }
            }
         */
        //7. jdk底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1实例，并且把地址
        //   返回给 tiger
        //8. 匿名内部类使用一次，就不能再使用
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger的运行类型=" + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();

//        IA tiger = new Tiger();
//        tiger.cry();

        //演示基于类的匿名内部类
        //分析
        //1. father编译类型 Father
        //2. father运行类型 Outer04$2
        //3. 底层会创建匿名内部类
        /*
            class Outer04$2 extends Father{
                @Override
                public void test() {
                    System.out.println("匿名内部类重写了test方法");
                }
            }
         */
        //4. 同时也直接返回了 匿名内部类 Outer04$2的对象
        //5. 注意("jack") 参数列表会传递给 构造器
        Father father = new Father("jack"){

            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型=" + father.getClass());//Outer04$2
        father.test();

        //基于抽象类的匿名内部类
        Animal animal = new Animal(){
            @Override
            void eat() {
                System.out.println("小狗吃骨头...");
            }
        };
        animal.eat();
    }
}

interface IA {//接口
    public void cry();
}
//class Tiger implements IA {
//
//    @Override
//    public void cry() {
//        System.out.println("老虎叫唤...");
//    }
//}
//class Dog implements  IA{
//    @Override
//    public void cry() {
//        System.out.println("小狗汪汪...");
//    }
//}

class Father {//类
    public Father(String name) {//构造器
        System.out.println("接收到name=" + name);
    }
    public void test() {//方法
    }
}

abstract class Animal { //抽象类
    abstract void eat();
}

注意：基于类的匿名内部类一定要有大括号，如果没有大括号的话就变成了对象的创建。当然基于对象的匿名内部类也要有大括号。
比如

Father father = new Father("jack"){

            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };

匿名内部类既是一个类的定义，同时其本身又是一个对象，因此可以直接调用匿名内部类的方法
举例

class out01{
    public void f1(){
         new Person(){
            @Override
            void hi() {
                System.out.println("匿名内部类重写了hi方法");;
            }
        }.hi();
         Person person = new Person(){
             @Override
             void hi() {
                 System.out.println("匿名内布类重写了hi方法 哈哈哈");
             }
         };
         person.hi();
    }
}
class Person{
    void hi(){
        System.out.println("外部类的hi方法");
    }
}

匿名内部类可以访问外部类的所有成员，外部其他类不能访问匿名内部类，因为用完一次就销毁。
如果外部类和匿名内部类的成员重名时，匿名内部类的访问默认遵守就近原则，如果想访问外部列则可以使用（外部类.this.成员）去访问

匿名内部类的实践
当作实参直接传递，简单高效

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

        //当做实参直接传递，简洁高效
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("这是一副名画~~...");
            }
        });
        //传统方法
        f1(new Picture());

    }

    //静态方法,形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}
//接口
interface IL {
    void show();
}
//类->实现IL => 编程领域 (硬编码)
class Picture implements IL {

    @Override
    public void show() {
        System.out.println("这是一副名画XX...");
    }
}

成员内部类

class Outer08 { //外部类
    private int n1 = 10;
    public String name = "张三";

    private void hi() {
        System.out.println("hi()方法...");
    }

    //1.注意: 成员内部类，是定义在外部内的成员位置上
    //2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    public class Inner08 {//成员内部类
        private double sal = 99.8;
        private int n1 = 66;
        public void say() {
            //可以直接访问外部类的所有成员，包含私有的
            //如果成员内部类的成员和外部类的成员重名，会遵守就近原则.
            //，可以通过  外部类名.this.属性 来访问外部类的成员
            System.out.println("n1 = " + n1 + " name = " + name + " 外部类的n1=" + Outer08.this.n1);
            hi();
        }
    }
    //方法，返回一个Inner08实例
    public Inner08 getInner08Instance(){
        return new Inner08();
    }


    //写方法
    public void t1() {
        //使用成员内部类
        //创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}

成员内部类时定义在外部类的成员位置，并且没有static修饰

可以直接访问外部类的所有成员，包含私有的
可以使用修饰符，因为本质是成员
和外部类的其他成员一样，为整个类体比如前面的案例，在外部类的成员方法中创建成员内部类对象，在调用方法
成员内部类直接可以访问外部类的成员。
外部类访问成员内部类：先创建兑现再访问
外部其他类访问内部成员类
外部类和内部类成员重名时，默认遵循就近原则，如果要调用外部类成员，则外部类名.this.成员

静态内内部类
静态内部类是定义在外部类的成员位置，并且有static修饰

package com.hspedu.innerclass;

public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();

        //外部其他类 使用静态内部类
        //方式1
        //因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //方式2
        //编写一个方法，可以返回静态内部类的对象实例.
        Outer10.Inner10 inner101 = outer10.getInner10();
        System.out.println("============");
        inner101.say();

        Outer10.Inner10 inner10_ = Outer10.getInner10_();
        System.out.println("************");
        inner10_.say();
    }
}

class Outer10 { //外部类
    private int n1 = 10;
    private static String name = "张三";
    private static void cry() {}
    //Inner10就是静态内部类
    //1. 放在外部类的成员位置
    //2. 使用static 修饰
    //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    //4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    //5. 作用域 ：同其他的成员，为整个类体
    static class Inner10 {
        private static String name = "韩顺平教育";
        public void say() {
            //如果外部类和静态内部类的成员重名时，静态内部类访问的时，
            //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
            System.out.println(name + " 外部类name= " + Outer10.name);
            cry();
        }
    }

    public void m1() { //外部类---访问------>静态内部类 访问方式：创建对象，再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }

    public Inner10 getInner10() {
        return new Inner10();
    }

    public static Inner10 getInner10_() {
        return new Inner10();
    }
}

可以直接访问外部类的所有静态成员，包括私有的，但是不能访问非静态成员
可以添加任意访问修饰符，包括私有的
作用域同类体
外部类访问内部类：先创建对象再访问
外部其他类访问静态内部类（两种方式如上）
重名问题通常默认就近原则，若要访问外部类成员则外部类名.成员去访问

崔可夫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
内部类（重点）

基本介绍一个类的内部又嵌套了另一个类的结构。被嵌套的类被称为内部类，嵌套其他类的类叫做外部类。类的五大成员：属性方法构造器代码块内部类内部类的最大特点是可以直接访问私有属性，并且可以体现类和类之间的包含关系。基本语法...
复制链接

扫一扫

专栏目录