Java基础语法部分，结合chatGPT写的第一篇技术文章

MrXian
144 阅读11分钟

一、Java基础语法

1. 数据类型和变量

数据类型和变量是计算机编程中的重要概念，用于存储和处理不同类型的数据。

数据类型： 数据类型定义了变量可以存储的数据的种类以及对应的操作。不同的数据类型在内存中占据不同的存储空间，并确定了可以对变量执行的操作。

在Java中，有两种主要的数据类型：

  1. 基本数据类型（Primitive Data Types）： 这些数据类型包括整数、浮点数、字符和布尔值。Java的基本数据类型有：

    Java的基本数据类型用于存储常见的数据，如整数、浮点数、字符和布尔值。每种数据类型在内存中占据不同的存储空间。以下是Java基本数据类型及其占据的空间大小：

    a.整数类型：

    • byte：占据8位（1字节），表示范围为 -128 到 127。
    • short：占据16位（2字节），表示范围为 -32,768 到 32,767。
    • int：占据32位（4字节），表示范围为约 -2.1 亿到 2.1 亿。
    • long：占据64位（8字节），表示范围为约 -9 百万亿到 9 百万亿。

    b.浮点数类型：

    • float：占据32位（4字节），可表示约 7 位有效数字的浮点数。
    • double：占据64位（8字节），可表示约 15 位有效数字的浮点数。

    c.字符类型：

    • char：占据16位（2字节），用于存储Unicode字符。

    d.布尔类型：

    • boolean：通常占据1位（实际大小在不同环境中可能有变化，但至少1位），表示true或false值。

    需要注意的是，不同的硬件架构和Java虚拟机实现可能会对基本数据类型的存储大小有所不同。上述的空间大小是Java语言规范中定义的标准大小。

    在Java中，变量的声明通常遵循以下格式：

data_type variableName;

例如：

int age; // 声明一个整数类型的变量名为"age"
double salary; // 声明一个双精度浮点数类型的变量名为"salary"

例如，声明和初始化基本数据类型变量：

int age = 25;       // 声明一个整数变量"age"，赋值为25
double price = 9.99; // 声明一个双精度浮点数变量"price"，赋值为9.99
char grade = 'A';    // 声明一个字符变量"grade"，赋值为'A'
boolean isStudent = true; // 声明一个布尔变量"isStudent"，赋值为true

这些基本数据类型的选择取决于你的数据需求和性能考虑。在进行数值计算时，选择合适的数据类型可以有效地管理内存和提高计算性能。

  • 引用数据类型（Reference Data Types）是Java编程中用于处理对象和数据结构的类型。与基本数据类型不同，引用数据类型并不直接存储数据，而是存储数据的内存地址或引用。这使得Java可以支持更复杂的数据结构和对象的创建与使用。

在Java中，所有的类（包括用户自定义的类和Java标准库中的类）、接口、数组等都是引用数据类型。这些类型实际上是在堆内存中分配的对象的引用。

引用数据类型的特点包括：

  1. 内存存储： 引用数据类型的变量存储的是对象在内存中的引用或地址，而不是实际的对象数据。实际的对象数据存储在堆内存中。

  2. 动态分配： 引用数据类型的对象是在运行时动态分配的，它们的大小可能在编译时无法确定。

  3. 对象操作： 通过引用，可以对对象进行各种操作，包括调用方法、访问属性等。

  4. 空值引用： 引用数据类型的变量可以具有空值（null），表示没有引用任何对象。

    示例：

    // 创建一个引用数据类型的对象
String message = new String("Hello, World!");

// 另一个引用指向同一个对象
String anotherMessage = message;

// 修改一个引用的值会影响另一个引用
message = "New message";

// 创建一个数组对象
int[] numbers = new int[5];

// 创建一个用户自定义的类的对象
class Person {
    String name;
    int age;
}
Person person = new Person();
person.name = "Alice";
person.age = 30;

    在上面的示例中，String是Java标准库中的引用数据类型，int[]是一个整数数组的引用数据类型，Person是一个用户自定义的类的引用数据类型。引用数据类型的使用允许程序员创建和操作复杂的数据结构和对象。需要注意的是，Java的引用机制也需要注意内存管理，以防止出现内存泄漏和其他问题。

2. 运算符

Java运算符是用于在表达式中执行各种操作的符号。它们允许你对变量、常量和表达式进行各种数学、逻辑和其他类型的操作。Java中的运算符可以分为多个类别，包括算术运算符、赋值运算符、比较运算符、逻辑运算符等。

