Java中的内部类如何理解——详解

概念

🔥🔥🔥今天给大家讲解的是内部类以及匿名内部类，希望能够对你在Java的学习过程中起到一定的帮助。

• 内部类就是定义在一个类里面的类，里面的类可以理解为（寄生），外部类可以理解为（宿主）

public class People{
    //内部类
    public class love{
    
    }
}

📗内部类的使用场景、作用：

• 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计。
• 内部类通常可以方便访问外部类的成员，包括私有的成员。
• 内部类提供了更好的封装性，内部类本身就可以用private protectecd等修饰，封装性可以做更多控制。

🗞️内部类的分类：

静态内部类、成员内部类（非静态内部类）、局部内部类、匿名内部类

什么是静态内部类？

• 有static修饰，属于外部类本身
• 它的特点和使用与普通类是完全一样的，类有的成分它都有，只是位置在别人里面而已

public class outer{
    //静态内部类
    public class static inner{
        
    }
}

📘静态内部类创建对象的格式：

外部类名.内部类名 对象名 = new 外部类名.内部类名();

outer.inner in = new outer.inner;

public class computer {
    public static String name = "石原里美";
    public static class mouse{
        private String name ;
        private int price;

        public mouse() {
        }

        public mouse(String name, int price) {
            this.name = name;
            this.price = price;
        }

        public void buy(){
            System.out.println(computer.name+"购买了"+this.name);
        }

        public String getName() {
            return name;
        }

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

        public int getPrice() {
            return price;
        }

        public void setPrice(int price) {
            this.price = price;
        }
    }
}
//main方法
computer.mouse m = new computer.mouse("雷蛇",300);
m.buy();
//输出结果:
//石原里美购买了雷蛇

内部类可以访问外部类的静态成员，但是不能访问外部类的实例成员，因为实例成员是由对象创建的，内部类无法找到，除非在内部类中new一个对象，进行间接的访问。

什么是成员内部类？

无static修饰，属于外部类的对象

//格式
public class outer{
    public class inner{
    }
}

📙成员内部类创建对象的格式：

外部类名.内部类名 对象名 = new 外部构造器.new内部构造器();

outer.inner in = new outer().new inner();

public class computer {
    public static String name1 = "石原里美";
    private String name2 ;
    public  class mouse{
        private String name ;
        private int price;
        public void buy(){
            System.out.println(computer.name1+"购买了"+this.name);
        }

        public String getName() {
            return name;
        }

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

        public int getPrice() {
            return price;
        }

        public void setPrice(int price) {
            this.price = price;
        }
    }
}
//main方法
computer.mouse m = new computer().new mouse();
        m.setName("雷蛇");
        m.buy();
//输出结果：
//石原里美购买了雷蛇

相较于静态内部类，成员内部类，不仅可以访问外部类的静态成员变量，同时也可以访问外部类的实例成员，原因在于内部类的实例对象是在外部类创建之后而创建的，其可以直接调用之前所创建对象的实例成员。

什么是局部内部类？

局部内部类放在方法、代码块、构造器等执行体中

局部内部类的类文件名为：外部类$N内部类.class

格式（在main方法中定义）：

class 类名{

    } 

仅作了解即可

什么是匿名内部类？

本质上是一个没有名字的局部内部类，定义在方法中、代码块中、等。
作用:方便创建子类对象，最终目的为了简化代码编写。

📒格式：

new 类名|抽象类名|或者接口名(){

    重写方法;

};

People p = new People(){
    public void run(){
    }
};
p.run();

前面我们学习过了多态，通过子类的方法重写，再重新访问子类中的方法，下面来比较一下使用匿名内部类和不使用的区别：

过去的方法：

public static void main(String[] args) {
//父类       
            class People{
            void run() {

            }
        }
//子类
        class Student extends People{

            @Override
            public void run() {
                System.out.println("小学生跑的慢");
            }
        }

        People p = new Student();
         p.run();
    }
//输出结果：
//小学生跑的慢

使用匿名内部类之后:

public static void main(String[] args) {
        class People{
            void run() {

            }
        }
//匿名内部类
        People p = new People(){
            void run(){
                System.out.println("小学生跑的慢");
            }
        };
         p.run();
    }
//输出结果：
//小学生跑的慢

特点：

• 匿名内部类是一个没有名字的内部类
• 匿名内部类写出来就会产生一个匿名内部类的对象相较于之前，出现的不一样主要是：不需要实例化对象就可以重写方法，并且节省一定的代码空间。

创作不易，给个三连吧