Java基础

柔光的暖阳◎ 2024-05-05 22:07 20阅读 0赞

### 一、java的了解 ###

#### 1.1常用命令 ####

> <table style="width:500px;"> 
>  <tbody> 
>   <tr> 
>    <td>&nbsp; &nbsp; &nbsp; &nbsp; win + r，输入cmd&nbsp; &nbsp;确认/回车</td> 
>    <td>打开dos命令窗口</td> 
>   </tr> 
>   <tr> 
>    <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;dir</td> 
>    <td>查看当前目录下&nbsp; 所有子文件+子目录</td> 
>   </tr> 
>   <tr> 
>    <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;cd</td> 
>    <td>切换路径,所有的相对路径都是从当前所在目录作为起点开始查找的路径&nbsp;</td> 
>   </tr> 
>   <tr> 
>    <td>直接输入C:或 d: 回车</td> 
>    <td>q切换盘符,进去c或d盘</td> 
>   </tr> 
>   <tr> 
>    <td>&nbsp; &nbsp; &nbsp; &nbsp; del</td> 
>    <td>删除文件或目录 <strong>del *.txt </strong>【删除当前目录下所有的.txt文件】</td> 
>   </tr> 
>   <tr> 
>    <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ipconfig</td> 
>    <td>查看IP地址等信息&nbsp; <strong>ipconfig /all</strong>&nbsp; 更详细信息</td> 
>   </tr> 
>   <tr> 
>    <td>&nbsp; &nbsp; &nbsp; &nbsp; ping</td> 
>    <td>看两电脑间是否在正常通信 <strong>ping 192.168.1.123&nbsp;</strong></td> 
>   </tr> 
>   <tr> 
>    <td>&nbsp; &nbsp; &nbsp; &nbsp; shutdown</td> 
>    <td>定时关机 <strong>shutdown -s -t 7200</strong>&nbsp; 【2小时候自动关机】&nbsp;<code>-s</code>&nbsp;参数表示执行关机操作，&nbsp;<code>-t 7200</code>&nbsp;参数表示设置关机的延迟时间为 7200 秒，即2小时</td> 
>   </tr> 
>   <tr> 
>    <td>&nbsp; &nbsp; &nbsp; &nbsp; mkdir</td> 
>    <td>创建目录&nbsp; &nbsp;mkdir abc&nbsp; 【创建个名为abc的目录】 <pre><code>mkdir dir1\dir2\dir3
> //三级目录结构</code></pre> </td> 
>   </tr> 
>   <tr> 
>    <td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;cls</td> 
>    <td>清屏</td> 
>   </tr> 
>   <tr> 
>    <td>&nbsp; &nbsp; &nbsp; &nbsp; exit</td> 
>    <td>退出dos命令窗口</td> 
>   </tr> 
>   <tr> 
>    <td colspan="2"><a href="https://blog.csdn.net/JokerLJG/article/details/128954677" title="Java命令大全-CSDN博客" rel="nofollow">Java命令大全-CSDN博客</a></td> 
>   </tr> 
>  </tbody> 
> </table>

#### 1.2JDK的下载与安装 ####

[JDK下载安装以及环境配置 (baidu.com)][JDK_ _baidu.com]

[Java JDK下载安装及环境配置超详细图文教程-CSDN博客][Java JDK_-CSDN]

#### 1.3Java的注释——三种 ####

> 1.  **// 单行注释**
> 2.   **/\*  多行注释 \*/**
> 3.   **/\*\*javadoc注释，可被javadoc.exe工具提取生成帮助文档\*/ 也叫文档注释**
> 
>     /**
>      * （javadoc注释，写在这里的注释信息会被JDKbin  (文档注释)
>      * 目录下的javadoc.exe工具提取并生成帮助文档）
>      * @author 开发人员
>      * @version 1.0 版本号
>       */
>     public class Test{
>     	/*
>     	 	这是程序的入口，也称为主方法            （多行注释）
>     	 	类加载之后，程序从这里进来开始执行
>     	 */
>     	public static void main(String[] args) {
>     			System.out.println(); //换行       （单行注释）
>     		}
>     	}
>     }

#### 1.4 public class 与 class ####

一个java源文件中可以定义多个class，并且在编译的时候一个class会对应编译生成一个class字节码文件。还有，public的class可以没有。

注意：**规范的写法**是**一个java源文件中只定义一个class**

#### 1.5 java标识符 ####

标识符可以**用来标识**：类名和接口名、变量名、方法名、常量名等  
**规则**：可包含— **字母a、下划线\_、美元符合$、人民币符号￥、数字5**   
**不以数字开头**  
 **区分大小写**  
 **不能使用Java中的关键字和保留字，如`int`、`class`等  