以下是一些常见的Java运算符及其功能：

算术运算符： 这些运算符用于执行基本的数学计算。

  • +：加法
  • -：减法
  • *：乘法
  • /：除法
  • %：取模（取余）

赋值运算符： 这些运算符用于将值赋给变量。

  • =：简单赋值
  • +=：加法赋值
  • -=：减法赋值
  • *=：乘法赋值
  • /=：除法赋值
  • %=：取模赋值

比较运算符： 这些运算符用于比较两个值的关系，并返回布尔结果。

  • ==：相等
  • !=：不相等
  • >：大于
  • <：小于
  • >=：大于等于
  • <=：小于等于

逻辑运算符： 这些运算符用于执行逻辑操作，返回布尔结果。

  • &&：逻辑与
  • ||：逻辑或
  • !：逻辑非

位运算符： 这些运算符用于在位级别执行操作。

  • &：位与
  • |：位或
  • ^：位异或
  • ~：位取反
  • <<：左移
  • >>：右移
  • >>>：无符号右移

条件运算符（三元运算符）：

  • condition ? expr1 : expr2：如果条件为真，则返回expr1，否则返回expr2。

实例：

int a = 10;
int b = 20;
int sum = a + b; // 使用算术运算符计算a和b的和

boolean isEqual = (a == b); // 使用比较运算符判断a是否等于b

boolean isTrue = true;
boolean isFalse = false;
boolean result = isTrue && isFalse; // 使用逻辑运算符执行逻辑与操作

int x = 5;
int y = (x > 0) ? x : -x; // 使用条件运算符计算绝对值

总之，Java运算符允许你执行各种操作，从基本的数学运算到逻辑判断，以及位级操作等。了解不同类型的运算符及其功能可以帮助你编写更复杂和有效的代码。

3. 控制流程（if、else、switch、循环）

Java控制流程是编程中用于控制程序执行顺序的结构。通过控制流程语句，可以实现条件执行、循环和跳转等不同的程序行为。Java中常见的控制流程语句包括条件语句（if-else）、循环语句（for、while、do-while）、以及跳转语句（break、continue、return）等。

以下是Java中常见的控制流程语句及其功能：

条件语句（if-else）： 条件语句根据给定的条件决定是否执行某个代码块。

int x = 10;
if (x > 5) {
    System.out.println("x is greater than 5");
} else {
    System.out.println("x is not greater than 5");
}

多重条件语句（if-else if-else）： 这是在多个条件中选择执行一个代码块的方式。

int grade = 85;
if (grade >= 90) {
    System.out.println("A");
} else if (grade >= 80) {
    System.out.println("B");
} else if (grade >= 70) {
    System.out.println("C");
} else {
    System.out.println("F");
}

循环语句（for、while、do-while）： 循环语句用于重复执行一段代码，直到某个条件不满足为止。

// for循环
for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

// while循环
int j = 1;
while (j <= 5) {
    System.out.println(j);
    j++;
}

// do-while循环
int k = 1;
do {
    System.out.println(k);
    k++;
} while (k <= 5);

跳转语句（break、continue、return）： 跳转语句用于在程序中进行控制流程的跳转。

  • break：用于中断循环或开关语句，并跳出当前代码块。
  • continue：用于结束当前迭代并跳转到下一次迭代。
  • return：用于从方法中返回值，并结束方法的执行。
for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break; // 当i等于5时中断循环
    }
    if (i % 2 == 0) {
        continue; // 当i为偶数时跳过本次迭代
    }
    System.out.println(i);
}

int add(int a, int b) {
    return a + b; // 从方法中返回结果
}

控制流程在编程中非常重要，可以根据不同的条件和需求来控制程序的执行流程，使程序更加灵活和有逻辑。

4. 异常处理（try、catch、finally）

异常处理是编程中处理错误和异常情况的机制。在程序执行过程中，可能会出现一些意外的情况，如数据错误、资源不足、网络问题等，这些情况可能会导致程序崩溃或不正确的行为。异常处理机制可以让我们在这些情况下优雅地管理错误，提高程序的健壮性和可维护性。

在Java中，异常是一个对象，它代表了某种错误或意外情况。Java异常分为两种类型：编译时异常（Checked Exceptions）和运行时异常（Unchecked Exceptions）。

编译时异常（Checked Exceptions）： 这些异常在编译阶段被检查，必须在代码中显式处理，否则程序无法编译通过。这些异常通常表示外部条件的问题，如文件不存在、网络连接断开等。

