Java总结（第二周）

包睿婷

已于 2023-05-21 17:53:11 修改

阅读量145

点赞数

文章标签： java 后端

于 2023-05-21 17:47:00 首次发布

本文链接：https://blog.csdn.net/xingrengengzai/article/details/130793991

版权

一、数组

1.声明数组语法：数组名是任意合法的变量名

一、数组

1.声明数组语法：数组名是任意合法的变量名

语法：数据类型[ ] 数组名

或者：数据类型数组名[ ]；

int[] scores;  //整形数组
double height[];  //浮点型数组
String[] names;  //字符串型数组

2.分配空间

就是指定数组中可以存储多少个元素，语法：

数组名 = new 数据类型 [ 数组长度 ]; //数组长度指的是可以存放元素的个数

scores = new int[5];  //长度为5的整形数组
height = new double[5];  //长度为5的浮点型数组
names = new String[5];  //长度为5的字符串数组

把 1 和 2 合起来写就是这样的：

int [] scores = new int [5];

3.赋值

分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的，例：

scores[0] = 89;
scores[1] = 90;

4.处理数组中的数据

对赋值后的数组进行操作和处理，如获取并输出数组中元素的值

System.out.println("scores数组中第一个元素的值：" + scores[0]);

还有一种直接创建数组的方式，将数组声明、分配空间和赋值操作一起完成

int [] scores = {78,89,48,59}; //创建一个长度为4的数组
//等价于
int [] scores = new int []{78,89,48,59}; //这中方式的方括号里面不能指定长度

5.循环操作数组

int scores = {78,89,97,45};
for (int i = 0;i < scores.length;i ++) {
    System.out.println(scores[i]); 
    //循环打印每一个数，数组名.length  用于获取数组的长度
}

6、二维数组

示例：

int[][] num = {{1,2,3},{4,5,6}};
for (int i = 0; i < num.length;i ++) {
    for (int j = 0;j < num[i].length;i ++) {
        //依次输出
        System.out.println(num[i][j]);
    }
    //换行
    System.out.println();
}
//输出：
1 2 3
4 5 6

7、注意

1、数组下标从 0 开始。因此 scores[3] ，表示数组中的第 4 个元素，而并非第 3 个元素
2、数组下标的范围是 0 至数组长度-1 ，如果越界访问，就会报错
6.使用Arrays类操作数组
Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等。
1）排序，语法：Arrays,sort(数组名)；
可以使用 sort( ) 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就可以完成对该数组的排序（按升序排列），例：

//定义一个整形数组
int[] scores = {78,79,89,98,72};
使用Arrays的sort（）方法对数组进行排序
Arrays.sort(scores);
System.out.println("排序后数组元素的值：");
//for循环输出值
for (int i = 0;i < scores.length; i ++) {
    System.out.println(scores[i]);
}
//输出：72 78 79 89 98

2）将数组转换为字符串, 语法：Arrays.toString(数组名);

可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开，例：

int [] nums = new int[] {25,89,78,45,12};
System.out.println("输出数组nums中的元素：" + Arrays.toString(nums));
//输出数组nums中的元素：[25，7，126，53，14，86]

3）使用 foreach 操作数组：foreach 并不是 Java 中的关键字，是 for 语句的特殊简化版本，在遍历数组、集合时， foreach 更简单便捷。从英文字面意思理解 foreach 也就是“ for 每一个”的意思

String[] strArr = {"123","456","789"};
//使用for循环遍历
for (int i = 0;i < strArr.length;i ++) {
    System.out.println(strArr[i]);
}
//使用foreach遍历
for (String str : strArr) {
    System.out.println(str);
}

二、方法

1、知识点概述

1、定义方法
方法由方法头和方法体组成，方法头：修饰符、返回值、方法签名（方法名+参数列表）
形参：定义在参数列表当中的参数；实参：调用方法时传入的值
2、通过传值进行参数传递
调用带参数的方法时，实参的值传递给形参，这个过程称为按值传递
3、重载方法
overload，重载，方法同名，参数列表不同。这里的参数列表不同指的是形式参数的类型或者数量不同，仅仅名字不同是没有用的
编译器在选择重载方法时，会选择实际参数与形式参数匹配最精确的方法进行执行。如果最精确的匹配结果不止一个，就会报错
4、方法的作用域
变量的作用域是指变量可以在程序中引用的范围
在方法中定义的变量称为局部变量
局部变量的作用域是从声明变量的地方开始，到包含该变量的块结束为止
信息的隐藏或者封装指的是：方法的实现细节封装在方法内，对调用该方法的用户隐藏

