面向对象——内部类

1.概念

在一个类的内部定义一个新类，即内部类，
另一个类称之为外部类。

2.分类

根据位置：
    成员内部类
    方法内部类（局部内部类）
带static修饰词的：
    静态内部类
没有名称的：
    匿名内部类

3.不常用的内部类

（1）方法内部类：
    定义在方法中，相当与局部变量，仅限与在方法中使用，
    定义时不能使用修饰词，可以直接访问外部类的非静态成员变量

/**
 * 方法内部类的学习
 */
public class A {
    char gender;

    public void run() {
        //在方法中定义了一个B类
        class B {
            String name;
            int age;

            public B(String name, int age) {
                this.name = name;
                this.age = age;
            }

            public void ShowB() {
                System.out.println(name + "，" + age + "，" + gender);
            }
        }
        //不能在run()方法外使用
        B b = new B("翠花", 18);
        b.ShowB();
    }

    public static void main(String[] args) {
        A a = new A();
        a.run();
    }
}

（2）静态内部类
    以类的成员来定义的，只是多了一个修饰词static，
    可以直接访问外部类的静态成员

/**
 * 静态内部类
 * */
public class C {
    String name;
    D d = new D(12);
    public void run() {}

    static class D{
        int age;
        public D(int age) {
            this.age = age;
        }
        //静态内部类可以直接访问外部类的静态成员
        public void showD() {
            //name为非静态成员
            //System.out.println(age+"，"+name);
        }
    }
}

4.常用的内部类

（1）成员内部类
    以类的成员来定义，可以使用任何修饰词来修饰

    1.成员内部类访问外部类
        方法内隐藏一个指向外部类对象的引用
        外部类名.this.

    2.外部类访问成员内部类的成员
        在外部添加一个内部类的成员变量进行访问

    3.成员内部类的使用
        先创建一个外部类对象，
        然后外部类对象使用new调用内部类的构造器实例化

public class Mom {
    char gender;
    int age;
    /** 添加一个内部类的成员变量 */
    Baby baby;

    public Mom(char gender, int age) {
        this.gender = gender;
        this.age = age;
        baby = new Baby('m');
    }

    public void sport() {
        System.out.println("正在走路");
        /** 访问成员变量的信息 */
        System.out.println("为了肚子里的孩子" + baby.toString());
    }

    /** 以成员的身份定义一个胎儿类型 */
    class Baby {
        char gender;

        public Baby(char gender) {
            this.gender = gender;
        }

        /** 展示自己的行为 */
        public void show() {
            /**
             * 内部类访问外部类的成员
             * 方法内隐藏一个指向外部类对象的引用 外部类名.this.
             */
            System.out.println("妈妈的年龄" + Mom.this.age + "，" + "我自己的性别：" + gender);
        }
        public String toString() {
            return "gender:"+gender;
        }
    }
}

public class TestMom {
    public static void main(String[] args) {
        /**如果想创建一个内部类对象
         *  首先应有一个外部类的对象*/
        Mom mama = new Mom('f',23);
        Baby b = mama.new Baby ('m');

        mama.sport();
        b.show();
    }
}

（2）匿名内部类
    没有名字的类，写在外部类的方法中，
    只用一次，不需要定义类的结构，
    通常都是为了实现接口，抽象类或某一现有的类的子类

语法格式：   
    = new 想使用子类的父类 (){};
    大括号里重写接口或抽象类中的所有抽象方法，或重写要实现的方法

public class Test {
    public static void main(String[] args) {
        //匿名内部类较为常用
        InterX ix = new InterX() {
            public void sum(int a, int b) {
                System.out.println(a + b);
            }

            public void mul(int a, int b) {
                System.out.println(a * b);
            }
        };
        ix.sum(5, 3);
        ix.mul(4, 8);
    }
}

interface InterX {
    public void sum(int a, int b);

    public void mul(int a, int b);
}