java内部类简介

最新推荐文章于 2024-07-26 12:28:02 发布

LNsupermali

最新推荐文章于 2024-07-26 12:28:02 发布

阅读量91

点赞数

分类专栏： Java学习笔记文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/LNsupermali/article/details/131450209

版权

Java学习笔记专栏收录该内容

21 篇文章 1 订阅

订阅专栏

基本介绍

注意：以下为他人笔记转述，原视频链接如下：
【【零基础快速学Java】韩顺平零基础30天学会Java】 https://www.bilibili.com/video/BV1fh411y7R8/?p=424&share_source=copy_web&vd_source=947d2b5c7c8558f66335ee25caabf036

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其它类的类称为外部类(outer class).是我们类的第五大成员(属性，方法，构造器，代码块，内部类)，内部类最大的特点就是可以直接私有化属性，并且可以体现类与类之间的包涵关系。

基本语法

class Outer {	//外部类
	class inner {	//内部类
	
	}
}
class Other {	//外部其它类
}

内部类的分类

A.定义在外部类局部位置上(比如方法内)

1).局部内部类(有类名)
2).匿名内部类(没有类名)

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

1).成员内部类(没用static)
2).静态内部类(使用static)

局部内部类的使用

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

1.可以直接访问外部类的所有成员，包含私有的
2.不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
3.作用域：仅仅在定义它的方法或者代码块中。
4.局部内部类—访问—>外部类的成员[访问方式:直接访问]
5.外部类—访问—>局部内部类的成员。访问方式：创建对象，再访问(注意：必须在作用域内)
6.外部其它类—不能访问----->局部内部类(因为局部内部类地位是一个局部变量)
7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

注意：

1.局部内部类定义在方法中/代码块
2.作用域在方法体或者代码块中
3.本质还是一个类

代码演示:

package allDays;

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.成员）去访问
                // 本质就是外部类的对象，即哪个对象调用了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();
    }

}

匿名内部类的使用

1.本质是类
2.内部类
3.该类没有名字
4.同时还是一个对象
说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

1.匿名内部类的基本语法
new 类或接口(参数列表) {
类体
}；

代码：

package allDays;

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}
class Outer04 {
    private int n1 = 10; //属性
    public void method() {
        //基于接口的匿名内部类


        //假如想使用接口并创建一个对象，而且该类只使用一次
        //后面不在使用，则可以使用匿名内部类简化开发
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger的运行类型=" + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();


        //基于类的匿名内部类
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型=" + father.getClass());
        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();
}

细节：

1.匿名内部类的语法比较奇特，因为匿名内部类即是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码可以看出这个特点，因此可以调用匿名内部类方法
2.可以直接访问外部类的所有成员，包括私有的
3.不能添加访问修饰符，因为它的地位就是一个局部变量。
4.作用域：仅仅在定义它的方法或代码块中
5.匿名内部类 — 访问 ----> 外部类成员[直接访问]
6.外部其它类 ---- 不能访问 -----> 匿名内部类[因为匿名内部类地位是一个局部变量]
7.如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

代码:

package allDays;

/**
 * @author: ln
 * @data:
 * @description:
 */
public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();

        //外部其他类 --- 不能访问 ----> 匿名你内部类
        System.out.println("main outer05 hashcode= " + outer05);
    }
}
class Outer05 {
    private int n1 = 99;
    public void f1() {
        //创建一个基于类的匿名内部类
        //不能添加访问修饰符，因为它的地位就是一个局部变量
        //作用域: 仅仅在定义它的方法或者代码块中
        Person p = new Person() {
            private int n1 = 88;

            @Override
            public void hi() {
                //可以直接访问外部类的所有成员，包括私有的
                //如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，
                //默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)
                System.out.println("匿名内部类重写了hi方法 n1 = " + n1 + " 外部类的n1 = "
                + Outer05.this.n1);
                //Outer05.this就是调用f1的对象
                System.out.println("Outer05.this.hashcode=" + Outer05.this);
            }
        };
        p.hi();//动态绑定，运行类型是Outer05$1

        //也可以直接调用，匿名内部类本生也是返回对象
        //class 匿名内部类 extends person{}
//        new Person() {
//            @Override
//            public void hi() {
//                System.out.println("匿名内部类重写了hi方法，哈哈。。。");
//            }
//
//            @Override
//            public void ok(String str) {
//                super.ok(str);
//            }
//        }.ok("jack");

    }
}
class Person {
    public void hi() {
        System.out.println("Person hi()");
    }
    public void ok(String str) {
        System.out.println("Person ok()" + str);
    }
}

匿名内部类的最佳实践

当作实参直接传递，简洁高效

代码：

package allDays;

/**
 * @author: ln
 * @data:
 * @description:
 */
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...");
    }
}

我们可以看到:
1.传统的硬编码需要写一个类，而且若成员一但有所修改就会影响到其它的(引用了该类的部分)，而且假如实际使用到该类的地方较少，这样就会使得效率更低
2.将匿名内部类作为实际参数传递的好处就是使用一次就写一次，影响较小，简洁高效

代码;

package allDays;

/**
 * @author: ln
 * @data:
 * @description:匿名内部类作为实参的练习
 */
public class InnerClassExercise02 {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        cellphone.alarmclock(new Bell() {
            @Override
            public void ring() {
                System.out.println("懒猪起床啦...");
            }
        });

        cellphone.alarmclock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴上课了。。。。");
            }
        });
    }

}

interface Bell {
    public void ring();
}

class Cellphone {
    public void alarmclock(Bell bell) {
        System.out.println(bell.getClass());
        bell.ring();
    }
}

成员内部类的使用

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰。

1.可以直接访问外部类的所有成员，包括私有的
2.可以添加任意访问修饰符(public, protected, 默认,private),因为它的地位就是一个成员。
3.作用域和外部类的其它成员一样，为整个类体，比如前面案例。在外部类的成员方法中创建成员内部类对象，再调用方法。
4.成员内部类 — 访问 —> 外部类成员（比如属性）[访问方式：直接访问]
5.外部类 —访问 ---->成员内部类访问方式：创建对象，再访问
6.外部其他类 — 访问 —> 成员内部类
7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类.this.成员)去访问

package allDays;

/**
 * @author: 
 * @data:
 * @description:
 */
public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();

        //外部其它类，使用成员内部类的三种方式
        //第一种
        //outer08.new Inner08(); 相当于把new Inner08()当作是outer08成员
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();

        //第二种 在外部类中，编写一个方法，可以返回Inner08对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();

    }
}
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修饰

1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问静态成员
2.可以添加任意访问修饰符(public，protected，默认，private)，因为它的地位就是一个成员
3.静态内部类 — 访问 —>外部类(比如：静态属性)【访问方式：直接访问所有静态成员】
4.作用域：同其他的成员，为整个类体
5.外部类 — 访问 ----> 静态内部类访问方式：创建对象，再访问
6.外部其它类 — 访问 -----> 静态内部类
7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类.this.成员)去访问

package allDays;

/**
 * @author:
 * @data:
 * @description:
 */
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.getInner_();
        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 getInner_() {
        return new Inner10();
    }
}