总结：字下美人其后数 【后数——数字排后不可开头】  
规范：见名知意，驼峰命名，类名+接口名首字母大写，变量+方法名首字母小写，常量全部大写**

#### 1.6 java 关键字 ####

> ![d724e7fb87114a6f8eb8ece7ba7c25ab.png][]
> 
> 1、用于数据类型。  
> 用于数据类型的关键字有 boolean、byte、char、 double、 false、float、int、long、new、short、true、void、instanceof。  
> 2、用于语句。  
> 用于语句的关键字有break、case、 catch、 continue、 default 、do、 else、 for、 if、return、switch、try、 while、 finally、 throw、this、 super。  
> 3、用于修饰  
> 用于修饰的关键字有 abstract、final、native、private、 protected、public、static、synchronized、transient、 volatile。  
> 4、用于方法、类、接口、包和异常
> 
> 用于方法、类、接口、包和异常的关键字有 class、 extends、 implements、interface、 package、import、throws。  
> 还有些关键字,如cat、 future、 generic、innerr、 operator、 outer、rest、var等都是Java保留的没有意义的关键字。  
> 另外，Java还有3个保留字:true、false、null。它们不是关键字，而是文字

#### 1.7 java 变量 ####

**变量是用于存储数据的容器**。它们用于存储各种类型的值，如整数、浮点数、字符、布尔值等。  
**字面量（数据/数值）放到内存当中，给这块内存空间起一个名字，这就是变量**

1.  **声明变量时需要指定变量的 名称和类型** String name;
2.  **变量可以选择性地进行初始化，即给变量赋予初始值。如果未初始化变量，则会被赋予默认值。**   
    int age = 25; // 初始化一个整数类型的变量 "age"，并设置初始值为 25
3.  **已声明的变量可以通过赋值操作符（=）来给它们赋新的值** age = 30;将整数类型变量 "age" 的值更由25 改为 30
4.  **变量可以具有不同的作用域，即变量的有效范围 局部变量在其所在的代码块中可见，而实例变量在整个类中可见**  **同一个域中变量名不能重名**

##### 1.7.1变量使用 #####

**声明变量的语法格式为：**数据类型 变量名; //例如：int age;

**注意**： int a, b , c = 300; 只有变量 c 被初始化了  
同时初始化多个变量 :

int a = 300, b = 300, c = 300;

##### 1.7.2变量的分类 #####

声明的位置不同可以分为：**局部变量 和 成员变量** 【**实例变量、静态变量**】

public class Test{
    
    	//实例变量（成员变量）//类中声明变量·
    	int x = 20;
    	
    	//静态变量（成员变量） static修饰的类中变量
    	static int y = 200;
    	
    	//方法：int a,int b都是局部变量   方法中声明变量
    	public static void sum(int a, int b){
    		//局部变量
    		int firstNum = 100;
    	}
    }

**注意：局部变量只在方法体当中有效**，方法开始执行的时候局部变量的内存才会被分配，**当方法执行结束之后，局部变量的内存就释放了**。所以局部变量的生命周期非常短暂

##### 1.7.3 Java的数据类型 #####

![3ad1ab6656ec49d49fdeeac46062bb5f.png][]

**两种：**基本数据类型 引用数据类型

Java中的基本数据类型又包括四类8种：  
![5def26fe7b3f44d0a85bf8ba2d9e9ff3.png][]

十进制、二进制对照表

![4ae5a242d2aa4ebf938c2f423cd7f4a8.png][]

● 二进制转换成十进制：比方说二进制代码为1000001的十进制数是多少呢？可以采用按权相加的方法，对于二进制代码1000001首先从右边第一位起对应2的零次方，第二位对应2的一次方，以此类推，把相应的数位与权值相乘得到的积相加即可，即2^0\*1+0\*2^1+0\*2^2+0\*2^3+0\*2^4+0\*2^5+1\*2^6=65

**什么是编码？什么是解码？我们拿’a’来解释：**

● ‘a’ ----（以ASCII字符集进行编码）----> 01100001

● 01100001----（以ASCII字符集进行解码）----> ‘a’

大家一定要注意：编码和解码要采用同一种字符编码方式（要采用同一个对照表），不然会出现乱码

##### 1.7.4 Java字符类型 #####

字符型char在java语言中占用2个字节，char类型的字面量必须使用半角的单引号括起来，取值范围为\[0-65535\]，char和short都占用2个字节，但是char可以取到更大的正整数，**因为char类型没有负数。**java语言中的char类型变量可以容纳一个汉字

