JAVA编程基础

一.JAVA概述

        计算机编程语言发展史：第一代计算机编程语言是机器语言；第二代计算机编程语言是汇编语言（运行速度快，可移植性不强）；第三代计算机编程语言是高级语言

        JAVA语言发展史：Oak（橡树，Java的前身）。詹姆斯.高林斯也被誉为“Java语言之父”。在Java语言发展史中，Java分成3个版本：标准版，企业版，微型版。

        Java语言的特点：1.简单性：继承了C和C++语言的优点，而摒弃了c和c++语言中比较难的知识和易引发程序错误的地方，取消了指针。2.面向对象。3.跨平台性（最大特点）不受计算机硬件和操作系统的约束而在任意计算机环境下正常运行。4.可移植性。5.安全性。6.健壮性。7.编译和解释性。Java语言的编译程序先将Java源程序编译生成与计算器无关的字节码。8.高性能。9.动态性。能够动态的载入运行环境。10.多线性多线程是指允许一个应用程序同时存在两个或两个以上的线程。用于支持程序中的事务并发和多任务处理。11分布性。12.平台无关性。（JAVA最突出的特点）

二.int x=100；

1.数据类型

        （1）标识符标识符只能由字母，数字，下划线，美元符号组成，并且不能以数字开头。         （2）数据类型数据类型分为基本数据类型和引用数据类型。基本数据类型有数值型，字符型（char），布尔型（boolean）。竖直型又分为整型（byte，short，int，long）和浮点型（float，double）。引用数据类型分别有类接口和数组。

数据类型占用空间

数据类型	字节	位	取值范围
byte	1B	8	-128~127
short	2B	16	-32768~32767
int	4B	32	-2^31~2^31-1
long	8B	64
float	4B		-3.403*10^38~3.4.3*10^38

注：string.value of（八大基本类型）

2.变量

        （1）变量需要先声明再使用。

        （2）在一个代码块中，同一个一个变量名只能出现一次，变量名不能重复出现。

        （3）变量名的命名需要遵守小写字母开头的驼峰规则。

3.运算符

        运算符分为关系运算符，逻辑运算符，赋值运算符，算数运算符，位运算符和三元运算符。其中位运算符属于难点知识。

运算符的优先级

优先级	描述	运算符	结合性
1	括号	（）
2	正负号	+，-	从右到左
3	一元运算符	++，--，！	从右到左
4	乘除	*，/，%	从左到右
5	加减	+，-	从左到右
6	移位运算符	>>,<<,>>>	从左到右
7	比较大小	<,>,>=,<=	从左到右
8	比较是否相等	==，！=	从左到右
9	按位运算符	&	从左到右
10	按位异或运算	^	从左到右
11	按位或运算	|	从左到右
12	逻辑与运算	&&，&	从左到右
13	逻辑或运算	||	从左到右
14	三元运算符	？：	从右到左
15	赋值运算符	=	从右到左

注：算术运算符>关系运算符>逻辑运算符>赋值运算符

4.常量

        （1）常量一旦被赋值后，就不可以改变了。

        （2）常量的命名一般要求所有字母大写，单词之间使用“-”隔开。

三.程序三大结构

1.选择结构

（1）if语句

if（条件表达式）{
//代码块1
}
else if(条件表达式2){
//代码块2
}
else{
//代码块n
}

注：如果if选择结构只需执行一条语句，那么可以省略括号，为了提高代码的易读性，建议不省略。括号中的代码语句也称为代码块，在代码块定义的常量或变量的作用域仅限于代码块中在，代码块之外不能使用。

2.switch语句

switch(变量){
case 值一：
    代码块一；
    break；
case 值二：
    代码块二；
    break；
default：
    代码块n；
    break；
}

注：Switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break。语句处或者switch语句的末尾，如果全部不匹配，则进入default语句。Switch语句判断的变量中类型只能是byte，short， int， string和枚举，因此它适用范围较窄，但对于精确值的判断switch仍然是非常方便的。

2.循环结构

（1）for语句

for（循环初始化表达式；循环条件表达式；循环后操作表达式）{
    //循环体；
}

（2）while语句

while（条件表达式）{
    //循环体；
}

（3）do……while语句

