面向对象之内部类

内部类

概述
	把类定义在其他类的内部
访问特点
	内部类可以直接访问外部类的所有成员 
	外部类需要创建内部类对象才可以访问内部类的成员
内部类位置
	外部类成员位置 
		成员内部类(没有static修饰) 
		静态内部类(有static修饰)
	外部类局部成员位置 
		局部内部类(有类名)
        匿名内部类(没有类名)

---

成员内部类

修饰符
	private 为了保证数据的安全性
	static 为了方便访问数据
注意事项
	成员方法可以是静态和非静态的
成员内部类调用方式
	外部类名.内部类名 对象名 = new 外部类名().new 内部类名();

//非静态成员内部类
//要求：使用已知的变量，在控制台输出30，20，10。
class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);//(内部类.)this.成员变量
            System.out.println(Outer.this.num);//外部类.this.成员变量
        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
         //调用方式
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

---

静态内部类

修饰符
	static 为了方便访问数据
注意事项
	静态内部类访问的外部类数据必须使用静态修饰符
	成员方法可以是静态和非静态的
静态内部类调用方式
	外部类名.内部类名 对象名 = new 外部类名.内部类名();

//静态成员内部类
//要求：使用已知的变量，在控制台输出30，20，10。
class Outer {
    public static int num = 10; //静态的变量静态内部类才可以访问
    static class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);
            System.out.println(Inner.this.num);//(内部类.)this.成员变量
            System.out.println(Outer.num);//外部类.成员变量
        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        //调用方式
        Outer.Inner oi = new Outer.Inner();
        oi.show();
    }
}

---

局部内部类

修饰符
	final修饰 让数据还可以使用 final修饰符局部变量都可以使用
	不能添加其他访问修饰符 因为它就是一个局部变量 局部变量不能使用修饰符
注意事项
	局部内部类可以直接访问外部类数据
使用方法
	创建内部类对象 对象调用内部类方法 

class Outer {
    private int age = 10;
    public void show(){
        //局部内部类
        class Inner{
            public void word(){
                System.out.println(Outer.this.age);
            }
        }
        //创建内部类的对象 通过对象来调用内部类方法
        Inner inner = new Inner();
        inner.word();
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

---

匿名内部类

概述
	局部内部类的简化
格式
	new 类名或者接口名(){
		重写方法;
	} ;
本质
	继承了一个类或者实现了一个接口的子类匿名对象

例题1 调用匿名内部类

class Test{
    public static void main(String[] args) {
        B b = new B();
        b.bb();// hahah
    }
}
//接口 还可以是抽象类
interface IA{
    void show();
}
class B{
    public void bb(){
        //创建了匿名内部类
        IA ia = new IA() {
            @Override
            public void show() {
                System.out.println("hahah");
            }
        };
        ia.show();
    }
}

例题2 匿名内部类当做实参传值

//抽象类 也可以是接口
abstract class Person {
    public abstract void show();
}
class PersonDemo {
    public void method(Person p) {
        p.show();
    }
}
class PersonTest {
    public static void main(String[] args) {
        //如何调用PersonDemo中的method方法呢?
        
        PersonDemo personDemo = new PersonDemo();
        //把匿名内部类当做实参直接传递
        personDemo.method(new Person() {
            @Override
            public void show() {
                System.out.println("Person");
            }
        });
        
    }
}

例题3 匿名内部类值传递

interface Inter {
    public static final int a = 23 ;
}
public class Test {
    public static void main(String[] args) {
        new Inter() {
            int a = 20;
            public void show() {
                //this 代表匿名内部类
                System.out.println(a);//20  或this.a
                System.out.println(Inter.a);//23

            }
        }.show();
    }
}