Java面向对象之内部类

---

tip：以下是正文部分

一、内部类简介

一个类的内部又完整的嵌套了另一个类结构。
被嵌套的类称为内部类(inner class)，嵌套其他类的类称为外部类(outer class)

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

二、局部内部类

1.局部内部类是定义在外部类的局部位置，比如方法中，并且有类名，
2.可以直接访问外部类的所有成员，包含私有的.
3.不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。
4.可以使用final 修饰，因为局部变量也可以使用final。
5.作用域:仅仅在定义它的方法或代码块中。
6.局部内部类可以直接访问外部类。
7.外部类访问局部内部类，需要先创建对象再访问。( 注意 ： 必须在作用域内 )

三、匿名内部类

1.基本结构 ( 匿名内部类是定义在外部类的局部位置)

new 类名|接口名( ) {
};

2.匿名内部类的编译类型与运行类型。

class a{
	b a = new b(){
	} ;
	//a的编译类型为b，但是因为a为匿名内部类，
	//所以a的运行类型其实是被隐藏的名字，相当于a$1
}
class b{}

3.匿名内部类既是类，也是对象。

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

5.不能添加修饰符，因为他只是一个局部变量

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

7.匿名内部类可以直接访问外部类成员，外部类不能访问内部匿名类。

8.如果外部类与内部匿名类的成员重名时，内部类访问时，默认遵循就近原则，
可以通过 ( 类名.this.成员 ) 访问

class a{
	int num = 10;
	new a(){
		int num = 11;
		public void print(){
			System.out.println(num);//11
			System.out.println(a.this.num);//10
		}
	}
}

9.内部匿名类与编译类型构成继承。

class a{
    int num = 10;
    public void print() {
       b b = new b(){
           @Override
           //重写b父类的方法
           //证明了这个方法继承了b类
           public void yes1() {
               super.yes1();
           }
       };
        System.out.println(b.getClass());//运行类型 class a$1
    }
}
class b{
    public void yes1(){
        System.out.println("b");
    }
}

10.内部类初体验

/**
 * 1.有一个铃声接口Bell，里面有个ring方法。(右图)
 * 2.有一个手机类Cellphone，具有闹钟功能alarmclock，参数是Bell类型(右图)
 * 3.测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印:懒猪起床了
 * 4.再传入另一个匿名内部类(对象)，打印:小伙伴上课了
 */
public class main {
    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{
    void ring();
}
class cellphone{
    public void alarmclock(Bell bell){
        bell.ring();//动态绑定
    }
}

四、成员内部类

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

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

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

4.作用域：和外部类的其他成员一样，为整个类体。

5.成员内部类可以直接访问外部类成员。

6.外部类访问内部类，需要先创建对象再访问。

7.外部其他类访问内部类

public class main {
    public static void main(String[] args) {
        a.b1 b1 = new a().new b1();//第一种方式
        b b2 = new a().getB();//第二种方式
    }
}
class a{
    class b1{}//成员内部类
    public b getB(){
        return new b();
    }
}
class b{ }

五、静态内部类

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

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

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

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

5.静态内部类可以直接访问所有静态成员
注意：只能访问静态成员

6.外部类访问静态内部类，需要先创建对象再访问。

7.外部其他类访问静态内部类

public class main {
    public static void main(String[] args) {
        a.b1 b2 = new a.b1();//第一种方式
        b b3 = new a().getB();//第二种方式
    }
}
class a{
    static class b1{}//成员内部类
    public b getB(){
        return new b();
    }
}
class b{ }