如何去理解四大内部类

　　由于对内部类不是很熟悉,将内部类相关知识进行整理,达到深入理解的目的.

　　定义:内部类,一个类嵌套在另一个类中,这样的类.我们称为内部类.

　　内部类的种类:

1. 静态内部类

2. 成员内部类

3. 局部内部类

4. 匿名内部类

   静态内部类

   由static修饰,不依赖外围对象实例独立存在,因为类在编译过程中,会事先准备好所有的静态属性方法,静态成员,所以静态内部类可以访问外部类的所有静态属性.不受外部类约束.

   成员内部类

   成员内部类:定义在类的内部,与外部类中的成员方法,成员变量同级,成员内部类可以访问外部类所有的成员方法包括私有属性,成员内部类更像是外部类中成员之一.

   可以这么去理解,当外部类没有创建对象时,外部类中的成员方法,成员变量没有被初始化,因此这时候成员内部类不知道该创建哪个成员的变量.

   成员内部类对象一直隐含的表示对外部类的对象的引用.

   用个例子来表示

   public class Teacher {
        private Student m;
        private String name;
        public void subject(){
            System.out.println("我教语文");
        } 
        public class Student{
            private int age;
            private String name;
        }
   }

　　　　Student就是Teacher的成员内部类,当new一个老师对象的时候,我们知道老师他底下有学生,但是成员内部类更重要的表现老师类下面的成员变量学生的具体实例化,即成员内部类的对象属于m.new()出的具体实例.

　　　　局部内部类

　　局部内部类:就是在方法、构造器、初始化块中声明的类,且不能使用访问修饰符,因为是局部变量,局部内部类的局部变量已经被fina修饰,不能再更改了.

因此如果局部内部类只是在静态环境中,只能访问外部类的静态成员,不能范围外围类中非静态成员,当局部内部类定义在实例环境中,这个限制将被取消,这是因为java的编译机制决定的.

public class Outclass {
    int a=10;
    //在静态块下的局部内部类
    static{
        class inclass1{
            //int b=a; 这个写法是错误的,因为在静态块的局部变量不能访问外部元素
        }
    }
    //非静态块的下的局部内部类
    {
        class inclass2{
            int c=a;  //这个是允许的,因为局部内部类定义在实例环境中,可以访问外部类的全局变量
        }
    }
    //构造器中的局部内部类
    public Outclass(){
        class inclass3{
            //这里可以访问所有类的成员
        }
    }
    //方法中的局部内部类
    public void method(){
        class inclass4{
            //同理可以访问所有类的成员
        }
    }
}

　　　　匿名内部类

　　匿名内部类:和局部内部类很像,可以当做一个局部内部类但是隐藏了类的名字,但是唯一不同的,匿名内部类在被创建出来就会调用,并且返回一个此内部类的一个引用对象.

当不用匿名内部类有以下代码:

?
abstract class Person {
    //抽象类中有抽象方法
        public abstract void eat();
    }
        //有子类Child继承抽象类Person
    class Child extends Person {
        //重写抽象类中的方法
        public void eat() {
            System.out.println("eat something");
        }
    }
public class Demo {
        public static void main(String[] args) {
            //子类new对象
            Person p = new Child();
            //对象p调用子类中的方法
            p.eat();
        }
    }

使用匿名内部类后代码为:

abstract class Person {
    //抽象类中有抽象方法
        public abstract void eat();
    }
?
public class Demo {
        public static void main(String[] args) {
            //Person为抽象类或者接口,无法直接new对象(抽象类或者接口中无具体实现抽象方法的方法体)
            Person p = new Person()
            //此处为隐藏了匿名内部类实际的名称Child
            //并且实现Person抽象类或者接口中的具体方法,并返回一个该类的对象
            {
                @Override
                public void eat() {
                }
                };
            //对象p调用子类中的方法
            p.eat();
        }
    }

　　从上面的例子中,我们可以看出来匿名内部类的优缺点:

　　优点:编码更加简洁,快捷

　　缺点:匿名内部类的实际名被隐藏,不易发现,难理解

　　　　只能继承一个类或实现一个接口不能再继承其他类或其他接口

　　　　只能创建一次实例化对象

如何去理解四大内部类

原文：https://www.cnblogs.com/daoyouzhanzhu/p/11405569.html