**\\n表示换行符，\\’表示普通的单引号字符，\\\\表示一个普通的\\字符，\\”表示一个普通的双引号字符，\\u后面的十六进制是文字的Unicode编码【'\\u4e2d'】。**

**图1-1**

public class Test{
    	public static void main(String[] args) {
    		char c1 = 'a';
    		System.out.println(c1); //a
    		System.out.println(c1 + 1);//98
    		char c2 = '中';
    		System.out.println(c2);//中
     		char c4 = 97;
    		System.out.println(c4);//a
            char c5 = '\t';
    		System.out.println("abc" + c5 + "def");//abc    def
    		System.out.println("测试杠杆=" + '\\');//测试杠杠=\
    	    System.out.println("测试双引号=" + "\"");//测试双引号="
    	}
    }

**注意：图1-1**表面看起来’\\t’是由两个字符构成，按说应该编译报错，因为它毕竟是一个字符串，最终的结果编译通过了，这还是说明’\\t’是一个字符，所以\\具有转义功能，根据以上输出结果可以看出\\t是制表符

##### 1.7.5 Java字整数类型 #####

public class Test{
    	public static void main(String[] args) {
    		//十进制
    		int a = 10;
    		System.out.println("a = " + a);//10
    		//八进制
    		int b = 010;
    		System.out.println("b = " + b);//8
    		//十六进制
    		int c = 0x10;
    		System.out.println("c = " + c);//16
    //=========================================================================
            //100被默认当做int类型处理，占用4个字节
    		//b变量是long类型，默认可容纳8个字节
    		//小容量转换成大容量，叫做自动类型转换
    		long b = 100;
    
            //c变量int类型，占用4个字节
    		//大容量不能直接赋值给小容量，编译报错了
    		//int c = b;
    		
    		//强制类型转换需要添加强制类型转换符
    		//强制类型转换时可能引起精度损失，谨慎使用  ***
    		int c = (int)b;
    	}
    }

##### 1.7.6 java 布尔类型 /Boolean #####

Java语言中布尔类型的值只包括true和false，没有其他值

##### 1.7.7 java 浮点类型 #####

现实世界中存在无穷的数据，例如：3.333333333333333333..，数据是无穷的，但是内存有限，所以只能**存储近似值**，**float单精度占4个字节，double双精度占8个字节**，**相对来说double精度要高一些**。

public class Test{
    	public static void main(String[] args) {
    		//float f = 3.0;//打印结果报错。小自动转大范围，不能反着进行
    		//第一种方案  加F
    		float f = 3.0F;
    		System.out.println("f = " + f);
    		//第二种方案  强制转换
    		float f1 = (float)3.0;
    		System.out.println("f1 = " + f1);
    	}
    }

##### 1.7.8 基本数据类型转换 #####

1.  **小容量向大容量转换称为自动类型转换**，容量从小到大的排序为：byte < short(char) < int < long < float < double 注意：short和char都占用两个字节，但是char可以表示更大的正整数；
2.  整数型字面量没有超出byte,short,char的取值范围，可以直接将其赋值给byte,short,char类型的变量
3.  byte,short,char类型混合运算时，先各自转换成int类型再做运算
4.  大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用

#### 1.8 java 运算符 \*\*\* ####

常见的Java运算符的使用，包括 **算术**运算符、**关系**运算符、**逻辑**运算符、**赋值**运算符、**条件**运算符、**字符串连接**运算符

![1c5d0bcd8797402b9cd6163546c58d8c.png][]

##### 1.8.1算术运算符 #####

