Java学习笔记之---内部类

（一）成员内部类

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

实例

public class People {
    private String name;
    private int age;
    public Heart getHeart(){
        //外部类访问内部类信息，需要通过内部类实例，无法直接访问
        new Heart().temp=12;
        return new Heart();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void eat(){
        System.out.println("人会吃东西");
    }
    //内部类的访问修饰符可以任意，但是访问范围会受到影响
    public class Heart{
        int temp=10;
        int age=12;

        public void beat(){
            //内部类可以直接访问外部类的成员，如果出现重名属性，优先访问内部类中定义的
           // System.out.println(name+"的"+age+"心脏在跳动");
            //可以使用外部类.this.成员的方法，访问外部类中同名的信息
            System.out.println(name+"的"+People.this.getAge()+"心脏在跳动");
        }
    }

}
class PeopleTest{
    public static void main(String[] args){

        People a=new People();
        a.setName("zhang");
        a.setAge(10);
        //获取内部类对象实例  方法1：new 外部类.new 内部类
//        People.Heart aa=new People().new Heart();
//        aa.beat();
        //获取内部类对象实例  方法2：外部对象.内部类
//         People.Heart aa=a.new Heart();
//         aa.beat();
         //获取内部类对象实例  方法3：外部类对象.获取方法
        People.Heart aa=a.getHeart();
        aa.beat();
    }
}

（二）静态内部类

静态内部类中只能访问外部类中的静态成员，如果要访问非静态的成员，需要通过对象实例
静态内部类实例时，可以不依赖于外部类对象
可以通过外部类.内部类.成员的方式，访问内部类中的静态成员
当内部类属性于外部类属性同名时，默认直接调用内部类的成员
如果要访问外部类中的静态属性，可以通过外部类.属性的方式
如果要访问外部类中的非静态属性，可以通过 new 外部类（）.属性的方式

实例

public class People {

    private String name;

    private static int age;

    public String getName() {

        return name;

    }



    public void setName(String name) {

        this.name = name;

    }



    public int getAge() {

        return age;

    }



    public void setAge(int age) {

        this.age = age;

    }

    public void eat(){

       Heart c= new Heart();

       c.temp=12;

        System.out.println(c.temp+"人会吃东西");

    }

    //内部类的访问修饰符可以任意，但是访问范围会受到影响

    public static class Heart{

        int temp=10;

        int age=12;



        //静态内部类中只能访问外部类中的静态成员，如果要访问非静态的成员，需要通过对象实例

        public static void say(){

            String ll=new People().getName();

            //如果要访问外部类中的静态属性，可以通过 外部类.属性 的方式

            //如果要访问外部类中的非静态属性，可以通过 new 外部类（）.属性 的方式

            System.out.println(ll+People.age+new People().getName());



        }

    }



}

class PeopleTest{

    public static void main(String[] args){



        People a=new People();

        a.setName("zhang");

        a.setAge(10);

        //静态内部类实例时，可以不依赖于外部类对象

       People.Heart aa=new People.Heart();

       //当内部类属性于外部类属性同名时，默认直接调用内部类的成员

       People.Heart.say();

    }

}

（三）方法内部类

定义在方法内部，作用范围也在方法内
和方法内部成员使用规则一样，class前面不可以添加public，private，protected，static
类中不能包含静态成员
类中可以包含final，abstract修饰的成员

实例

public class People {

    private String name;

    private static int age;

    public String getName() {

        return name;

    }
    public void setName(String name) {

        this.name = name;

    }
    public int getAge() {

        return age;

    }
    public void setAge(int age) {

        this.age = age;

    }

    public Object getHeart(){

        //和方法内部成员使用规则一样，class前面不可以添加public，private，protected，static

        class  Heart{

          //类中可以包含final，abstract修饰的成员

           final int temp=10;

            int age=12;

            public String  beat(){

                System.out.println("心在跳动");

                return "心在跳动";

            }
            }

      return new Heart().beat();
    }
}
class PeopleTest{

    public static void main(String[] args){
        People a=new People();
        a.setName("zhang");
        a.setAge(10);
     System.out.println(a.getHeart());

    }
}

（四）匿名内部类

匿名内部类没有类型名称，实例对象名称
编译后的文件名：外部类$数字.class
无法使用private，public，protected，abstract，static修饰
无法编写构造方法，可以添加构造代码块
不能出现静态成员
匿名内部类可以实现接口，也可以继承父类，但不可兼得

 实例

 public abstract class Person {

    public abstract void read();

}
class PersonTest{

    public void getRead(Person a){

        a.read();

    }

    public static void main(String[] args){

        PersonTest test=new PersonTest();

        //匿名内部类没有类型名称，实例对象名称

        //无法使用private，public，protected，abstract，static修饰

        //匿名内部类可以实现接口，也可以继承父类，但不可兼得

        test.getRead(new Person() {

            //无法编写构造方法，可以添加构造代码块

            {

                //构造代码块

            }

            @Override

            public void read() {

                System.out.println("男生");

            }

        });

        test.getRead(new Person() {

            @Override

            public void read() {

                System.out.println("女生");

            }

        });
    }

}