Java内部类的分类以及注意事项

    

目录

    

1、成员内部类：直接在类中定义的类

​    2、方法内部类：在一个类中的方法内定义一个类

    3、静态内部类，在类中定义一个静态修饰的内部类

    4、匿名内部类就是没有名字的内部类。

---

1、成员内部类：直接在类中定义的类

示例：

public class Demo {
    public static void main(String[] args) {
        Person p1=new Person();//创建Person对象
        Person.Student s1=p1.new Student();//创建Student对象
        s1.print();
    }
}
class Person{
    class Student
    {
     public void print()
     {
         System.out.println("这是一个成员内部类");
     }
    }
}

运行结果：

这是一个成员内部类 

（注意：在类外部创建对象写法：Person.Student s1=p1.new Student(); 其中，Student为Person的内部类,在外部创建成员内部类的实例,因为成员内部类需要依赖外部类的对象,
在Java项目中不建议这样的写法，一般建议在外部类中定义一个方法，对外提供访问内部类的接口
）

例如：

public class Demo {
    public static void main(String[] args) {
        Person p1=new Person();//创建Person对象
        p1.StudentPrint();
    }
}
class Person{
    public void StudentPrint()
    {
        Student s1=new Student();
        s1.print();
    }
    class Student
    {
     public void print()
     {
         System.out.println("这是一个成员内部类");
     }
    }
}

​
    2、方法内部类：在一个类中的方法内定义一个类

        (1)方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化
        (2)方法内部类对象不能使用该内部类所在方法的非final局部变量。

public class Demo {
    public static void main(String[] args) {
        Person p1=new Person();//创建Person对象
        int a=200;
        p1.test(a);
    }
}
class Person{

    public void test(final int a)
    {

        //方法内部类
        class Student
        {final int a=10;
            public void print()
            {
                System.out.println("这是一个方法内部类"+a);
            }
        }
        Student s2=new Student();
        s2.print();
    }

}

  （注意：因为局部变量直接存储在栈中，当方法执行结束，非final的局部变量就被销毁，而局部内部类对局部变量的引用依然存在，当局部内部类要调用局部变量时，就会出错，出现非法引用。因此，在Java中，局部内部类如果调用了方法中的变量，那么该变量必须申明为final类型（jdk1.8之前，之后不写默认为final））

    3、静态内部类，在类中定义一个静态修饰的内部类

        静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。
        静态嵌套类仅能访问外部类的静态成员和方法。

public class Demo {
    public static void main(String[] args) {
        Person p1=new Person();//创建Person对象
        p1.s1.print();
    }
}
class Person{
    static int a=10;
    Student s1=new Student();
static class Student
{

    public void print()
    {
        System.out.println("静态内部类方法被调用"+a);
    }
}


}

（注意：静态内部类无法使用外部的非静态变量和方法，静态内部类可以访问外部类的静态成员和方法。 可以直接通过外部类的名称来访问静态成员和方法） 

    4、匿名内部类就是没有名字的内部类。

匿名内部类的三种情况：
        （1）继承式的匿名内部类

public class Demo {
    public static void main(String[] args) {
        Person p1=new Person();//创建Person对象
        p1.test1();
    }
}
class Person{
public void test1()
{
    Student student=new Student(){
        public void study()
        {
            System.out.println("我爱学习");
        }
    };
    student.study();
}
}
interface study
{
    public void study();
}
abstract class Student
{
    public abstract void study();
}

        （2）接口式的匿名内部类

public class Demo {
    public static void main(String[] args) {
        Person p1=new Person();//创建Person对象
        p1.test1();
    }
}
class Person{
public void test1()
{
    study s=new study() {
        @Override
        public void study() {
            System.out.println("我爱学习2");
        }
    };
    s.study();
}
}
interface study
{
    public void study();
}
abstract class Student
{
    public abstract void study();
}

        （3）参数式的匿名内部类

public class Demo {
    public static void main(String[] args) {
        Person p1=new Person();//创建Person对象
        p1.test1(new study() {
            @Override
            public void study() {
                System.out.println("我爱学习3");
            }
        });
    }
}
class Person{
public void test1(study s)
{
    s.study();
}
}
interface study
{
    public void study();
}
abstract class Student
{
    public abstract void study();
}