public class Test {
        public static void main(String[] args) {
            int a = 10;
            int b = 3;
            System.out.println(a + b); //13
            System.out.println(a - b); //7
            System.out.println(a * b); //30
            /*
             * 在java语言中10除以3结果不是3.3333..
             * 因为java中有一个语法规则：int类型和int类型
             * 做运算，最终的结果还是int类型，所以10除以3
             * 的结果就是3，这个过程会取整数位。
             */
            System.out.println(a / b); //3
            /*
             * 10对3求余数，3乘3得9，余1。
             */
            System.out.println(a % b); //1
            /*
             * ++和--都是单目运算符，++负责自加1，--负责自减1
             * 以下程序重点研究++运算符，--运算符可以依照++运算
             * 符进行类推。
             */
            int i = 10;
            i++;
            System.out.println("i = " + i); //11
            int j = 10;
            ++j;
            System.out.println("j = " + j); //11
            /*
             * 根据以上的程序可以得出结论：++可以出现在变量前，也
             * 可以出现在变量后，无论是变量前还是变量后，只要执行完
             * ++，最终的结果都会让变量自加1。那么++出现在变量前
             * 和变量后到底有什么区别呢？请看以下程序
             */
            int k = 10;
            int m = k++;
            /*
             * 根据以上结论，++无论是出现在变量前还是变量后，只要++执行
             * 变量一定会自加1，那么k变量一定会自加1，所以以下输出k=11
             */
            System.out.println("k = " + k); //11
            /*
             * 以上int m = k++;代码中++和=两个运算符同时存在，
             * 那么此时这两个运算符哪个优先级高呢？java语法中是这样
             * 规定的，当++运算符出现在变量后，会先做赋值运算，再自
             * 加1,所以最后m = 10
             */
            System.out.println("m = " + m); //10
            int x = 10;
            int y = ++x;
            //上行代码执行结束后，我们可以确定x变量一定自加1了，所以x=11
            System.out.println("x = " + x); //11
            /*
             * java语法中又有这样的规定，++出现在变量前，会先进行自加1
             * 的操作，然后再做赋值运算，所以y = 11
             */
            System.out.println("y = " + y); //11
        }
    
    }

##### 1.8.2 关系运算符 #####

public class Test{
    	public static void main(String[] args) {
    		int a = 10;
    		int b = 10;
    		System.out.println(a > b);//false
    		System.out.println(a >= b);//true
    		System.out.println(a < b);//false
    		System.out.println(a <= b);//true
    		System.out.println(a == b);//true
    		System.out.println(a != b);//false
            //比较两个字符串是否相等，不能使用“==”，必须调用equals方法
            System.out.println(“abc”.equals(“abc”));//true
    	}
    }

##### 1.8.3 逻辑运算符 #####

![70eb58d81c9c4b7fab61ce3d20e5f132.png][]

public class LogicalOperatorTest01 {
    	public static void main(String[] args) {
    		System.out.println(5 > 3 & 5 > 4); //true
    		System.out.println(5 > 100 | 5 > 4); //true
    		System.out.println(!(5 > 3)); //false
    		System.out.println(true & true); //true
    		System.out.println(true & false); //false
    		System.out.println(true | false); //true
    		System.out.println(!false); //true
    		System.out.println(true ^ false); //true
    		System.out.println(false ^ false); //false
    
    		//重点研究逻辑与（&）和短路与（&&）的区别
    		int x = 100;
    		int y = 98;
    		int z = 99;
    		System.out.println(x > y & x > z); //true
    		System.out.println(x > y && x > z); //true
    		//通过以上测试得出，逻辑与（&）和短路与（&&）最终运行结果相同
    		//那么它们有什么区别呢？请看以下代码。
    		int m = 99;
    		int n = 100;
    		System.out.println(m > n & m > n++); //false
    		//逻辑与（&）运算符，只有当两边的操作数都是true的时候，结果才是true
    		
    		System.out.println("n = " + n); //101
    		//以上程序的运行结果是101，说明n++已经执行了。也说明了逻辑与
    		//运算符无论左边表达式结果是true还是false，右边表达式一定会执行。
    
    		//那我们来看一下短路与（&&）是怎样的？
    		int k = 99;
    		int f = 100;
    		System.out.println(k > f && k > f++); //false
    		System.out.println("f = " + f); //100
    		//通过以上测试得出f++并没有执行，因为左边表达式(k > f)为false
    		//右边的表达式就不再执行了，这种现象被称为短路现象。也就是说对于短路与
    		//来说，左边的表达式只要为false，就会发生短路，右边表达式不再执行了。
    	}
    }

##### 1.8.4位运算符 #####

![43a5ebe42be84dfea247466ae8edee73.png][]

##### 1.8.5 赋值运算符 #####

public class Test{
    	public static void main(String[] args) {
    		//基本的赋值运算符
    		int i;
    		i = 10;
    		System.out.println("i = " + i); //10
    		i = 100;
    		System.out.println("i = " + i); // 100
    		//扩展的赋值运算符
    		int x = 10;
    		x += 1; //等同于x = x + 1
    		System.out.println("x = " + x); //11
    		int y = 10;
    		y -= 1; //等同于y = y - 1
    		System.out.println("y = " + y); //9
    		int z = 10;
    		z *= 2; //等同于z = z * 2
    		System.out.println("z = " + z); //20
    		int m = 10;
    		m /= 3; //等同于m = m / 3
    		System.out.println("m = " + m); //3
    		int n = 10;
    		n %= 3; //等同于 n = n % 3
    		System.out.println("n = " + n); //1
    //注意：特殊情况
            byte bt=10;
            bt +=1;
    		System.out.println("bt = " + bt); //11
        
            bt=bt+1;// byte 与 int类型运算，小转大，结果是int类型，赋值给bt时报错【需要强转】
            bt=(byte) (bt+1); // 12
    	}
    }