2、概念

① 访问修饰符有4种：public、protected、default、private
② 返回值类型可能是8大基本数据类型、引用类型或无返回值（void）
③ 方法名需符合标识符命名规范、方法名需见名知意、方法名需是小驼峰（类名是大驼峰）
④ 参数列表是该方法需要调用者传入的值（包括参数类型和参数名）
⑤ 方法体中才可编写 Java 语句（并不是所有花括号中都是方法体：如类定义的花括号中不是方法体）

方法体示例：

public class MethodBody {

    // 1.代码块
    {
        System.out.println("【{}】是方法体");
    }

    // 2.静态代码块
    static {
        System.out.println("【static {}】是方法体");
    }

    // 3.方法
    public void run(int age) {
        System.out.println("方法的花括号中是方法体");

        // 4.if
        if (age == 18) {
            System.out.println("if 语句的花括号中是方法体");
        }

        // 5.for
        for (int i = 0; i < age; i++) {
            System.out.println("for 循环的花括号中是方法体");
        }

        // 6.while
        while (age > 50) {
            System.out.println("while 循环的花括号中是方法体");
        }

        // 7.switch-case
        switch (age) {
            // 错误：在该区域写代码是错误的（该区域不是方法体）
            // System.out.println(age); // ERROR
            case 1: {
                System.out.println("switch 语句的 case 语句块是方法体");
            }
        }

        // 8.do-while
        do {
            System.out.println("do-while 循环的花括号中是方法体");
        } while (age < 5);
    }

}

3、定义参数

public class CreateMethodDemo {

    public static void main(String[] args) {
        int sum1 = CreateMethodDemo.sumOne2Hundred(1, 100);
        // sum1 = 5050
        System.out.println("sum1 = " + sum1);

        int sum2 = CreateMethodDemo.sumOne2Hundred(1, 1000);
        // sum2 = 500500
        System.out.println("sum2 = " + sum2);

        int sum3 = CreateMethodDemo.sumOne2Hundred(1, 10000);
        // sum3 = 50005000
        System.out.println("sum3 = " + sum3);
    }

    /**
     * 计算[start, end]的累加和
     *
     * @param start 起始值
     * @param end   结束值
     * @return [start, end]的累加和
     */
    private static int sumOne2Hundred(int start, int end) {
        int sum = 0;

        for (int i = start; i <= end; i++) {
            sum += i;
        }

        return sum;
    }

}

4、可变参数（Variable）

示例：：编写程序计算多个整数的和。eg：计算【2, 5, 6, 7, 66, 53】的和

思路1：
可把需要进行求和的整数放入一个整型数组中，并把整型数组作为参数传给 sumByArr 方法
sumByArr 方法接收一个 int 类型的数组作为参数，在 sumByArr 的方法体中通过 for 循环遍历数组中的数字，并进行求和
思路2：
使用可变参数替换 arr 数组

public class VariableParameter {

    public static void main(String[] args) {
        int[] arr = {2, 5, 6, 7, 66, 53};
        VariableParameter vp = new VariableParameter();
        // sumByArr = 139
        System.out.println(vp.sumByArr(arr));
    }

    /**
     * 计算多个整数的和（通过数组）
     *
     * @param arr （数组中存放需要进行求和的多个整数）
     * @return 数组中多个整数的和（类型是字符串）
     */
    private String sumByArr(int[] arr) {
        if (arr == null || arr.length < 1) return "arr 数组为 null, 为数组元素为 0";

        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return "sumByArr = " + sum; 
    }

}

可变参数的本质是数组
可变参数必须是方法的参数列表中的最后一个参数

public class VariableParameter {

    public static void main(String[] args) {
        VariableParameter vp = new VariableParameter();
        // 当 sumByVariable1Parameter 的参数列表中一个【值】都没有
        // 的时候, 返回值是可变参数类型的默认值
        int sum = vp.sumByVariable1Parameter(2, 5, 6, 7, 66, 53);
        // sumByVariable1Parameter = 139
        System.out.println("sumByVariable1Parameter = " + sum);
    }

