内部类

基本介绍：

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class)。是我们类的第五大成员[类的五大成员：属性、方法、构造器、代码块、内部类]，内部类的最大特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系；

package com.example.InnerClass;



/**
 * @author gaoqinghui
 * @date 2022/4/30 22:13
 */
public class InnerClass01 {
    public static void main(String[] args) {

    }
}

class Outer {//外部类
    private int n1 = 100;   //属性

    public Outer(int n1) {  //构造器
        this.n1 = n1;
    }

    {//代码块
        System.out.println("代码块....");
    }
    
    class Inner {//内部类，在Outer类的内部
        
    }
}

内部类的分类

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

  • 局部内部类(有类名)
  • 匿名内部类(没有类名)

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

  • 成员内部类(没用static修饰)
  • 静态内部类(使用static修饰)

局部内部类

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

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

2.不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final；

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

4.局部内部类直接访问外部类的成员，无论是否是私有；

5.外部类访问局部内部类的成员的访问方式：在作用域中创建对象，再和以前创建类那样访问. 注意：必须在作用域中；

6.局部内部类本质还是一个类，五大成员都可以定义；

7.外部其他类不能访问局部内部类，因为局部内部类地位是一个局部变量；

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

具体的(外部类名.this.成员)解释看下面代码

package com.example.InnerClass.localinnerclass;

/**
 * @author gaoqinghui
 * @date 2022/4/30 22:51
 */
public class LocalInnerClass {
    public static void main(String[] args) {
        Outter outter = new Outter();
        outter.m1();
    }
}


class  Outter{
    private int n1 = 100;
    private void m2(){

        System.out.println("m2方法被调用");
    }

    public void m1(){
        //1.局部内部类是定义在外部类的局部位置，通常在方法
        //3.不能添加访问修饰符，但是可以使用final修饰内部类
        //4.作用域：仅仅在在定义它的方法或者代码块中
        final class Inner {//局部内部类(本质还是一个类，五大成员都可以定义)
            //2.可以直接访问外部类的所有成员，包含私有的
            private int n1 = 800;
            public void f1(){
                //5.局部内部类可以直接访问外部类的成员，
                
                //6.如果外部类和局部内部类的成员重名时，默认遵循就近原则，
                // 如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问
                //Outter.this本质就是外部类的对象，即哪个对象调用了上面m1这个方法，谁就是Outter.this
                // 我们上面是outter.m1();定义的，所以Outter.this就是outter这个对象引用。这个类就是Outter;
                System.out.println("n1=" + n1 + " 外部类的n1=" + Outter.this.n1);
                m2();
            }
        }
        //6.外部类在方法中，可以创建Inner对象，然后调用方法
        Inner inner = new Inner();
        inner.f1();
    }

}

匿名内部类

匿名内部类的使用

匿名内部类的使用细节

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

package com.example.anonymousclass.anonymousclass;

/**
 * @author gaoqinghui
 * @date 2022/5/3 15:09
 * 匿名内部类
 */
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}

class Outer04 {//外部类
    private int n1 = 10;    //属性
    public void method(){
        //基于接口的匿名内部类
        //需求：使用IA接口，并创建对象
        //2.传统方式，s写一个类，实现接口并创建对象
        //3.现在需求Tiger类只使用一次，后面不再使用
        //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("老虎叫唤");
            }
        };
        tiger.cry();
        System.out.println("tiger运行类型名字=" + tiger.getClass());

        //演示基于类的匿名内部类
        //分析：
        //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方法");
            }
        };
        father.test();
        System.out.println("father的运行类型=" + father.getClass());


        //基于抽象类的匿名内部类
        Animal animal = new Animal(){
            @Override
            public 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);
    }

    public void test(){

    }
}

abstract class Animal {
    abstract public void eat();
}

实例：

package com.example.anonymousclass.anonymousclassdetail;


/**
 * @author gaoqinghui
 * @date 2022/5/3 15:48
 */
public class AnonymousClassDetail {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
    }
}

class Outer05 {//外部类
    private int n1  = 99;
    public void f1(){

        //创建一个基于类的匿名内部类
        //p的编译类型是Person，运行类型是Outer05$1
        Person p = new Person(){

            private int n1 = 100;
            @Override
            public void hi() {
                //可以直接访问外部类的所有成员，包括私有
                //不能添加访问修饰符，因为它的地位就是一个局部变量
                //作用域：仅仅再定义它的方法或代码块中

                //如果外部类和匿名内部类的成重名时，匿名内部类访问的化默认遵守就近原则，
                //如果想访问外部类的成员则可以使用(外部类名.this.成员)去访问
                System.out.println("匿名内部类重写了hi方法 n1= " + n1 +
                        "外部类的n1= " + Outer05.this.n1);
                //Outer05.this就是调用f1的对象，谁调用f1，Outer05.this就是谁
            }
        };
        p.hi(); //动态绑定，运行类型是Outer05$1

        //也可以直接调用,匿名内部类本身也是返回对象

        new Person(){
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了Person类，哈哈啊哈");
            }

            @Override
            public void ok(String name) {
                super.ok(name);
            }
        }.ok("gao");
    }
}
class Person {
    public void hi(){
        System.out.println("Person hi() ");
    }

    public void ok(String name){
        System.out.println("ok()" + name);
    }
}
//抽象类和接口都可以写