##### 1.8.6 条件运算符 #####

public class Test{
    	public static void main(String[] args) {
    
    		//三目运算符最经典的用法
    		boolean sex = true;
    		//当布尔变量sex为true则结果是'男'，反之'女'
    		char gender = sex ? '男' : '女';
    		System.out.println("性别：" + gender); //男
    
    		
    		//又如
    		int x = 100;
    		int y = 100;
    		System.out.println(x == y ? "x和y相等" : "x和y不相等");
    	}
    }

##### 1.8.7 字符串连接符 #####

所有的字符串都使用**半角双引号**括起来的，**字符串属于引用数据类型**，不属于基本数据类型

“+”运算符在java语言中有两个作用，作用**一是对数字进行求和运算**，作用**二就是字符串连接运算  
两个变量都是数值操作为求和，有一个变量为字符串是连接！**

![5e079c028d5f4c2191984dbba92064ff.png][]

#### 1.9 java 控制语句 ####

![c90794ec1ec34265a4893720bd2b412f.png][]

##### 1.9.1 if语句 #####

布尔表达式就是看结果 是true 还是 false

![4a8543050fd04a64b7338834200c479b.png][]

java.util.Scanner scann = new java.util.Scanner(System.in);
    System.out.print("请输入天气指数，1表示下雨天，0表示晴天：");
    int weather = scann.nextInt();
    if(weather == 1){
    	System.out.print("请再输入您的性别，1表示男，0表示女：");
    	int sex = scann.nextInt();
    	if(sex == 0){
    		System.out.println("女士，外面下雨了，您需要带一把小花伞");
    	}else if(sex == 1){
    		System.out.println("哥们，外面下雨了，您需要带一把大黑伞");
    	}else{
    		System.out.println("对不起，您输入性别参数出错了！");
    	}
    }else if(weather == 0){
    	System.out.println("走起，一起出去玩耍喽！");
    }else{
    	System.out.println("对不起，您输入天气参数出错了！");
    }

##### 1.9.2 switch语句 #####

![ae03b7086c0f446cb90c70e5721b3a43.png][]

##### 1.9.3 java 循环 #####

java中的循环语句共包括三个，分别是：**for循环、while循环、do..while循环**，接下来我们先来学习for循环。

**for结构：**

![19336a28ca37429fa46456ff1d36f013.png][]

![6a9b36c9076e414e9831de924ef8e5e4.png][]

**while结构：**

![b252c8b0737243038bec165d44487ec8.png][]

![710f87d63d3e4663b9d3e4cba0b5dcfc.png][]

**do..while 结构：**

do..while循环是while循环的变形，它们的区别在于do..while循环可以保证循环体执行次数至少为1次，也就是说do..while循环的循环体执行次数是1~N次，它有点儿先斩后奏的意思，而while循环的循环体执行次数为0~N次。

![2f0b49b7b93e45958e9bc66dc5116364.png][]

##### 1.9.4 break 语句 #####

用在switch语句当中，用来终止switch语句的执行  
用在循环语句当中，用来终止/跳出循环

![7953cfeef73e4a88ac893837e76be405.png][]

first:for(int j = 1; j <= 2; j++){// 当i==5时，标识first,此时跳出外层循环
    	for(int i = 1; i <= 10 ; i++){
    		if(i == 5){
    			break first;
    		}
    		System.out.println("i = " + i);
    	}
    }

总结：当多层循环嵌套的时候，可以给每个循环设置标识，例如：first:for...、second:for...，当某个条件成立时，想终止指定循环的话，可以这样做：break first;或者break second;，这样指定的循环就结束了

##### 1.9.5 continue语句 #####

![e8479562719145ec81d6941373994f28.png][]

##### 1.9.6 return 语句 #####

return关键字不是专门用于结束循环的，return语句用于**终止函数的执行或退出类的方法**

1.如果不是立即要对函数返回值做操作，那么可以使用returm语句保留返回值。

2.需要多次调用函数时，可以再定义一个主函数main（），调用非主函数的返回值。

3.Python的函数返回值可以是多个，多个返回值的数据类型是元组（tuple）。

4.没有return语句的函数会默认返回None值。

5.一旦函数内部遇到return语句，就会停止执行并返回结果。

![00f99a3187734877b5ea21ec562d1960.png][]

#### 2.0 java方法 ####

![bd091a696a4a46659e2f0ea9aac00c85.png][]