do{
    //循环体；
}while（条件表达式）；

3.选择语句

四.数组

1、一维数组
(1)声明数组变量
        为了在程序中使用数组，必须声明一个引用数组的变量，并指明数组的元索类型。
声明数组变量的语法：
        

elementType[] arrayRefVar;//(元素类型[] 数组引用变量 ;)
elementType arrayRefVar[];//(元素类型 数组引用变量[];)

elementType 可以是任意数据类型，数组中所有的元素都必须具有相同的数据类型
arrayRefVar 是数组变量名，遵循用户自定义标识符规则
(2)数组创建及初始化
不同于基本数据类型变量的声明，声明一个数组变量时并不在内存中给数组分配任何空间。它只是创建一个对数组的引用的存储位置。
当给数组分配空间时，必须指定该数组能够存储的元素个数，从而确定数组大小。创建数组之后就不能再修改它的大小。
为数组变量分配内存空间

elementType[] arrayRefVar = new elementType[arraySize];
(元素类型[] 数组引用变量 =new 元素类型[ 数组大小];)
elementType arrayRefVar[] = new elementType[arraySize];
(元素类型数组引用变量 =new 元素类型[ 数组大小];)

数组初始化
数组元素的默认值：
当创建数组后，它的元素被赋予默认值，数值型基本数据类型的默认值为 0, char 型的默认值为 '\u0000'，boolean 型的默认值为 false。
创建数组对象并同时赋予初始值
将声明数组、创建数组和初始化数组结合到一条语句中

elementType[] arrayRefVar = {value0, value1, valuek}

数组初始化语法中不使用操作符 new。使用数组初始化语法时，必须将声明、创建和初始化数组都放在一条语句中。将它们分开会产生语法错误。
初始化匿名数组：

new elementType[]{value0,value1,value2...};

这种表示方法将创建一个新数组并利用括号中提供的值进行初始化，数组的大小就是初始值的个数，使用这种语法形式可以在创建新变量的情况下重新初始化数组。

arrayRefVar = new elementType[]{value0,value1,value2...};

(3)访问数组元素
数组元素可以通过下标访问。数组下标其范围从0开始到arrayRefVar.length-1结束。
当给数组分配空间时，必须指定该数组能够存储的元素个数，从而确定数组大小。创 建数组之后就不能再修改它的大小。可以使用 arrayRefVar.length 得到数组的大小
数组中的每个元素都可以使用下面的语法表示，称为下标变量（indexed variable)
arrayRefVar[index];
(数组引用变量[下标];)
循环遍历数组：
计数for循环：

for ( int i = 0;i < arrayRefVar.length ; i++){
System.out.println(arrayRefVar[i]);
}

增强for each循环