匿名内部类当作实参参数

package com.example.anonymousclass.anonymousclassexercise;


/**
 * @author gaoqinghui
 * @date 2022/5/3 16:59
 */
public class AnonymousClassExercise {
    public static void main(String[] args) {
        //当作实参直接传递
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("这是一副名画");
            }
        });

    }

    public static void f1(IL il) {
        il.show();
    }
    
}

interface IL {
    void show();
}

实例：

package com.example.anonymousclass.anonymousclassexercise;

/**
 * @author gaoqinghui
 * @date 2022/5/3 17:19
 * 1.有一个铃声接口 Bell，里面有个 ring 方法。(右图)
 * 2.有一个手机类 Cellphone，具有闹钟功能 alarmClock，参数是 Bell 类型(右图)
 * 3.测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印：懒猪起床了
 * 4.再传入另一个匿名内部类(对象)，打印：小伙伴上课了
 */
public class AnonymousClassExercise02 {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();

        //解释：
        //1.传递的是实现了Bell接口的匿名内部类
        //2.重写了ring方法

        cellphone.alarmclock(new Bell() {
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });

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

interface Bell {
    void ring();
}

class Cellphone {
    public void alarmclock(Bell bell){
        bell.ring();
    }
}

成员内部类

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

1. 可以直接访问外部类的所有成员，包括私有
2. 可以添加任意访问修饰符，因为它的地位就是一个成员
3. 作用域和外部类的其他成员一样，为整个类体
4. 成员内部类直接访问外部类成员
5. 外部类访问成员内部类，需要创建对象然后再访问
6. 外部其他类访问成员内部类两种方式看下面实例
7. 如果外部类和成员内部类的成重名时，成员内部类访问的话默认遵守就近原则，如果想访问外部类的成员则可以使用(外部类名.this.成员)去访问

package com.example.memberclass;



/**
 * @author gaoqinghui
 * @date 2022/5/3 19:13
 */
public class MemberinnerClass01 {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        outer01.hi();

        //外部其他类使用成员内部类的两种方式
        //第一种
        //outer01.new Inner01();相当于把new Inner01()当作是outer08成员
        Outer01.Inner01 inner01 = outer01.new Inner01();

        //第二种
        //在外部类种编写一个方法，可以返回Inner01对象
        Outer01.Inner01 inner011 = outer01.getInner01();
        inner011.say();

        //第三红
    }
}

class Outer01 {//外部类
    private  double sal = 99;
    private int n1 = 10;
    public String name = "张三";

    //1.可以直接访问外部类的所有成员，包含私有的
    //可以添加任意访问修饰符(public、protected、默认、private),
    // 因为它的地位就是一个成员
    class Inner01 {//成员内部类
        private double n1 = 1001;
        public void say() {
            System.out.println("n1 = " + n1 + " name = " + name +  " 外部类n1= " + Outer01.this.n1);
        }
    }

    public void hi(){
        Inner01 inner01 = new Inner01();
        inner01.say();
    }

    //方法，返回一个Inner01实例
    public Inner01 getInner01(){
        return new Inner01();
    }
}

静态内部类

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

1. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
2. 可以添加任意访问修饰符
3. 作用域同其他成员一样为整个类体
4. 可以添加任意访问修饰符
5. 作用域：同其他成员为整个类体
6. 如果内外名字冲突的话默认也是就近原则，如果想访问外部类属性直接用 类名.属性

package com.example.staticinnerclass;


/**
 * @author gaoqinghui
 * @date 2022/5/3 19:52
 */
public class StaticInnerClass {
    public static void main(String[] args) {
        Outter1 outter1 = new Outter1();
        outter1.m1();
        //外部其他类使用静态内部类
        //1.通过类名直接访问
        Outter1.Inner1 inner1 = new Outter1.Inner1();
        inner1.say();

        //2.编写一个方法，可以返回对象实例
        Outter1.Inner1 inner11 = outter1.getInner1();
        System.out.println("============");
        inner11.say();

        Outter1.Inner1 inner2 = Outter1.getInner2();
        System.out.println("**********");
        inner2.say();


    }
}
class Outter1 {
    private double n1 = 100;
    private static String name = "jack";
    private static void cry(){}
    //Inner1就是静态内部类
    //1.放在外部类的成员位置
    //2.使用static修饰
    //3.可以直接访问外部类的所有静态成员，包含私有
    //4.可以添加任意访问修饰符
    //5.作用域：同其他成员为整个类体

    static class Inner1{
        private static String name = "gaoqinghui";
        public void say(){
            //如果内外名字冲突的话默认也是就近原则，如果想访问外部类属性直接用 类名.属性
            System.out.println("name=" + name + " 外部name= " + Outter1.name);
            cry();
        }
    }

    public void m1(){//外部类访问静态内部类的访问方式：创建对象，再访问
        Inner1 inner1 = new Inner1();
        inner1.say();
    }
    public Inner1 getInner1(){
        return new Inner1();
    }

    public static Inner1 getInner2(){
        return new Inner1();
    }
}

小结：

1. 内部类有四种：局部内部类、匿名内部类、成员内部类、静态内部类
2. 重点是匿名
3. 成员内部类，静态内部类是放在外部类的成员位置，本质还是一个成员

标签：部类,内部,void,public,访问,成员
来源： https://www.cnblogs.com/gaoqinghui/p/16254649.html