概念：**方法其实就是一段普通的代码片段，并且这段代码可以完成某个特定的功能，而且可以被重复的调用/使用**。java中的方法又叫做method，在C语言中叫做函数

public static void main(String[] args) {
    	//调用求和方法计算10和20的和
    	sumInt(10 , 20);
    	//调用求和方法计算666和888的和
    	sumInt(666 , 888);
    	//调用求和方法计算888和999的和
    	sumInt(888 , 999);
    }
    //专门负责求和的方法
    public static void sumInt(int a , int b){
    	int c = a + b;
    	System.out.println(a + "+" + b + "=" + c);
    }

##### 2.0.1 方法的定义、调用 #####

> \[`修饰符] 返回值类型 方法名(参数类型 参数名){`
> 
> `...`
> 
> `方法体`
> 
> `...`
> 
> `return 返回值；`
> 
> `}`
> 
> **有返回值 图2-01**``
> 
> ![b4378a863c764574b5cfc520dc313729.png][]
> 
> **无返回值 图2-02**
> 
> ![accb0d502ecb4817b0debe124cbe18bc.png][]
> 
> 图2-02中
> 
> **形参**：(int a , int b)是形式参数列表，简称形参，每一个形参都是局部变量；
> 
> **实参**：方法在调用的时候，实际传给这个方法的数据被称为实际参数列表，简称实参
> 
> 举例：sumInt(10,20) 传递的10,20都是实参
> 
> **注意**：java语法中有这样的规定：**实参和形参必须一一对应，所谓的一一对应就是，个数要一样，数据类型要对应相同**

##### **2.0.2 方法返回值详解** #####

方法的返回值类型可以是任何一种数据类型，包括基本数据类型，也包括引用数据类型

每个方法都是为了完成某个特定的功能，例如：登录功能、求和功能等，既然是功能，那么当这个功能完成之后，大多数情况下都会有一个结果的

> 1.返回值  
> ![992809f640584a95ae88d5f881458dd1.png][]
> 
> 2.提前结束方法 / 返回void 注意：**retrun ;** 分号
> 
> ![357ea417d9a844de8f495ecb5b6a0155.png][]
> 
> 3.多个返回点：方法中可以存在多个 `return` 语句，但在任何代码路径上，只能有一个 `return` 语句被执行。一旦执行了其中一个 `return` 语句，方法的执行将立即结束。

#### 2.1 java 数据结构 ####

概念：**数据结构**是计算机科学中用于**组织和存储数据**以便有效访问和修改**的方式**

> 1.  数组（Array）：一种线性数据结构，元素在内存中连续存储，通过索引访问。数组适用于随机访问元素，但插入和删除操作效率较低。
> 2.  链表（Linked List）：也是一种线性数据结构，元素不连续存储，通过指针连接。链表适用于频繁的插入和删除操作，但访问元素的效率较低。
> 3.  栈（**Stack**）：一种后进先出（LIFO）的数据结构，**只能在栈顶进行插入和删除操作**，常用于实现函数调用、表达式求值等场景。
> 4.  队列（Queue）：一种先进先出（FIFO）的数据结构，从队尾插入元素，从队头删除元素。常用于任务调度、广度优先搜索等场景。
> 5.  树（Tree）：一种非线性数据结构，包括二叉树、平衡树、二叉搜索树等。树适用于表示具有层次关系的数据，如文件系统、组织结构等。
> 6.  图（Graph）：一种非线性数据结构，包括有向图、无向图等。图用于表示节点之间的关系，如社交网络、路线规划等。
> 7.  哈希表（Hash Table）：使用哈希函数将键映射到值的数据结构，提供快速的查找、插入和删除操作。
> 8.  许多其他类型的数据结构，如堆、优先队列、字典树（Trie）等，每种数据结构都有其特定的应用场景和优缺点

![c7170955f8f842b49175ffe44130a130.png][]

#### 2.2方法执行过程中内存的变化 ####

![98408472fa5747768ab9a6852580348b.png][]

只看其中的“栈”和“方法区”，其它的后期研究，**方法区中存储类的信息，或者也可以理解为代码片段**，**方法在执行过程中需要的内存空间在栈中分配**。java程序开始执行的时候先通过类加载器子系统找到硬盘上的字节码(class)文件，然后将其加载到java虚拟机的方法区当中，开始调用main方法，main方法被调用的瞬间，会给main方法在“栈”内存中分配所属的活动空间，此时发生压栈动作，main方法的活动空间处于栈底。

也就是说，**方法只定义不去调用的话，只是把它的代码片段存储在方法区当中**，**java虚拟机是不会在栈内存当中给该方法分配活动空间的**，只有在调用的瞬间，java虚拟机才会在“栈内存”当中给该方法分配活动空间，此时发生压栈动作，直到这个方法执行结束的时候，这个方法在栈内存中所对应的活动空间就会释放掉，此时发生弹栈动作。**由于栈的特点是先进后出，所以最先调用的方法（最先压栈）一定是最后结束的（最后弹栈）。比如：main方法最先被调用，那么它一定是最后一个结束的**

**一段代码，同时画出内存结构图，以及使用文字描述该程序的内存变化**

![1b1a2f2328ff45459d67fa9f204ff6c3.png][]

![9f29f68b7cd44ef8a65c4062ce7b0e96.png][]

总结：方法体当中的代码是有执行顺序的，必须遵循自上而下的顺序依次逐行执行，当前行代码必须执行结束之后，下一行代码才能执行，不能跳行执行。和栈数据结构一起联系起来思考一下，只有采用这种先进后出的栈数据结构才可以保证代码的执行顺序

#### 2.3 java 递归方法 ####

方法自身调用自身，就是方法递归。

**错误示例**

**图示2-3-1**

![8a19942841cc42fb85685fb0745cf4d4.png][]

一个方法不停执行时，main方法调用方法，报java.lang.StackOverflowError，这个错误是栈内存溢出错误 **不停占据栈内存**

**图2-3-2**

![cb81edfd749d4a6e81fc73213e2ff4b0.png][]

OutOfMemoryError 内存溢出,简称(OOM) 不停创建 / new 对象占据的**堆内存**

1.  **堆溢出错误（Heap Overflow Error）**： **将jvm堆内存调小，在执行上述图2-3-2得到**
    
     *  堆溢出错误通常是指在程序执行过程中，动态分配的堆内存空间不足，无法满足新对象的分配请求，从而导致程序异常终止。
     *  这种情况通常发生在程序中频繁地创建大型对象，而堆空间不足以容纳这些对象。
     *  堆溢出错误通常是由于程序中存在内存泄漏、缓存未及时清理、对象创建过多等原因引起的。
2.  **内存溢出错误（OutOfMemoryError）**：
    
     *  内存溢出错误是一个更加宿命性的术语，它可以**表示任何一种内存资源耗尽的情况，不仅包括堆溢出错误，还包括栈溢出错误、永久代溢出错误等。**
     *  在 Java 中，**通常指由于堆空间、栈空间、方法区/元空间等内存区域耗尽导致的错误**。

**正确示例 基本方法+结束条件**

public class Test{
        public static int factorial(int n) {
            if (n == 0) {
                return 1; // 终止条件：当 n 为 0 时返回 1
            }
            return n * factorial(n - 1); // 递归调用：计算 n 的阶乘
        }
    
        public static void main(String[] args) {
            int result = factorial(5); // 调用递归方法计算阶乘
            System.out.println("阶乘结果：" + result);
        }
    }

**注意**：一个递归程序有的时候存在合法有效的终止条件，但由于递归的太深，在还没有等到条件成立的时候，栈内存已经发生了溢出，这种情况也是存在的，所以实际开发中我们尽可能使用循环来代替递归算法，原则是：能不用递归尽量不用，能用循环代替的尽可能使用循环。当然，如果在开发中遇到了由于使用递归导致栈内存溢出错误的发生，首先，我们要检查递归的终止条件是否合法，如果是合法的还是发生栈内存溢出错误，那么我们可以尝试调整堆栈空间的大小

![ad5ab0a7a3a04a28a15df68420b59987.png][]

总结：1.**包含一个或多个终止条件**，确保递归能够在**某个条件下结束，防止进入无限循环  
2.递归函数内部包含对自身的调用 3.处理大规模数据时，需要注意堆栈溢出的问题**

#### 2.4 方法重载 / **Overload**  ####

概念：**同一个类中定义多个同名的方法**，但要求每个方法具有**不同的参数的类型或参数的个数**  
**或者 本类中** 定义多个**方法名相同但参数列表不同**的方法  
**注意**：**跟返回类型毫无关系**

最常用的地方就是构造器的重载。

*  被重载的方法必须改变参数列表(参数个数或类型不一样)；
 *  被重载的方法可以改变返回类型；
 *  被重载的方法可以改变访问修饰符；
 *  被重载的方法可以声明新的或更广的检查异常；
 *  方法能够在同一个类中或者在一个子类中被重载。
 *  无法以返回值类型作为重载函数的区分标准。

普通方法重载
    public int add(int a, int b) {
        return a + b;
    }
    //参数类型不同
    public double add(double a, double b) {
        return a + b;
    }
    //参数个数不同
    public int add(int a, int b，int c) {
        return a + b+c;
    }
    //参数类型不同
     public int add(int a, double b) {
            return (int) (a + b);
     }
    //不算重载，改变返回类型 不属于重载概念
    public void add(int a, int b) {
        System.out.println(a+b);
    }
    
    构造器重载
    // 无参构造器
     public Person() {
         this.name = "Unknown";
         this.age = 0;
     }
    
     // 带参数的构造器
     public Person(String name, int age) {
         this.name = name;
         this.age = age;
     }

####  ####

[JDK_ _baidu.com]: https://baijiahao.baidu.com/s?id=1749642961611694666&wfr=spider&for=pc
[Java JDK_-CSDN]: https://blog.csdn.net/ACE_U_005A/article/details/114840497
[d724e7fb87114a6f8eb8ece7ba7c25ab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/eb749ce83e3a4f8a99daf9f08e0531ac.png
[3ad1ab6656ec49d49fdeeac46062bb5f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/988c71bbab7d4ac59902a83da9618d57.png
[5def26fe7b3f44d0a85bf8ba2d9e9ff3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/0c70f07c4caf4ec99a101d64a061d676.png
[4ae5a242d2aa4ebf938c2f423cd7f4a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/12de3257aa4e4e3a896330981f738055.png
[1c5d0bcd8797402b9cd6163546c58d8c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/ea40e9d87859461da8ffba1d80a2eb58.png
[70eb58d81c9c4b7fab61ce3d20e5f132.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/768cb195e6234db1848f1df4d3ea233b.png
[43a5ebe42be84dfea247466ae8edee73.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/c7b019660d9641d5bc5ccaa653c93d01.png
[5e079c028d5f4c2191984dbba92064ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/b9374adf9da642a694fba5063d6bf2b1.png
[c90794ec1ec34265a4893720bd2b412f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/95c45966e3134285bcea45e873209e5f.png
[4a8543050fd04a64b7338834200c479b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/8a1f3b8c4d894516a89f257b58275345.png
[ae03b7086c0f446cb90c70e5721b3a43.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/dc24194f57bd4e0bb77a68c785166c05.png
[19336a28ca37429fa46456ff1d36f013.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/56740df8b1b846dcb696e125b00bc7be.png
[6a9b36c9076e414e9831de924ef8e5e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/ea68081b69c94946bb2786282429a9d9.png
[b252c8b0737243038bec165d44487ec8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/1f66272bd722464bbcc8afcc1ff0886f.png
[710f87d63d3e4663b9d3e4cba0b5dcfc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/d3d5a181e0eb40628f032e0c28442b37.png
[2f0b49b7b93e45958e9bc66dc5116364.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/099c7e18934647febf056f5c04b60f97.png
[7953cfeef73e4a88ac893837e76be405.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/e5f2b27380bf499880c7fa053fa75917.png
[e8479562719145ec81d6941373994f28.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/378fae9a35ba44c7b06d131f0843e27a.png
[00f99a3187734877b5ea21ec562d1960.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/9941412f1aae4e2da07ade6c2779a9ba.png
[bd091a696a4a46659e2f0ea9aac00c85.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/26ec51990f5f4ab6bcbeea4aa817d095.png
[b4378a863c764574b5cfc520dc313729.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/9d0e38941b77416d9e8491c23c14e073.png
[accb0d502ecb4817b0debe124cbe18bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/5552c425ffa94e58ac2116e2a4f5053e.png
[992809f640584a95ae88d5f881458dd1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/1180d6df93c142bca8bfa49b103b02ea.png
[357ea417d9a844de8f495ecb5b6a0155.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/13ab0488d9e04073a782e873997f3d1a.png
[c7170955f8f842b49175ffe44130a130.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/56b8f33ec13c457985947ffdb4f1e9f9.png
[98408472fa5747768ab9a6852580348b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/7e1a6d77af1440fe8489eff24b8c232b.png
[1b1a2f2328ff45459d67fa9f204ff6c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/b33147ef63f747b9b1ec653ef4e2095b.png
[9f29f68b7cd44ef8a65c4062ce7b0e96.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/cda459ae290643c58f8f0109fc2ea5bd.png
[8a19942841cc42fb85685fb0745cf4d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/765be82221564ebbb30e05d5f75b5cea.png
[cb81edfd749d4a6e81fc73213e2ff4b0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/5826a1730f43451c87bdf48fad3e06d9.png
[ad5ab0a7a3a04a28a15df68420b59987.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/05/69d1eef43c4245fd8fdd876c3ccdb10d.png