【JAVASE_学习笔记】内部类

【JAVASE_学习笔记】内部类

内部类：在一个类的内部定义另外一个类，另外一个类称为内部类
内部类的class文件名：外部类$内部类.class
内部类的类型：成员内部类：在外部类的成员位置
　　　　　　　局部内部类：在外部类的局部位置
内部类的好处：可以直接访问外部类的所有成员
应用场景：在描述A事物时，A事物内部还维护了另外一个B事物，且B事物必须要访问到A事物的成员，这时可以用内部类来描述B事物

成员内部类

访问方式：
　　　　　方式一：在外部类提供一个方法创建内部类的对象进行访问
　　　　　方式二：在其他类中直接创建内部类的对象进行访问
　　　　　Outer.Inner inner=new Outer().new Inner();
　　　　格式：外部类.内部类　变量名=new　外部类（）.new 　内部类（）；
举例：

//测试类
public class Demo1 {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.useMethod();
        //直接在测试类中创建内部的对象进行访问
        Outer.Inner oi=new Outer().new Inner();
        oi.method();
    }
}
//外部类
class Outer{
    String name;
    //内部类
    class Inner{
        public void method(){
            System.out.println("今天是个学习Java的好日子！");
        }
    }
    //外部类提供一个方法创建内部类的对象进行访问
    public void useMethod(){
        Inner i=new Inner();
        i.method();
    }
}

注意：
　　　1.内部类可以访问外部类的所有成员（包括私有）
　　　2.内部类与外部类存在同名成员时，在内部类中默认是访问内部类的成员，可以通过“外部类.this.成员”进行指定访问外部类的成员
　　　3.私有的成员内部类只能通过在外部提供一个公共的方法进行访问，在其他类无法访问（private只是为了数据安全）
　　　4.如果一个成员内部类定义了静态的成员，则该类也必须使用static修饰，静态成员内部类只能访问外部类的static成员变量
　　　因为：静态成员变量是不依赖对象而存在的
　　　
静态成员内部类在其他类创建对象的格式：
　　外部类.内部类　变量名=new　外部类.内部类（）；
举例：

//测试类
public class Demo2 {
    public static void main(String[] args) {
        Outer2.Inner2 oi2=new Outer2.Inner2();
        oi2.getStaticParm();//损伤
        Outer2 o=new Outer2();
        o.method();//心脏  人体
    }
}
//外部类
class Outer2{
    String type="人体";
    int age;
    static String mod="损伤";
    //私有的内部类
    private class Inner{
        String type="心脏";
        public void getparm(){
            System.out.println(type);
            System.out.println(Outer2.this.type);//可以通过外部类.this.成员指定访问外部类的成员
        }
    }
    //成员内部类定义了静态的成员，该类也必须用static修饰
    static class Inner2{
        private int weight;
        static String color;
        //静态成员内部类只能访问静态的成员变量
        public void getStaticParm(){
            System.out.println(mod);
        }
    }
    //私有的成员内部类只能用外部类的方法进行访问
    public void method(){
        Inner i=new Inner();
        i.getparm();
    }
}

局部内部类

如果局部内部类要访问局部变量，则局部变量必须用final修饰（jdk1.8不会报错——封装好了）
举例：

//测试类
public class Demo3 {
    public static void main(String[] args) {
        Outer3 o=new Outer3();
        o.method();//10
    }
}
//外部类
class Outer3{
    String name;
    public void method(){
        final int a=10;//被局部内部类访问的局部变量必须用final修饰
        //局部内部类
        class Inner{
            public void getParm(){
                System.out.println(a);
            }
        }
        //局部内部类可以在外部类的局部方法内，局部内部类外创建内部类的对象访问内部类的方法
        Inner i=new Inner();
        i.getParm();
    }
}

匿名内部类

没有类名的内部类
使用前提：必须存在继承或者实现关系
举例：

//测试类
public class Demo4 {
    public static void main(String[] args) {
        Outer4 o=new Outer4();
        o.print();
    }
}
//抽象类
abstract class Animal{
    public abstract void eat(); 
} 
//接口
interface Hibernation{
    public abstract void hibernation();
    public abstract void sleep();
}
class Outer4{
    public void print(){
        //创建的是Animal的子类对象
        new Animal(){
            public void eat() {
                System.out.println("猫吃鱼");
            }
        }.eat();//猫吃鱼
        //当接口中有多个方法时，运用多态可以调用多个方法
        Hibernation h=new Hibernation(){
            public void hibernation(){
                System.out.println("有些动物会冬眠");
            }
            public void sleep() {
                System.out.println("有些动物会进行深层睡眠");
            }
        };
        h.hibernation();//有些动物会冬眠
        h.sleep();//有些动物会进行深层睡眠
    }
}