大学生浅学java心得

m0_74318316

已于 2023-11-30 15:54:04 修改

阅读量63

点赞数

文章标签：开发语言 java

于 2023-11-30 15:52:48 首次发布

本文链接：https://blog.csdn.net/m0_74318316/article/details/134638807

版权

本文介绍了Java语言的基础知识，包括Java的发展历程、基本概念（如变量、数据类型、运算符）、开发环境搭建（JDK和JRE）、第一个Java程序的编写，以及后续章节中深入探讨的数据类型、运算符优先级、控制结构（if、switch、循环）、数组、类与对象、方法和构造方法等内容。

摘要由CSDN通过智能技术生成

第一章 Java入门第1课

初识java

在开始学习Java之前，我首先了解到了Java的发展历程以及其跨平台的特性。Java是一种面向对象的编程语言，它具有简单、面向对象、分布式、强类型、可移植等特性。这些特性的介绍使我对于Java有了基本的认识和理解。

在学习Java的语法规则时，我接触到了诸如变量、数据类型、运算符和控制流程等基础概念。这些概念在后续的学习中发挥了重要的作用，它们是构建Java程序的基础。

Java开发环境搭建

Java官网：(https://www.java.com/zh-CN/download/)

在掌握了Java的基本概念后，我开始学习如何搭建Java开发环境。在这个过程中，我了解了JDK（Java Development Kit）和JRE（Java Runtime Environment）的区别和作用。同时，我也学会了如何下载和安装JDK和JRE，以及如何在计算机上配置环境变量。通过完成这个学习任务，我不仅掌握了Java开发环境的基础知识，还增强了自己的动手实践能力。

第一个java程序

在搭建好Java开发环境后，我开始学习如何编写和运行Java程序。在这个过程中，我学习了如何使用文本编辑器编写Java代码，以及如何使用命令行工具编译和运行Java程序。通过编写一个简单的“Hello World”程序，我学会了如何在控制台输出信息。这个学习任务让我对于Java编程有了更深入的理解，也让我对于编程有了更多的热情和兴趣。

这是我写的第一个java程序：

public class HelloWorld {  
    public static void main(String[] args) {  
        System.out.println("Hello, World!");  
    }  
}

总结

：通过本章的学习，我对于Java有了基本的认识和理解，掌握了Java开发环境的基础知识，学会了如何编写和运行Java程序。这些知识和技能将为我后续的学习和实践打下坚实的基础。

第二章 Java语言基础第1课

数据类型、常量与变量

在这一课中，我学习了Java中的数据类型、常量与变量。了解了Java是一种静态类型语言，它的数据类型可以分为基本类型和引用类型。基本类型包括int、char、boolean等，而引用类型则是对象类型。同时，我也学习了如何声明和初始化变量，以及常量的概念和特点。

运算符、运算符的优先级

接下来，我学习了Java中的运算符和运算符的优先级。了解了Java支持的运算符类型，如算术运算符、比较运算符、逻辑运算符等。同时，我也学习了运算符的优先级和结合性，这对于编写正确的表达式和代码非常重要。通过这个学习，我对于Java语言中的运算符和运算规则有了更深入的了解。

public class OperatorExample {  
    public static void main(String[] args) {  
        // 定义三个整数变量a、b和c，并初始化它们的值  
        int a = 5;  
        int b = 10;  
        int c = 15;  
  
        // 使用+和*运算符计算表达式a + b * c的值  
        int result = a + b * c;  // 5 + (10 * 15) = 165  
        System.out.println("a + b * c = " + result); // 输出结果：a + b * c = 165  
  
        // 使用括号改变表达式的计算顺序，先执行乘法运算，再执行加法运算  
        result = a + (b * c);  // 5 + (10 * 15) = 165  
        System.out.println("a + (b * c) = " + result); // 输出结果：a + (b * c) = 165  
  
        // 使用括号将加法运算和乘法运算分组，先执行乘法运算，再执行加法运算  
        result = (a + b) * c;  // (5 + 10) * 15 = 225  
        System.out.println("(a + b) * c = " + result); // 输出结果：(a + b) * c = 225  
    }  
}

数据类型转换

在上一课的基础上，我继续学习了Java中的数据类型转换。了解了Java中数据类型之间的转换规则和方法，如隐式转换和显式转换。同时，我也学习了数据类型转换的方法，如int类型的强制类型转换和String类型的转换。通过这个学习，我对于Java语言中的数据类型转换有了更深入的了解。

示例

public class DataTypeConversionExample {  
    public static void main(String[] args) {  
        int a = 100;  
        double b = 100.0;  
        boolean c = true;  
        char d = 'A';  
  
        // 将int类型转换为double类型  
        double intToDouble = (double) a;  
        System.out.println("intToDouble = " + intToDouble);  
  
        // 将double类型转换为int类型  
        int doubleToInt = (int) b;  
        System.out.println("doubleToInt = " + doubleToInt);  
  
        // 将boolean类型转换为int类型  
        int booleanToInt = (int) c;  
        System.out.println("booleanToInt = " + booleanToInt);  
  
        // 将char类型转换为int类型  
        int charToInt = (int) d;  
        System.out.println("charToInt = " + charToInt);  
    }  
}

控制台输入输出

我学习了Java中的控制台输入输出。了解了如何使用System.out.println方法输出信息到控制台，以及如何使用Scanner类从控制台读取输入。通过这个学习，我不仅学会了如何输出信息和读取用户输入，还对于Java语言中的控制台输入输出有了更深入的了解。

第三章选择结构

3.1 If分支语句

If分支语句是编程中最基本的选择结构之一，用于根据条件执行不同的代码块。通过学习，我掌握了以下内容：

If语句的语法：if (condition) { code block }。
If语句的执行流程：如果条件为真，则执行代码块；否则跳过。
If语句的实用场景：用于根据不同的条件执行不同的操作，例如判断用户输入的密码是否正确：

import java.util.Scanner;  
  
public class PasswordCheck {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        System.out.print("请输入密码：");  
        String inputPassword = scanner.nextLine();  
        String correctPassword = "123456";  
        if (inputPassword.equals(correctPassword)) {  
            System.out.println("密码正确！");  
        } else {  
            System.out.println("密码错误！");  
        }  
    }  
}

