【Java 学习】字符串、数组、方法、函数重载

[1. 字符串](#1. 字符串)
- [1.1 String 类](#1.1 String 类)
- [1.2 String 类的使用](#1.2 String 类的使用)
[2. 数组](#2. 数组)
- [1.1 数组的介绍](#1.1 数组的介绍)
- [1.2 静态数组](#1.2 静态数组)
- - [1.2.1 一维数组](#1.2.1 一维数组)
  - [1.2.1 多维数组](#1.2.1 多维数组)
- [1.3 动态数组](#1.3 动态数组)
[3. 方法（函数）](#3. 方法（函数）)
- [3.1 引入方法](#3.1 引入方法)
- [3.2 使用无返回值的方法](#3.2 使用无返回值的方法)
- [3.3 使用有回值的方法](#3.3 使用有回值的方法)
[4. 方法重载](#4. 方法重载)
- [4.1 为什么要有方法重载？](#4.1 为什么要有方法重载？)
- [4.2 方法重载的规则](#4.2 方法重载的规则)
- [4.3 示例](#4.3 示例)
[5. main 方法](#5. main 方法)

1. 字符串

1.1 String 类

String 类并不是数组，但它有一些与数组相似的特性。String 是一个不可变的字符序列，内部使用字符数组来存储数据。

基本概念：

不可变性：String 对象是不可变的，这意味着一旦创建了一个 String 对象，其内容就不能被修改。每次对 String 进行修改操作时，都会创建一个新的 String 对象。

java 复制代码

//创建一个字符串
String str = "Hello";
//str是不可变的，但是 str+ "World" 拼接后
// 会生成一个新的字符串对象，并用str接收
//误认为str是可变的
str += "World";

System.out.println(str);

存储方式：String 对象在内存中的存储方式是通过一个字符数组实现的，通常是一个 char[] 数组。

1.2 String 类的使用

java 复制代码

 //创建字符串对象
 String str1 = "Hello";
 String str2 = "World";

//字符串拼接
String str3 = str1 + str2;

//字符串比较
boolean b = str1.equals(str2);

 //字符串长度
 int len = str1.length();

//字符串转大写
String str4 = str1.toUpperCase();

//字符串转小写
String str5 = str1.toLowerCase();

//字符串截取，返回的是从1到3的字符串
String str6 = str1.substring(1,3);

//查找字符串，返回的是第一个l的位置
int index = str1.indexOf("llo");

// 获取字符串中指定位置的字符
char ch = str1.charAt(1);

//字符串替换
String str7 = str1.replace("H","h");

//字符串分割
String[] str8 = str1.split("l");

//字符串格式化
String str9 = String.format("我的名字叫%s，今年%d岁。", "小明", 18);

2. 数组

1.1 数组的介绍

数组是一种线性数据结构，用于存储固定数量的相同类型的数据。数组中的每个元素都有一个索引（从 0 开始），可以通过索引来访问和修改数组中的元素。

1.2 静态数组

1.2.1 一维数组

静态初始化：在声明数组时同时赋值。

java 复制代码

//声明一个长度为5的整数数组
int[] arr = { 1, 2, 3, 4, 5};
//修改数组的元素
arr[0] = 100;

//声明一个长度为5的字符串数组
String[] s = {"李明", "李华", "李红", "李蓝", "李绿"};
//修改数组的元素
s[0] = "小明";

动态初始化：在声明数组时指定数组的大小，但不立即赋值。

java 复制代码

//声明一个长度为5的整数数组
int[] arr = new int[5];
Random r = new Random();

//赋值
for(int i=0; i<5; i++){
    arr[i] = r.nextInt(100);
}

//打印内存地址表示形式
System.out.println(arr);

//遍历数组
for(int i = 0; i<5; i++){
    System.out.println(arr[i]);
}

//修改数组的元素并遍历
for(int i = 0; i<5; i++){
    arr[i] += 100;
    System.out.println(arr[i]);
}


//声明一个长度为5的字符串数组
String[] s = new String[5];
//给数组的元素赋值

1.2.1 多维数组

静态初始化二维数组

java 复制代码

//静态初始化二维数组,3行3列
int[][] arr = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
};
//遍历
for(int i=0; i<3; i++ ){
    for(int j=0; j<3; j++){
        //=打印第i+1行的第j+1列的值
        System.out.print(arr[i][j] + " ");
    }
    System.out.println("");//换行
}

动态初始化二维数组

java 复制代码

//创建Random对象
Random r = new Random();

//动态初始化3行3列的二维数组
int[][] arr = new int[3][3];

//赋值
for(int i=0; i<3; i++){
    for(int j=0; j<3; j++){
        //给i+1行且j+1列的元素赋值
        arr[i][j] = r.nextInt(100);
    }
}

//遍历
for(int i=0; i<3; i++ ){
    for(int j=0; j<3; j++){
        //=打印第i+1行的第j+1列的值
        System.out.print(arr[i][j] + " ");
    }
    System.out.println("");//换行
}

// 修改并遍历
for(int i=0; i<3; i++ ){
    for(int j=0; j<3; j++){
        //修改i+1行和j+1行的值
        arr[i][j] +=100;

        //打印第i+1行的第j+1列的值
        System.out.print(arr[i][j] + " ");
    }
    System.out.println("");//换行
}

1.3 动态数组

动态数组是一种能够在运行时调整其大小的数据结构。与固定大小的数组不同，动态数组可以在需要时增加或减少其容量。在 Java 中，虽然没有内置的动态数组类型，但可以使用 ArrayList 类来实现类似的功能。

示例：

java 复制代码

import java.util.ArrayList;

public class Test {

    public static void main(String[] args) {
        // 创建一个 ArrayList 实例
        ArrayList<Integer> list = new ArrayList<>();

        // 添加元素
        list.add(10);
        list.add(20);
        list.add(30);

        // 打印当前列表
        System.out.println("Initial list: " + list);

        // 添加更多元素
        list.add(40);
        list.add(50);

        // 打印添加更多元素后的列表
        System.out.println("After adding more elements: " + list);

        // 访问元素
        int thirdElement = list.get(2);
        System.out.println("Third element: " + thirdElement);

        // 修改元素
        list.set(2, 35);
        System.out.println("After modifying the third element: " + list);

        // 删除元素
        list.remove(1); // 删除第二个元素
        System.out.println("After removing the second element: " + list);

        // 获取列表大小
        int size = list.size();
        System.out.println("Size of the list: " + size);

        // 遍历列表
        System.out.println("Iterating over the list:");
        for (int num : list) {
            System.out.println(num);
        }
    }
}

3. 方法（函数）

3.1 引入方法

场景：打印两个数之间的所有整数。

思考：打印两个数之间的所有的数需要用while 或 for 循环的，还要判断两个数哪个更小，从最小的数开始到最大的数终止。

实现：

java 复制代码

// 打印 1-6
        int start1 = 1;
        int end1 = 6;

        //假设end最大
        if(end1 < start1){
            int tmp = end1;
            end1 = start1;
            start1 = tmp;
        }

        //进行遍历
         while(start1 <= end1){
             System.out.print(start1 + " ");
             start1++;
         }

// 打印 10-16
        int start2 = 10;
        int end2 = 16;

        //假设end最大
        if(end2 < start2){
            int tmp = end2;
            end2 = start2;
            start2 = tmp;
        }

        //进行遍历
        while(start2 <= end2){
            System.out.print(start2 + " ");
            start2++;
        }
        
//等等
 		// ·················

如果我们打印很多的区间数就需要写很多的重复代码，这样会显得写的代码很多，效率很低。

有没有一种便捷方法来提高打印区间数呢？

答：有，把打印区间数的代码包装起来，把它比作一个工具，想用的时候直接拿来用，这种包装这些代码后的工具就叫做方法，或则叫做函数。

3.2 使用无返回值的方法

在Java中，方法和函数是同一个概念，都是用来执行特定任务的代码块。方法可以有参数和返回值。

把上述的代码块包装起来：

java 复制代码

public static void Fun_1(int start, int end){

        // 假设end最大
        if(end < start ){
            int tmp = end;
            end = start;
            start = end;
        }
		
		// 遍历数
        while(start <= end){
            System.out.print(start + " ");
            start++;
        }

我们怎么用呢？直接调用函数的名字，输入数值：

java 复制代码

 		// 遍历1-6
        Fun_1(1,6);

        //遍历10-16
        Fun_1(10,6);

图解：

3.3 使用有回值的方法

假如你要使用一个计算圆面积方法，是不要得到计算的结果，这时方法需要在计算结果后返回一个数值。

示例：

java 复制代码

	// 主函数main
	public static void main(String[] args){

        //计算圆的面积，调用函数S
        double s = S(5);
        System.out.print("圆的面积：" + s);

    }
	
	// 计算圆的面积
    public static double S(double r){

        double s = 3.14 * r * r;

		//返回圆的面积
        return s;
    }

4. 方法重载

4.1 为什么要有方法重载？

场景：假如你要两个数的相加，你需要写这些方法：

整数 + 整数
浮点数 + 浮点数
整数 + 浮点数
浮点数 + 整数

示例：

java 复制代码

	//整数 + 整数
    public static int Add1(int a, int b){
         return a + b;
    }

    //浮点数 + 浮点数
    public static double Add2(double a, double b){
        return a + b;
    }

    //浮点数 + 整数
    public static double Add3(double a, int b){
        return a + b;
    }

    //整数 + 浮点数
    public static double Add4(int a, double b){
        return a + b;
    }

这些函数虽是好写，但是，用的时候你能准确的使用方法名子吗？

所以，方法重载解决了这个问题，可以让相同功能的函数使用同一个方法名。

4.2 方法重载的规则

方法重载（Method Overloading）是 Java 中的一种特性，允许在同一个类中定义多个同名的方法，但这些方法的参数列表必须不同。方法重载可以提高代码的可读性和复用性。下面通过几个示例来详细解释如何使用方法重载。

方法重载的规则：

方法名相同：重载的方法必须具有相同的方法名。
参数列表不同：重载的方法必须有不同的参数列表。参数列表的不同可以体现在参数的数量、类型或顺序上。
返回类型无关：方法的返回类型不影响方法的重载。

4.3 示例

java 复制代码

	public static void main(String[] args){

    int a = 10;
    double b = 6.6;

    // 整数+整数
    int sum1 = Add(a,a);

    // 浮点数 + 浮点数
    double sum2 = Add(b,b);

    // 整数 + 浮点数
    double sum3 = Add(a,b);

    // 浮点数 + 整数
    double sum4 = Add(b,a);


    }

    //整数 + 整数
    public static int Add(int a, int b){
         return a + b;
    }

    //浮点数 + 浮点数
    public static double Add(double a, double b){
        return a + b;
    }

    //浮点数 + 整数
    public static double Add(double a, int b){
        return a + b;
    }

    //整数 + 浮点数
    public static double Add(int a, double b){
        return a + b;
    }

5. main 方法

main 方法是Java应用程序的入口点。当运行这个程序时，JVM（Java虚拟机）会寻找这个方法并从这里开始执行程序。

public 表示这个方法可以被任何其他类访问。
static 关键字意味着这个方法属于类本身而不是类的实例。因此，即使没有创建类的实例，也可以调用这个方法。
void 表示这个方法不会返回任何值。
String[] args 是一个字符串数组参数，用于接收命令行参数。当通过命令行运行Java程序时，用户可以在命令行中提供参数，这些参数会被传递给 main 方法的 args 参数。

【Java 学习】字符串、数组、方法、函数重载

目录

1. 字符串

1.1 String 类

1.2 String 类的使用

2. 数组

1.1 数组的介绍

1.2 静态数组

1.2.1 一维数组

1.2.1 多维数组

1.3 动态数组

3. 方法（函数）

3.1 引入方法

3.2 使用无返回值的方法

3.3 使用有回值的方法

4. 方法重载

4.1 为什么要有方法重载？

4.2 方法重载的规则

4.3 示例

5. main 方法