for ( int element:arrayRefVar){
System.out.println(element);

(4)数组拷贝
浅拷贝 一个数组变量拷贝给另一个数组变，这时，两个变量将引用同一个数组

elementType[] new_array = arrays ;

该语句并不能将arraysl引用的数组内容复制给new_array, 而只是将arraysl的引用值复制给了new_array。在这条语句之后，arrays和new_array 都指向同一个数组，实际上是将一个数组的引用复制给另一个变量，使两个变量都指向相同的内存地址。
深拷贝
一个数组的所有值拷贝到另个新的数组中去，
复制数组的方法：
循环赋值
使用 Arrays 类的 copyOf 方法

elementType[] new_array = Arrays. copyOf(arrays, arrays.length);

这个方法通常用来增加数组的大小：如果数组元素是数值型 ，那么多余的元素将被赋值为0; 如果数组元素是布尔型 ，则将赋值false相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。
使用 System 类中的静态方法 arraycopy

arraycopy(sourceArray, srcPos, targetArray, tarPos, length);

参数 srcPos 和 tarPos 分别表示在源数组 sourceArray 和目标数组 targetArray 中的起始位置
arraycopy 方法没有给目标数组分配内存空间。复制前必须创建目标数组以及分配给它的内存空间。
(5)命令行参数
每个Java应用程序的main方法带有的String[] 参数是一个字符串数组。
向 main 方法传递字符串
java TestMain arg0 arg1 arg2
运行程序时，可以从命令行给 main 方法传递字符串参数：其中，参数 arg0、arg1 和 arg2 都是字符串，但是在命令行中出现时，不需要放在双引号中。这些字符串用空格分隔。如果字符串包含空格，那就必须使用双引号括住。
​使用命令行参数
当调用 main 方法时，Java 解释器会创建一个数组存储命令行参数，然后将该数组的引用传递给 args。使用args[index]调用命令行参数。
如果运行程序时没有传递字符串，那么使用 new String[0]创建数组。在这种情况下，该数组是长度为 0的空数组。args 是对这个空数组的引用。因此，args 不是 null,但是 args.length 是 0。
Java 应用程序的 main 方法中，程序名并没有存储在 args 数组中
2、多维数组
(1)声明多维数组变量
        数据类型[]...[] 数组名;
        数据类型 数组名[]...[];// 允许这种方式 ，但并不推荐使用它
(2)多维数组初始化
        为数组变量分配内存空间
        

elementType[]...[] arrayRefVar = new elementType[arraySize0]...[arraySizen];

(元素类型[]...[] 数组引用变量 =new 元素类型[数组大小]...[数组大小];)
int[][] matrix;

        为数组变量赋初值
        

elementType[]...[] arrayRefVar = {{value},...,{value}}; 

每一维的长度可以不同，这类数组叫做锯齿形数组
(3)访问多维数组元素
        数组元素可以通过下标访问。
      

  arrayRefVar[index0]...[index1];

一.面向对象的概念
1.1什么是面向对象
        面向对象是一种计算机编程的范式，它基于现实世界中的对象来构建软件系统。面向对象的核心概念是“对象”，每个对象都拥有数据（属性）和操作这些数据的方法（行为），对象之间通过发送和接收消息来进行通信。

1.2面向对象的特性
         面向对象的主要特点包括封装，继承和多态。封装是将数据和操作数据的代码捆绑在一起，形成一个独立的单元；继承是一个类（子类）可以继承另一个类（父类）的属性和方法；多态是指不同的对象可以对同一消息做出响应。

补：面向对象的四大基本特征：封装，多态，继承和抽象。

1.3类与对象
        类（Class）：类是对象的蓝图或模板，描述了具有相同的属性和方法的对象的集合。

public class MyClass {
    // 定义属性（成员变量）
    private int myInt;
    private String myString;
 
    // 构造方法，用于创建对象时的初始化
    public MyClass() {
        // 默认初始化
        myInt = 0;
        myString = null;
    }
 
    // 定义方法（成员函数）
    public void setMyInt(int value) {
        this.myInt = value;
    }
 
    public int getMyInt() {
        return myInt;
    }
 
    public void setMyString(String value) {
        this.myString = value;
    }
 
    public String getMyString() {
        return myString;
    }
}

以下是关于Java类定义的一些关键点：

访问修饰符：Java类可以有不同的访问修饰符，如public、private、protected或默认无修饰符。这决定了其他类如何访问该类及其成员。

成员变量：类中的变量称为成员变量或属性。它们定义了对象的状态。在上面的例子中，myInt和myString就是成员变量。

构造方法：构造方法是用于创建类的新实例的特殊方法。它具有与类名相同的名称，并且没有返回类型。在上面的例子中，有一个无参数的构造方法。

方法：类可以包含方法，这些方法定义了类的行为。方法可以带有参数，并可以返回一个值（如果有返回值的话）。在上面的例子中，有四个方法用于设置和获取成员变量的值。

封装：在Java中，封装是一种重要的面向对象编程概念。它意味着将数据（属性）和操作数据的方法绑定在一起，以形成一个独立的对象。通过封装，可以隐藏对象的内部状态和实现细节，只提供公共的接口供外部使用。在上面的例子中，通过将成员变量声明为私有（private），实现了封装。

访问器和方法：为了从外部获取或设置私有成员变量的值，通常需要提供公共的“访问器”方法（也称为getter和setter方法）。在上面的例子中，有四个访问器方法用于获取和设置myInt和myString的值。

        对象（Object）：对象是类的实例，是类的具体表现形式。每个对象都有相同的属性和行为，但可以有不同的状态。

1.对象的创建与使用

（1）定义类：首先，你需要定义一个类。

public class MyObject {
    // 属性（字段）
    private String name;
    private int age;
 
    // 方法（行为）
    public void setName(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    // 其他方法...
}

（2）创建对象：一旦你定义了类，你就可以创建该类的对象。这是通过使用new关键字并调用类的构造函数来完成的。

MyObject myObject = new MyObject(); // 创建一个新的MyObject对象实例
（3）初始化对象：在创建对象后，你可能需要初始化其属性。这通常通过调用对象的setter方法来设置其属性值来完成.

myObject.setName("Alice"); // 设置对象的name属性值
myObject.setAge(25); // 设置对象的age属性值
（4）使用对象：一旦对象被创建并初始化，你就可以使用它的方法来执行操作或获取其属性值。

String objectName = myObject.getName(); // 获取对象的name属性值
二.构造方法
构造方法是用于初始化新创建的对象的方法。它具有与类名相同的名称，并且没有返回类型（包括void）。

public class Person {
    private String name;
    private int age;
 
    // 默认构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }
 
    // 带参数的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    // 其他方法，如getter和setter等
    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;
    }
}

注意：一个类可以有多个构造方法，只要它们的签名（参数列表）不同。这在Java中被称为构造方法的重载（Overloading）。通过使用重载的构造方法，你可以为类的对象提供多种不同的初始化方式。

三.this关键字
3.1引用当前对象
this关键字用于引用当前对象实例。当你在一个对象的成员方法内部需要引用这个对象本身时，你可以使用this。

public class MyClass {
    private int value;
 
    public void setValue(int value) {
        this.value = value; // 使用this来引用当前对象的value字段
    }
}
3.2构造器中的使用
在构造器中，你可以使用this来引用当前构造器中的参数，以区分局部变量和类的成员变量。

public class MyClass {
    private int value;
 
    public MyClass(int value) {
        this.value = value; // 使用this来区分构造器的参数和类的成员变量
    }
}
3.3在方法中明确当前对象
有时，在方法内部你可能需要明确表示你正在操作的是当前对象，而不是其他对象。这在你处理类似集合或数组等可能引起混淆的场景时特别有用。

3.4与继承的关系
当在一个子类的方法中使用this时，它通常指的是子类对象本身，而不是父类对象。但是，在某些情况下，你可能需要明确地使用super来引用父类。

注意事项：虽然this在某些情况下非常有用，但过度使用它可能会使代码难以阅读和理解。因此，建议只在真正需要明确当前对象时使用它。在大多数情况下，如果代码清晰明了，那么不使用this也是可以的。

四.static关键字
4.1静态变量

        静态变量也称为类变量，因为它们属于类本身，而不是类的任何特定实例。所有实例共享相同的静态变量。静态变量在类加载时初始化一次，之后所有实例都可以访问这个变量。

public class MyClass {
    public static int staticVar = 0; // 静态变量
}
4.2静态方法（Static Methods）
        静态方法也属于类本身，而不是任何特定实例。因此，你可以通过类名直接调用静态方法，而无需创建类的实例。

public class MyClass {
    public static void staticMethod() { // 静态方法
        // ... 方法体 ...
    }
}
五.包
5.1包的概念
包是一种将相关的类组织在一起的方式，以便更好地管理和重用代码。

5.2Java包的主要作用包括
1.代码组织：通过将相关的类放在同一个包中，可以使代码结构更加清晰。

2.防止命名冲突：不同的包可以有相同的类名，只要它们在不同的包中。

3.访问控制：Java的访问修饰符（如public、protected、默认（包内）访问和private）与包的概念相结合，可以控制类的访问级别。

4封装：包可以封装一组相关的类和方法，形成一个独立的单元。

5.3包的定义
package com.example.myapp;
 
public class MyClass {
    // 类定义
}
六.面向对象的四大基本特征
6.1封装
封装是将数据（属性）和对数据的操作（方法）绑定起来，隐藏对象的内部状态，只对外提供公共访问方式。这有助于保护数据的安全性和完整性。

1.封装数据：在Java中，我们可以通过将数据（属性）定义为私有（private）来实现封装。这意味着其他类不能直接访问或修改这些数据。相反，我们提供公共（public）方法（通常称为getter和setter方法）来允许其他类以受控的方式访问和修改这些数据。

2.隐藏实现细节：封装不仅隐藏了数据的实际细节，还隐藏了对象如何工作的细节。这有助于我们保护代码的内部工作机制，只暴露必要的接口给外部使用。

3.提高代码安全性：通过封装，我们可以限制对对象数据的直接访问，从而减少错误的可能性。只有通过我们提供的公共方法，才能以正确的方式访问和修改数据。

4.代码重用和扩展性：封装使得我们可以创建可重用的代码块（即类），这些类可以单独编译和测试。此外，由于封装了数据和操作数据的方法，我们可以更容易地扩展或修改类的功能，而不会影响其他使用该类的代码。

5.类设计：在Java中，类是封装的主要单位。一个类可以包含多个方法和属性，这些方法和属性一起定义了类的行为和状态。通过将相关的属性和方法组合在一起，我们可以创建一个有意义的类，这个类可以代表现实世界中的一个实体或概念。

public class Person {
    // 私有属性
    private String name;
    private int age;
 
    // 公共构造方法，用于创建对象并初始化属性
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
 
    // 公共getter和setter方法，用于访问和修改私有属性
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        if (age > 0) { // 添加一些验证逻辑
            this.age = age;
        } else {
            System.out.println("Age must be positive.");
        }
    }
}

