Java—面向对象(高)——内部类

咕咕猫_

已于 2022-03-03 17:01:47 修改

阅读量328

点赞数 1

分类专栏：笔记文章标签： java

于 2022-03-02 20:46:01 首次发布

本文链接：https://blog.csdn.net/weixin_61843013/article/details/123237860

版权

笔记专栏收录该内容

111 篇文章 5 订阅

订阅专栏

一、基本介绍

一个类的内部又完整的嵌套了另一个类的结构，被嵌套的类称为内部类，嵌套其他类的类称为外部类。内部类是我们类的第五大成员【1.属性 2.方法 3.构造器 4.代码块 5.内部类】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类的包含关系

二、基本语法

class Outer{ //外部类

class Innter{ //内部类

}

}

class Other{} //外部其它类

三、内部类的分类

定义在外部类的局部位置上(比如方法中)：

1.局部内部类(有类名)

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

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

1.成员内部类(没用static修饰)

2.静态内部类(使用static修饰)

四、局部内部类的使用

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

1.可以直接访问外部类的所有成员，包括私有的

2.不能添加访问修饰符，但是可以使用final修饰

3.作用域：仅仅是定义它的方法或代码块中

4.局部内部类---访问--->外部类的成员【访问方式：直接访问】

5.外部类---访问--->局部内部类的成员【访问方式：先创建对象再访问(注意：必须在作用域内)】

6.外部其它类---不能访问--->局部内部类（因为局部内部类地位是一个局部变量）

7.如果外部类和局部内部类的成员重名时，默认遵守就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

小结：1.局部内部类定义在方法或代码块中

2.作用域在方法体或代码块中

3.局部内部类本质仍然是一个类

五、匿名内部类的使用

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

1.匿名内部类的基本语法

new 类或接口(参数列表){

类体

}；

2.因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此可以调用匿名内部类的方法

3.可以直接访问外部类的所有成员，包括私有的

4.不能添加访问修饰符，因为它的地位就是一个局部变量

5.作用域：仅仅在定义它的方法或代码块中

6.匿名内部类---访问--->外部类成员【访问方式：直接访问】

7.外部其他类---不能访问--->匿名内部类（因为匿名内部类的地位是一个局部变量）

8.如果外部类和匿名内部类的成员重名时，匿名内部类访问的话默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

六、成员内部类的使用

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

1.可以直接访问外部类的所有成员，包括私有的

2.可以添加任意访问修饰符(public、protected、默认、private)，因为它的地址就是一个成员

3.作用域：和外部类的其他成员一样，为整个类体；在外部类的成员方法中创建成员内部类对象，再调用方法

4.成员内部类---访问--->外部成员类(比如属性)【访问方式：直接访问】

5.外部类---访问--->成员内部类【访问方式：先创建对象再访问】

6.外部其他类---访问--->成员内部类

7.如果外部类的成员和内部类的成员重名时，内部类访问的话会默认遵守就近原则，如果想访问外部类的成员，可以使用（外部类名.this.成员）访问

七、静态内部类的使用

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

1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员

2.可以添加任意访问修饰符(public、protected、默认、private)，因为它的地位就是一个成员

3.作用域：同其他的成员，为整个类体

4.静态内部类---访问--->外部类(比如静态属性)【访问方式：直接访问所有静态成员】

5.外部类---访问--->静态内部类【访问方式：先创建对象再去访问】

6.外部其它类---访问--->静态内部类

7.如果外部类的成员和静态内部类的成员重名时，静态内部类访问时默认遵守就近原则，如果想访问外部类的成员，则可以使用（外部类名.成员）去访问

小结：1.内部类有四种：局部内部类、匿名内部类、成员内部类、静态内部类

2.重点掌握匿名内部类使用

局部内部类的使用案例

package com.learn.innterclass_;

/**
 * 演示局部内部类的使用
 */
public class LocallnnerClass {
    public static void main(String[] args) {
        //演示
        Outer02 outer02 = new Outer02();
        outer02.m1();
    }
}

class Outer02{ //外部类
    private int n1 = 100;
    private void m2(){ //私有方法
        System.out.println("m2()");
    }
    public void m1(){ //方法
        //1.局部内部类是定义在外部类的局部位置，通常在方法
        //3.不能添加访问修饰符，但是可以使用final修饰
        //4.作用域：仅仅在定义它的方法或代码块中
        class Innter02{ //局部内部类(本质仍然是一个类)
            //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);
                m2();
            }
        }
        //6.外部类在方法中，可以创建Innter02对象实例，然后调用方法即可使用
        Innter02 innter02 = new Innter02();
        innter02.f1();
    }
}

匿名内部类的使用案例

package com.learn.innterclass_;

/**
 * 演示匿名内部类的使用
 */
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类只是使用一次，后面不再使用
        //4.可以使用匿名内部类来简化开发
        //5.tiger的编译类型是什么？ IA
        //6.tiger的运行类型是什么？ 运行类型就是匿名内部类 XXXX => 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();


//        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 Father{ //类
    public Father(String name) { //构造器
        System.out.println("接受到的name=" + name);
    }
    public void test(){ //方法

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

成员内部类的使用案例

package com.learn.innterclass_;

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();
        //第二种方式，在外部类中编写一个方法，可以返回
        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 class Inner08{ //成员内部类
        private double say = 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.say);
    }
}

静态内部类的使用案例

package com.learn.innterclass_;

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. 可以添加任意访问修饰符，因为它的地位就是一个成员
    //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();
    }
}

package com.learn.innterclass_;

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);
    }
}

//抽象类/接口...

咕咕猫_

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java—面向对象(高)——内部类

一、基本介绍一个类的内部又完整的嵌套了另一个类的结构，被嵌套的类称为内部类，嵌套其他类的类称为外部类。内部类是我们类的第五大成员【1.属性 2.方法 3.构造器 4.代码块 5.内部类】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类的包含关系二、基本语法class Outer{ //外部类 class Innter{ //内部类 }}class Other{} //外部其它类三、内部类的分类定义在外部类的局部位置上(比如...
复制链接

扫一扫