Java学习笔记 （成员内部类、静态内部类、匿名内部类、方法内部类）

package com.imooc.People;

public class Person {
    public int age;

    public Heart getHeart(){
        new Heart().temp = 10;
        return new Heart();
    }
    public void eat(){
        System.out.println("人在吃东西");
    }


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


    public class Heart{
        int temp = 222;
        public String beat(){
            int age = 23;
            return age + "心脏在跳动"+"aaaa"+Person.this.age;
        }
    }
}

package com.imooc.People;

public class Person1 {
    public static int age = 12;

    public Heart getHeart(){
        return new Heart();
    }
    public void eat(){
        System.out.println("人在吃东西");
    }
    

    public static class Heart{
        public static int age = 222;

        public static void say(){
            System.out.println("hello");
        }
        public String beat(){
            new Person1().eat();
            return Person1.age + "岁心脏在跳动";
        }
    }
}

package com.imooc.test;

import com.imooc.People.Person;
import com.imooc.People.Person1;

public class peopletest {
    public static void main(String[] args) {
        Person1 lili = new Person1();
        lili.age = 12;
        Person1.Heart myHeart = new Person1.Heart();
        System.out.println(myHeart.beat());
        Person1.Heart.say();
    }
}

package com.imooc.People;

public class Person1 {
    public static int age;


    public Object getHeart(){
        //方法内部类
        /**
         * 1、定义在方法内部，作用范围也在方法内
         * 2、和方法内部成员使用规则一样，class前面不可以添加public\private。。。。
         * 3、类中不能包含静态成员
         * 4、类中可以包含final、abstract修饰的成员
         */
          class Heart{
            public int temp = 222;
            public int age = 23;

            public void eat(){

            }
            public String beat(){
                new Person1().eat();
                return  Person1.age + "岁心脏在跳动";
            }
        }
        return new Heart().beat();
    }

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



}

package com.imooc.anonymous;

//public class Man extends Person{
//    @Override
//    public void read() {
//        System.out.println("男生看武侠");
//    }
//}

package com.imooc.test;

//import com.imooc.anonymous.Man;
import com.imooc.anonymous.Person;
//import com.imooc.antonymous.Woman;

public class PerTest {
//     public void getRead(Man man) {
//         man.read();
//     }
//
//    public void getRead(Woman woman) {
//        woman.read();
//    }

    public void getRead(Person person) {
        person.read();
    }

    public static void main(String[] args) {
        PerTest test = new PerTest();
        //方案1
//        Man one = new Man();
//        Woman two = new Woman();
//        test.getRead(one);
//        test.getRead(two);
        /**
         * 1、匿名内部类没有类型名称、实例对象名称
         * 2、编译后的文件命名:外部类$数字.class
         * 3、无法使用private、public、abstract、static修饰
         * 4、不能编写构造方法，可以添加构造代码块
         * 5、不能出现静态成员
         * 6、匿名内部类可以实现接口也可以继承父类，但是不可兼得
         */
        test.getRead(new Person() {
            @Override
            public void read() {
                System.out.println("fuck!!!");
            }
        });
        System.out.println("=============================");
        //方案2

    }
}