3.2 Switch多分支语句

Switch多分支语句是一种更高级的选择结构，用于处理多个条件的情况。通过学习，我掌握了以下内容：

Switch语句的语法：switch (expression) { case value1: code block1; break; case value2: code block2; break; … default: code block; }。
Switch语句的执行流程：根据expression的值，与每个case标签后面的value进行比较，如果匹配，则执行相应的代码块，如果不匹配，则执行default代码块（如果有）。
Switch语句的实用场景：用于处理多个条件的情况，例如根据不同的用户角色显示不同的权限等。

import java.util.Scanner;  
  
public class SwitchExample {  
    public static void main(String[] args) {  
        Scanner input = new Scanner(System.in);  
        System.out.print("请输入您的用户角色：");  
        int role = input.nextInt();  
        switch (role) {  
            case 1:  
                System.out.println("您是普通用户，可以查看所有信息。");  
                break;  
            case 2:  
                System.out.println("您是高级用户，可以查看和修改个人信息。");  
                break;  
            case 3:  
                System.out.println("您是管理员，可以查看、修改和删除所有信息。");  
                break;  
            default:  
                System.out.println("您的用户角色无效。");  
        }  
    }  
}

3.3 分支嵌套

分支嵌套是将一个if语句或switch语句嵌套在另一个if语句或switch语句中，以实现更复杂的条件判断。通过学习，我掌握了以下内容：

分支嵌套的语法：在if语句或switch语句中使用另一个if语句或switch语句。
分支嵌套的执行流程：根据外部条件判断是否执行内部条件判断，如果满足内部条件，则执行相应的代码块。
分支嵌套的实用场景：用于实现更复杂的条件判断，例如多级权限控制等。