Person类封装了姓名和年龄这两个属性。只有通过提供的公共方法（getter和setter），外部代码才能访问或修改这些属性。
6.2继承
1.继承是面向对象编程的一个核心概念，允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以扩展或修改父类的功能，而无需重新编写父类的代码

2.使用关键字：使用extends关键字来声明一个类继承另一个类。例如，class SubClass extends ParentClass表示SubClass继承了ParentClass。

3.继承的层次结构：Java支持多层继承，这意味着一个类可以继承另一个类，而这个类又可以继承另一个类，以此类推。这种层次结构有助于组织代码和实现代码重用。

4.访问修饰符：在Java中，访问修饰符（如public、protected、default（包级私有）和private）决定了其他类如何访问一个类的成员（属性和方法）。继承时，子类只能访问父类的公共和受保护成员。

5.方法的重写（Override）：子类有时可能需要修改从父类继承的方法的行为。在这种情况下，子类可以使用与父类方法相同名称和参数列表的方法，并使用@Override注解来明确表示这是一个重写的方法。这样，当子类对象调用该方法时，将执行子类中的实现，而不是父类中的实现。

6.super关键字：在子类中，可以使用super关键字来引用父类的成员。例如，super.methodName()用于调用父类的某个方法，super.variableName用于访问父类的某个变量。

