java内部类|四大内部类笔记总结

有的时候我也是挺服我自己的。。。用了这么久的Markdown Nice编辑器，我都不知道咋用，今天倒好，突然发现这玩意还能排版主题风格，尤其是我的代码风格!!!哎呦，我到现在才发掘我之前排版的什么鬼东西，看着就像一坨shi😫

废话不多说，直入主题。

内部类

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class), 嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员属性、方法、构造器、代码块、内部类 ,内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系内部类是学习的难点，同时也是重点，后面看底层源码时，有大量的内部类

内部类的分类

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

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

2)匿名内部类(没有类名,重点!!!）

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

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

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

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

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

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

3.局部内部类—访问—- >外部类的成员[访问方式:直接访问]

4.外部类–访问—->局部内部类的成员访问方式:创建对象，再访问(注意:必须在作用域内)

5.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员=>使用外部类名.this.成员去访问

package InnerClass;

public class InnerClass01 {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
    }
}
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 = 900;
            public void f1(){
                //5.局部内部类可以直接访问外部类的成员，比如下面外部类n1和m2()
                //7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员
                //=>使用外部类名.this.成员)去访问
                //Outer02.this本质就是外部类的对象，即哪个对象调用了m1, Outer02. this就是哪个对象
                System.out.println("n1=" + n1 + "外部类n1=" + Outer02.this.n1);
                m2();
            }
        }
        //6.外部类在方法中，可以创建Inner02对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
}

匿名内部类的使用(重要!!!!!)

(1)本质是类(2)内部类(3)该类没有名字 (4)同时还是一个对象

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

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

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

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

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

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

6.匿名内部类–访问—->外部类成员

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

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

package InnerClass;

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}

class Outer04 {//外部类
    private int n1 = 100;

    public void method() {
        //1.需求:想使用IA接口，并创建对象
        //2.传统方式，是写一个类，实现该接口，并创建对象
        //3.需求：是Tiger类只是使用一次，后面再不使用
        //4.可以使用匿名内部类来简化开发
        //5.tiger的编译类型 IA
        //6.tiger的运行类型 就是匿名内部类 xxxx=》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();

        //基于类的匿名内部类
        //1. father编译类型Father
        //2. father运行类型Outer04$2
        //3. 底层会创建匿名内部类
        /*
       class Outer04$2 extends Father{
        @Override
            public void test() {
                System.out.println("匿名内部类重写了 test()");
            }
         }
         */
        //这个参数列表"yg"会传递给构造器
        Father father = new Father("yg") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了 test()");
            }
        };
        father.test();

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

        //也可以直接调用，匿名内部类本身也是返回对象
        new Person() {
            @Override
            public void ok(String str) {
                super.ok(str);
            }
        }.ok("uigy");
    }
}

interface IA {
    public void cry();
}

class Father {
    public Father(String name) {
        System.out.println("接收到name=" + name);
    }

    public void test() {
    }
}

abstract class Animal {
    abstract void eat();
}

class Person {
    private String str;

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

参直接传递，简介高效

package InnerClass;

public class AnonymousInnerDetail {
    public static void main(String[] args) {
        //当作实参传递，简介高效,用一次就用这个，用多次就用下面这个传统方法
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("yjhguhiuho");
            }
        });
        //传统方法
        f1(new AA());
    }

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

interface IL {
    void show();
}

//传统方法
class AA implements IL {
    @Override
    public void show() {
        System.out.println("yjhguhiuho");
    }
}

练习题

package InnerClass;

public class AnonymousInnerDetail {
    public static void main(String[] args) {
//        AAA aaa = new AAA();
//        aaa.say();
        CellPhone cellPhone = new CellPhone();
        //1.传递的是实现了BeLl接口的匿名内部类InnerClassExercise02$1
        //2. 重写了ring
        //3. Bell bell = new BeLl() {
        //        @Override
        //        public void ring() {
        //        System.out.println("懒猪起床了");
        //        }
        // }
        cellPhone.alarmclock(new Bell() {
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });
        cellPhone.alarmclock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴上课了");
            }
        });
    }
}
//class AAA{//外部类
//    public void say(){
//        Bell CellPhone = new Bell() {//匿名
//            @Override
//            public void ring() {
//                System.out.println("懒猪起床了");
//                System.out.println("小伙伴上课了");
//            }
//        };
//        CellPhone.ring();
//    }
//}
interface Bell{//接口
    void ring();
}

class CellPhone{
    public void alarmclock(Bell bell){//形参是Bell接口类型
        bell.ring();//动态绑定
    }
}

成员内部类

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

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

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

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

4.成员内部类—访问—- >外部类成员(比如: 属性) [访问方式:直接访问] 5.外部类–访向—–>成员内部类访问方式: 创建对象，再访问 6.外部其他类—访问—->成员内部类

7.和前面的一毛一样如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问

package InnerClass;

public class iuyh {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
        //第一种方式
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
        //第二种方式 在外部类中编写一个方法 可以返回Inner08对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();
    }
}

//成员内部类,是定义在外部类的成员位置上
class Outer08 {
    private int n1 = 90;
    public String name = "iuh";

    private void hi() {
    }

    class Inner08 {
        private int sal = 31;
        public void say() {
            //可以直接访问外部类的所有成员，包含私有的
            System.out.println("n1=" + n1 + "name=" + name);
            hi();
        }
    }

    public Inner08 getInner08Instance() {
        return new Inner08();//返回一个Inner08()实例
    }

    public void t1() {
        //使用成员内部类
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}