​ 这是一个文件读写时捕获异常的示例：

try {
    FileInputStream file = new FileInputStream("file.txt");
} catch (FileNotFoundException e) {// 找不到文件异常
    System.out.println("File not found: " + e.getMessage());
}

运行时异常（Unchecked Exceptions）： 这些异常在运行时发生，不需要在代码中强制处理。这些异常通常表示程序逻辑错误，如除以零、空指针引用等。

这是一个除0异常示例：

int a = 10;
int b = 0;
try {
    int result = a / b;// 10 / 0 运行时异常
} catch (ArithmeticException e) {
    System.out.println("Division by zero: " + e.getMessage());
}

异常处理的基本结构： 在处理异常时，使用try块来包裹可能抛出异常的代码。然后使用catch块来捕获特定类型的异常，并执行相应的处理逻辑。如果不想在catch块中处理异常，可以将异常继续抛出，让更高层的代码处理。

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理ExceptionType1类型的异常
} catch (ExceptionType2 e2) {
    // 处理ExceptionType2类型的异常
} finally {
    // 可选的finally块，无论是否有异常，都会执行
}

finally块： finally块中的代码无论是否发生异常，都会被执行。它通常用于释放资源，如关闭文件或数据库连接。

FileInputStream file = null;
try {
    file = new FileInputStream("file.txt");
    // 读取文件内容
} catch (FileNotFoundException e) {
    System.out.println("File not found: " + e.getMessage());
} finally {
    // 无论是否发生异常，都会被执行
    if (file != null) {
        try {
            file.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

异常处理是编程中重要的部分，它可以帮助我们更好地应对程序中的错误情况，确保程序在各种情况下都能够正确地处理和运行。

以下是几个常见的Java异常：

  1. 编译时异常（Checked Exceptions）：
    1. FileNotFoundException：文件未找到异常。
    2. IOException：输入输出异常。

这些异常在编译时被检查，必须在代码中显式处理，否则程序无法编译通过。

​ 2.运行时异常（Unchecked Exceptions）：

  1. NullPointerException：空指针异常。
  2. ArithmeticException：算术异常。
  3. ArrayIndexOutOfBoundsException：数组下标越界异常。
  4. NumberFormatException：数字格式异常。
  5. ClassCastException：类转换异常。
  6. IllegalArgumentException：非法参数异常。
  7. OutOfMemoryError：内存溢出异常。
  8. StackOverflowError：栈溢出异常。

这些异常在运行时发生，不需要在代码中强制处理。在实际开发中，你仍然可以使用try-catch块来处理运行时异常，但不是必需的。

这些是常见的Java异常，它们在不同情况下会被抛出，帮助开发人员识别和处理问题。了解这些异常有助于编写更健壮和可靠的代码。

5. 方法和函数

在Java中，方法（Method）和函数（Function）是用于执行特定任务或操作的代码块。它们允许将一段可重用的代码封装成一个单独的单元，以便在程序中多次调用。封装代码到方法或函数中可以提高代码的模块化性、可读性和可维护性。

方法（Method）： 在Java中，我们通常称其为“方法”。方法是类中定义的一块代码，用于执行特定的操作。方法可以接收参数，执行一些任务，并返回一个结果。方法也被用于执行类的构造、初始化和操作。

方法的基本结构如下：

返回类型 方法名(参数列表) {
    // 方法体，包含执行的代码
    // 可以使用参数，执行操作，并返回结果
}

示例：

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public void printMessage(String message) {
        System.out.println(message);
    }
}

函数（Function）： 在一些编程语言中，术语“函数”用于表示不属于任何类的一块可调用的代码。然而，在Java中，“函数”这个术语不是官方的，通常使用“方法”来代替。Java中的函数和方法是一样的概念，都是指封装在代码块中的可执行任务单元。

请注意，Java中的方法（或函数）必须属于类，因此，您不会看到直接在Java中定义的全局函数。

示例：

public class MathUtils {
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
    
    public static double square(double num) {
        return num * num;
    }
}

在Java中，通过创建类和在类中定义方法，可以轻松地将代码组织成可重用的单元。这有助于提高代码的可维护性和可读性，并使程序更加模块化。

最后，谢谢大家的观看，由于现在还是一名在校大学生，这也是我写的第一篇技术文章写，的深度也远远不如其他的技术大牛，希望大家多多包涵。我也会坚持下去，通过写博客提高自己对知识的掌握，谢谢大家。

avatar
文章
阅读
粉丝