成员内部类

package java_person;

//外部类
public class Person {
    int age;

    public Heart getHeart(){
        return new Heart();
    }

    //成员内部类
    class Heart{
        public String beat(){
            return "心脏在跳动";
        }
    }
}

获取内部类对象实例的三种方式：

package java_person;

public class PersonTest {
    public static void main(String[] args) {
        Person lili = new Person();
        lili.age = 12;

        //获取内部类对象实例，方式一：new 外部类.new 内部类
        Person.Heart myHeart = new Person().new Heart();
        System.out.println(myHeart.beat());

        //获取内部类对象实例，方式二：外部类对象.new 内部类
        myHeart = lili.new Heart();
        System.out.println(myHeart.beat());

        //获取内部类对象实例，方式三：外部类对象.获取方法
        myHeart = lili.getHeart();
        System.out.println(myHeart.beat());
    }
}

输出：

心脏在跳动
心脏在跳动
心脏在跳动

内部类可以直接访问外部类的成员：

package java_person;

//外部类
public class Person {
    int age;

    public Heart getHeart(){
        return new Heart();
    }

    public void eat(){
        System.out.println("人会吃东西");
    }

    //成员内部类
    /**
     * 1.内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化
     * 2.内部类的访问修饰符，可以任意，但是访问范围会受到影响
     */
    class Heart{
        public String beat(){
            eat();
            return age + "岁的心脏在跳动";
        }
    }
}

再次查看获取内部类对象实例的三种方式的输出结果：

人会吃东西
0岁的心脏在跳动
人会吃东西
12岁的心脏在跳动
人会吃东西
12岁的心脏在跳动

可看到方式一中age的输出是默认值 0 ，那是因为方式一中对Person重新实例化了。而方式二、三使用已经实例化的lili。

如果出现同名属性，优先访问内部类中定义的：

class Heart{
    int age = 13;
    public String beat(){
        eat();
        return age + "岁的心脏在跳动";
    }
}

再次输出：

人会吃东西
13岁的心脏在跳动
人会吃东西
13岁的心脏在跳动
人会吃东西
13岁的心脏在跳动

若想访问外部类中同名的信息，可以使用外部类.this.成员的方式：

class Heart{
    int age = 13;
    public String beat(){
        eat();
        return Person.this.age + "岁的心脏在跳动";
    }
}

外部类访问内部类信息，需要通过内部类实例，无法直接访问：
内部类：

class Heart{
    int age = 13;
    int temp = 22;
    public String beat(){
        eat();
        return Person.this.age + "岁的心脏在跳动";
    }
}

外部类中：

public Heart getHeart(){
        new Heart().temp = 12;
        return new Heart();
    }

总结

 * 1.内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化
 * 2.内部类的访问修饰符，可以任意，但是访问范围会受到影响
 * 3.内部类可以直接访问外部类的成员；如果出现同名属性，优先访问内部类中定义的
 * 4.可以使用外部类.this.成员的方式，访问外部类中同名的信息
 * 5.外部类访问内部类信息，需要通过内部类实例，无法直接访问
 * 6.内部类编译后的.class文件命名：外部类$内部类.class