Java基础学习（六）（内部类）

一、什么是内部类

类的五大成员：属性、方法、构造器、代码块、内部类

内部类：一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)，是类的第五大成员。内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

class Outer{        //外部类
        class lnner{        //内部类
        }
}
class Other{        //外部其他类

}

内部类分为4种

1. 定义在外部类局部位置（如方法内）：①局部内部类（有类名）②匿名内部类(没有类名)
2. 定义在外部类的成员位置上：①成员内部类（无static修饰）②静态内部类（有static修饰)

二、局部内部类

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

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

三、匿名内部类

1. 本质是类
2. 内部类
3. 该类没有名字（实际上系统会自动分配一个名字）
4. 同时还是一个对象

有基于接口和类的匿名内部类

以基于接口的匿名内部类为例：

需求：想使用接口，并创建对象

传统方式：是写一个类，实现该接口，并创建对象

但是由于类只是使用一次，后面再不使用，即可以使用置名内部类来简化开发

IA tiger = new IA {    //tiger的编译类型是IA
    @Override
    public void cry() {
        System.out.println("老虎叫");
    }
};
System.out.println("tiger运行类型" + tiger.getClass());//就是匿名内部类(外部类名+$1)
tiger.cry();

class XXX implements IA {         

//Jdk底层在创建匿名内部类,立即就创建了匿名内部类实例，并且把地址返回给tiger
//匿名内部类使用一次，就不能再使用
        @Override
        public void cry() {
                System.out.println("老虎叫唤...");
        }
}

基于类的与基于接口的实现一样，只需要注意类传的形参会给原来的类的构造器，基于抽象类的方法必须要实现。

Cat cat = new Cat("喵喵"){

}

 匿名内部类的语法比较奇特，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此调用匿名内部类方法有两种。

第一种调用匿名内部类方式：

Person p = new Person(){
        @Override
        public void hi() {
                System.out.println("匿名内部类重写了hi方法");
        }
};
p.hi();//动态绑定，运行类型是 Outer05$1

 第二种调用匿名内部类方式：

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

// class匿名内部类extends Person{ }

new Person(){
        @Override
        public void ok(String str) {
                super.ok(str);
        }
}.ok( "jack");

 还可以当作实参进行传递

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

f1(new IL() {
        @Override
        public void show() {
                System.out.println("这是一副名画~~。.. ");
        }
});

 四、成员内部类

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

class test {        //外部类
        private int n1 = 10;
        public String name ="张三";
        //1.注意:成员内部类，是定义在外部内的成员位置上
        //2.可以添加任意访问修饰符(public,protected ,默认,private),因为它就是一个成员

        public class Inner {        //成员内部类
                public void say() {
                //可以直接访问外部类的所有成员。包含私有的
                        System.out.println("n1= " +n1 + " name = " +name) ;
        }
}

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

五、静态内部类

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

class test {        //外部类
        private int n1 = 10;
        public String name ="张三";
        //1.是定义在外部内的成员位置上
        //2.可以添加任意访问修饰符(public,protected ,默认,private),因为它就是一个成员

        //3.使用static修饰

        public static class Inner {        //成员内部类
                public void say() {
                //可以直接访问外部类的所有成员,包含私有的,但不能直接访问非静态成员
                        System.out.println(name) ;
        }
}

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