7.继承的优缺点：

优点：代码重用、扩展功能、组织代码结构。

缺点：可能导致代码复杂性和耦合性增加，需要谨慎设计类和继承层次结构以避免不必要的复杂性。

8.默认继承：如果一个类没有明确使用extends关键字继承另一个类，那么它仍然隐式地继承了Object类的所有方法和属性。Object是Java中所有类的超类。

6.3多态
1.多态是指同一个接口可以由多种不同的类来实现。在运行时，根据对象的实际类型来确定调用哪个实现。这增加了代码的灵活性和可扩展性。

2.多态主要基于继承和接口，以及方法的重写（Override）和重载（Overload）。下面是一些关于Java面向对象多态的关键点：

（1）继承：在Java中，一个类可以继承另一个类的属性和方法。这使得我们可以创建一个通用的类，然后通过继承来创建更具体的类。

（1）方法重写（Override）：在子类中，可以重写父类中的方法。这意味着子类提供了一个与父类同名但实现不同的方法版本。当通过父类引用调用该方法时，实际上会执行子类中的版本。

（2）多态性：这是当同一个接口引用可以指向多个不同类型对象时的行为。通过使用继承和方法重写，我们可以在运行时确定实际调用的方法版本。

（3）虚拟方法调用：在Java中，通过使用关键字virtual（尽管Java不直接使用此关键字，但概念相似），可以在运行时根据对象的实际类型来确定调用哪个方法。这就是多态的核心。

（4）实例化与引用：当你创建一个对象的实例时，你实际上是在创建一个特定类型的对象。但是，你可以使用一个更通用的类型（如父类类型）来引用这个对象。这就是多态性的一个关键点：使用父类类型的引用指向子类对象。