    /**
     * 计算多个整数的和（通过可变参数）
     *
     * @param nums （参数列表中可以放多个需要进行求和的整数）
     * @return 参数列表中多个整数的和（类型 int）
     */
    private int sumByVariable1Parameter(int... nums) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        return sum;
    }

}

String 类有静态方法 format 可用于拼接字符，它的底层就用到了【可变参数】

public class VariableParameter {

    public static void main(String[] args) {
        String info = String.format("name: %s; age: %d; money: %f", 
        							"庆医", 10, 895863.99);
        // info = name: 庆医; age: 10; money: 895863.990000
        System.out.println("info = " + info);
    }
 
}

5、方法的参数传递问题

1. 基本数据类型：传递原始数据类型参数

基本类型作为参数是值传递
基本类型作为返回值，返回的是值本身
基本类型：byte、short、int、long、float、double、boolean、char

原始参数（eg：int 或 double）通过 value 传递给方法。意味着对参数值的任何更改仅存在于该方法的作用域内。

当方法返回后，栈帧销毁参数消失后，对它们的任何更改都将无效。

示例：

public class ArgumentsPassingTest {

    public static void main(String[] args) {
        int n = 10;
        test(n); // 值传递（v 和 n 没有关系）
        // n = 10
        System.out.println("n = " + n);
    }

    private static void test(int v) { // v = 10
        v = 20;
    }

}

基本类型作为返回值，返回的是值本身

2. 引用数据类型

引用类型作为参数是引用传递（地址传递）
引用类型作为返回值是引用传递 (地址传递)

引用数据类型参数（例如对象）也按值传递给方法。这意味着当方法返回时，传入的引用仍然引用着与之前相同的对象。但是，如果对象字段的值具有适当的访问级别，则可以在方法中更改它们。

public class ArgumentsPassingTest {

    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        test(nums);
        // nums = [1, 66, 3]
        System.out.println("nums = " + Arrays.toString(nums));
    }

    private static void test(int[] param) {
        param[1] = 66;
    }

}

引用类型作为返回值是引用传递（地址传递）:

public class ArgumentsPassingTest {

    public static void main(String[] args) {
        int[] test = test();

        // test = [1314, 520, 666]
        System.out.println("test = " + Arrays.toString(test));
    }

    private static int[] test() {
        int[] ints = {1314, 520, 666};
        return ints;
    }

}

栈帧销毁销毁的是局部变量信息，堆空间的对象不会被回收的。

3、方法签名

方法签名只由2部分组成：方法名、参数类型

private static void test(double pai, String name, int age) {
    return null;
}

上面方法的方法签名是：test(double, String, int)
在同一个类中，方法签名是唯一的（同一方法签名在同一个类中只能出现一次）

4、方法的重载

重载的方法通过传递给方法的参数的数量和类型来区分。
例如：run(String s) 和 run(int i) 是不同且独特的方法，因为它们拥有不同的参数类型。

重载：① 方法名相同，参数类型或数量不同；② 重载与返回值类型、参数名称无关
编译器在区分方法时不考虑返回类型，因此即使它们具有不同的返回类型，也不能声明具有相同签名的两个方法。
您不能声明多个具有相同名称和相同数量和类型的参数的方法，因为编译器无法区分它们。

下面的两个方法构成方法重载：

private static int[] test(double weight, String name, int age) {
    return null;
}

private static int[] test(int age, double weight, String name) {
    return null;
}

包睿婷

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java总结（第二周）

1、定义方法方法由方法头和方法体组成，方法头：修饰符、返回值、方法签名（方法名+参数列表）形参：定义在参数列表当中的参数；实参：调用方法时传入的值2、通过传值进行参数传递调用带参数的方法时，实参的值传递给形参，这个过程称为按值传递3、重载方法overload，重载，方法同名，参数列表不同。这里的参数列表不同指的是形式参数的类型或者数量不同，仅仅名字不同是没有用的编译器在选择重载方法时，会选择实际参数与形式参数匹配最精确的方法进行执行。如果最精确的匹配结果不止一个，就会报错。
复制链接

扫一扫