示例程序：


```import java.util.Scanner;  
  
public class PermissionCheck {  
    public static void main(String[] args) {  
        Scanner input = new Scanner(System.in);  
        System.out.print("请输入用户名：");  
        String username = input.nextLine();  
        System.out.print("请输入密码：");  
        String password = input.nextLine();  
  
        // 使用分支嵌套进行多级权限判断  
        if (username.equals("admin")) {  
            // 如果是管理员用户，则进一步判断密码是否正确  
            if (password.equals("123456")) {  
                System.out.println("登录成功！您拥有管理员权限！");  
            } else {  
                System.out.println("密码错误！您没有管理员权限！");  
            }  
        } else if (username.equals("user")) {  
            // 如果是普通用户，则进一步判断密码是否正确  
            if (password.equals("654321")) {  
                System.out.println("登录成功！您拥有普通用户权限！");  
            } else {  
                System.out.println("密码错误！您没有普通用户权限！");  
            }  
        } else {  
            System.out.println("用户名或密码错误！您没有登录权限！");  
        }  
    }  
}

第四章循环结构

在这一章中，我们学习了循环结构的基本概念和语法，包括while语句、do…while语句、for循环语句以及循环嵌套。通过这些内容的学习，我深入理解了循环结构在编程中的应用，并掌握了一些实用的技巧。

4.1 while语句和do…while语句

while语句和do…while语句是两种基本的循环结构，它们都用于重复执行一段代码，直到满足某个条件。while语句先判断条件，再执行循环体，而do…while语句先执行循环体，再判断条件。
程序示例：

public class LoopExample {  
    public static void main(String[] args) {  
        int sum = 0;  // 初始化sum为0  
        int i = 1;     // 初始化i为1  
  
        // while循环语句  
        while (i <= 5) {  
            sum += i;  // 将i加入sum中  
            i++;       // i自增1  
        }  
        System.out.println("1到5的和为：" + sum); // 输出结果  
  
        sum = 0;  // 初始化sum为0  
        i = 1;   // 初始化i为1  
  
        // do...while循环语句  
        do {  
            sum += i;  // 将i加入sum中  
            i++;       // i自增1  
        } while (i <= 5); // 判断条件  
  
        System.out.println("1到5的和为：" + sum); // 输出结果  
    }  
}

4.2 for循环语句

for循环语句是一种更为高级的循环结构，它允许我们在循环中声明循环变量的初始值、条件和每次迭代的操作。使用for循环语句，我们可以更加简洁地实现一些循环操作，例如遍历数组或计算累加和等。
程序示例：

public class ForLoopExample {  
    public static void main(String[] args) {  
        // 使用for循环语句打印1到10的数字  
        for (int i = 1; i <= 10; i++) {  
            System.out.println(i);  
        }  
    }  
}

4.3 break和continue语句

break和continue语句是循环结构中的两个重要控制语句。break语句用于跳出整个循环，而continue语句用于跳过当前循环的剩余部分，进入下一次循环。学习这两个语句的用法，我学会了如何在循环中实现一些特殊的需求，例如跳过某些循环次数或者提前结束循环。
程序示例：

public class SumCalculator {  
    public static void main(String[] args) {  
        int sum = 0;  
        for (int i = 1; i <= 100; i++) {  
            // 如果i是偶数，则跳过本次循环  
            if (i % 2 == 0) {  
                continue;  
            }  
            // 如果i是3的倍数，则跳出整个循环  
            if (i % 3 == 0) {  
                break;  
            }  
            sum += i;  
        }  
        System.out.println("1到100之间所有整数的和为：" + sum);  
    }  
}

4.4 循环嵌套

循环嵌套是指在一个循环内部嵌套另一个循环的情况。通过学习循环嵌套的语法和用法，我学会了如何使用多层循环实现一些复杂的操作，例如打印乘法口诀表或生成二维数组等。同时，我也了解了在使用循环嵌套时需要注意避免出现死循环的情况。
下面是一个打印出乘法口诀表的简单程序示例：

public class MultiplicationTable {  
    public static void main(String[] args) {  
        for (int i = 1; i <= 9; i++) {  
            for (int j = 1; j <= i; j++) {  
                System.out.print(j + " x " + i + " = " + (i * j) + "\t");  
            }  
            System.out.println();  
        }  
    }  
}

第五章数组

5.1 一维数组

一维数组是一种线性数据结构，可以包含多个元素，并且每个元素都可以通过其索引进行访问。在本节中，您将学习如何声明、初始化和访问一维数组。

5.1.1 一维数组的声明和初始化

在Java中，使用以下语法声明和初始化一维数组：

type[] arrayName = new type[size];

其中，type是数组中元素的数据类型，arrayName是为数组选择的名称，size是数组的大小，即它可以容纳的元素数。例如，以下代码声明了一个包含5个整数的数组：

int[] myArray = new int[5];

5.1.2 一维数组的访问

要访问一维数组中的元素，可以使用索引。索引从0开始，因此第一个元素的索引是0，第二个元素的索引是1，依此类推。以下是访问数组中元素的示例代码：

myArray[0] = 10;    // 设置第一个元素为10  
int firstElement = myArray[0];    // 获取第一个元素的值

5.2 二维数组

二维数组是一种矩形数据结构，可以包含多个行和列。在本节中，将学习如何声明、初始化和访问二维数组。

5.2.1 二维数组的声明和初始化

在Java中，可以使用以下语法声明和初始化二维数组：

type[][] arrayName = new type[rowSize][colSize];

其中，type是数组中元素的数据类型，arrayName是数组选择的名称，rowSize和colSize分别是数组的行数和列数。以下代码声明了一个包含3行4列的二维整数数组：

int[][] myArray = new int[3][4];

第六章方法的定义及调用

方法是指在程序中为了实现特定功能而定义的一段代码块。方法的定义包括方法名、参数列表和方法体。方法调用是指通过方法名和传递给方法的参数来执行相应的方法体。

方法定义示例：

public class MyMath {  
    public static int add(int a, int b) {  
        return a + b;  
    }  
}

方法调用示例：

int result = MyMath.add(2, 3); // 调用MyMath类中的add方法，并传递2和3两个整数参数  
System.out.println(result); // 输出5，即2和3的和

6.2 方法的参数传递

方法的参数传递是指将参数传递给方法，以便方法能够使用这些参数执行相应的操作。Java中参数传递的方式有两种：按值传递和按引用传递。在按值传递中，传递的是参数的副本，方法对参数的修改不会影响原始值；而在按引用传递中，传递的是参数的引用，方法对参数的修改会影响原始值。

public class ParameterPassing {  
    public static void main(String[] args) {  
        int x = 10;  
        changeValue(x); // 按值传递，不会改变x的值  
        System.out.println(x); // 输出10  
        changeReference(x); // 按引用传递，会改变x的值  
        System.out.println(x); // 输出20  
    }  
  
    public static void changeValue(int a) {  
        a = 20; // 按值传递，不会影响原始值  
    }  
  
    public static void changeReference(int a) {  
        a = 20; // 按引用传递，会影响原始值  
    }  
}

6.3 方法的重载

方法重载是指在一个类中定义多个同名方法，但这些方法的参数列表必须不同（参数个数或参数类型至少有一个不同）。这样就可以根据不同的参数列表来调用相应的方法，实现多态性。重载方法的方法名相同，但参数列表不同，编译器会根据调用时提供的实参类型和个数来确定具体调用哪个方法。

第7章类与对象的一课一得

在本章中，我们学习了关于Java中类与对象的基础知识。类是一种抽象的概念，用于描述具有相似属性和行为的对象的集合。对象则是类的实例，具有类定义的属性和行为。通过学习本章，我深入理解了类与对象的关系，并掌握了如何定义类、创建对象以及使用getter和setter方法访问对象的属性。此外，还学习了构造方法的作用和使用，以及静态成员的声明和访问。