（5）动态绑定：在运行时，Java会根据对象的实际类型来确定调用哪个方法。这就是动态绑定或晚期绑定。

3.多态的实现

class Animal {
    void makeSound() {
        System.out.println("The animal makes a sound");
    }
}
 
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("The dog barks");
    }
}
 
class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("The cat meows");
    }
}
 
public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Dog();  // 使用Animal类型引用Dog对象
        Animal animal2 = new Cat();  // 使用Animal类型引用Cat对象
        
        animal1.makeSound();  // 实际上调用的是Dog的makeSound方法，输出"The dog barks"
        animal2.makeSound();  // 实际上调用的是Cat的makeSound方法，输出"The cat meows"
    }
}

6.4抽象类
1.概念：包含抽象方法和非抽象方法的类。抽象类不能直接实例化，只能作为其他类的基类。

2.抽象类的定义与使用

public abstract class Animal {
    // 字段
    private String name;
 
    // 构造方法
    public Animal(String name) {
        this.name = name;
    }
 
    // 非抽象方法
    public void eat() {
        System.out.println(name + " is eating.");
    }
 
    // 抽象方法，子类必须实现这个方法
    public abstract void makeSound();
}

七.Object类
Object类是所有类的超类，也就是说，所有的Java类都继承自Object类。Object类位于java.lang包中，因此在使用时无需显式导入。

Object类中定义了一些常用的方法，这些方法可以在任何对象上使用。以下是Object类中的一些主要方法：

1.equals(Object obj)：用于比较两个对象的内容是否相等。默认实现是比较对象的引用，通常需要子类重写以实现基于内容的比较。

2.hashCode()：返回对象的哈希码值，常与equals()方法一起使用在哈希表等数据结构中。

3.toString()：返回对象的字符串表示形式。默认实现返回类名和哈希码的无意义字符串，通常需要子类重写以提供更有意义的描述。

4.getClass()：返回对象的运行时类。

5.clone()：创建并返回对象的一个副本。默认实现可能并不适用于所有对象，通常需要子类重写以提供正确的克隆行为（注意，对于不可变对象或那些不应被克隆的对象，这个方法可能并不适用）。

6.finalize()：当垃圾收集器准备回收对象时调用此方法。这是一个保护性机制，通常不建议子类重写它，因为它依赖于具体的垃圾收集实现和时机。

八.接口
Java接口是一种定义方法但不实现方法的特殊类型。接口可以被看作是一种契约，定义了类应该具备的行为。任何类都可以实现一个接口，并按照接口中定义的方法进行实现。

// 定义一个接口
public interface Animal {
    void eat();
    void sleep();
}
// 实现Animal接口的Dog类
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog eats food.");
    }
 
    @Override
    public void sleep() {
        System.out.println("Dog sleeps.");
    }
}

九.final关键字
9.1定义
final是一个关键字，它用于修饰类、方法或变量。final的主要目的是确保其修饰的元素在程序中是不可变的。

9.2实现
public final class FinalExample { // final类
    public static final String CONSTANT_VALUE = "这是一个常量值"; // final静态变量
    private final int finalValue; // final实例变量，必须在声明时或构造器中初始化
    
    public FinalExample(int value) { // 构造器，finalValue必须在构造器中初始化
        this.finalValue = value;
    }
    
    public final void finalMethod() { // final方法，不能在子类中被重写
        // ... 方法实现 ...
    }
}
十.内部类概述

内部类（Inner Class）是定义在一个类内部的另一个类。内部类提供了更好的封装和数据隐藏，并且可以更方便地访问外部类的属性和方法

定义与分类：成员内部类：定义在类的内部，但不作为外部类的方法存在。它可以访问外部类的所有成员（包括私有成员）。

局部内部类：定义在方法内部的类。它只能访问外部类的局部变量（如果这些变量是final的）。

静态内部类：在内部类前加上static关键字，使其成为静态内部类。静态内部类不依赖于外部类的实例，可以直接通过类名调用。

匿名内部类：没有名字的局部内部类，常用于简化代码编写，特别是实现接口或继承类的场景。
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/2303_76278234/article/details/137693383