前言

作为Java开发工程师，掌握JavaSE基础知识是我们的必备技能。JavaSE是Java平台的标准版，是Java的基础，涵盖了Java语言的核心特性和标准库。本篇博客将从实战的角度介绍JavaSE的一些重要知识点，帮助读者快速入门并在实际项目中得心应手。

安装Java Development Kit (JDK)

安装jdk

在开始之前，首先要安装JDK。在Oracle官网或OpenJDK官网下载适合自己操作系统的JDK版本，然后按照安装向导进行安装。

配置开发环境

安装完JDK后，需要配置开发环境变量。在Windows系统中，将JDK的安装路径添加到系统环境变量的PATH中；在Linux/Mac系统中，编辑bashrc或profile文件添加JAVA_HOME和PATH。

推荐安装指南：Windows下最简单的Java环境安装指南

验证是否安装配置成功

打开命令行窗口，输入java -version，会显示jdk的安装版本

再分别输入java和javac查看配置是否成功

编写第一个Java程序

hello world

让我们从"Hello World"开始，这是学习任何编程语言的传统。

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

使用文本编辑器编写以上代码，保存为HelloWorld.java。然后通过命令行编译并运行：

javac HelloWorld.java

java HelloWorld

如果一切顺利，你应该在控制台上看到"Hello, World!"的输出。

运行Java程序的流程

运行Java程序的流程可以简要概括如下：

1.编写Java代码：首先，您需要编写Java程序代码。Java代码以 .java 扩展名保存在文本文件中，其中包含类、方法和其他必要的代码。您可以使用文本编辑器或集成开发环境（IDE）来编写代码。

2.编译Java代码：一旦编写了Java代码，您需要将其编译成字节码。Java编译器（通常是javac命令）会将您的源代码转换为Java字节码文件（以 .class 扩展名保存）。这些字节码是平台无关的，并可以在任何支持Java虚拟机（JVM）的平台上运行。

3.运行Java程序：编译后，您可以通过Java虚拟机（JVM）来运行Java程序。JVM是Java应用程序运行的环境，它负责解释和执行Java字节码。在命令行中，使用java命令后跟类名来运行Java程序。

4.JVM加载字节码：JVM会加载并解释您的字节码文件。它通过从主类（在上面的例子中是HelloWorld类）开始执行程序。

5.执行Java程序：JVM会按照您在代码中定义的逻辑和顺序执行Java程序。程序可以调用其他类和方法，与用户交互，处理数据等等。

6.程序终止：当Java程序执行完所有的语句或遇到System.exit()等终止指令时，或者出现未捕获的异常导致程序崩溃时，程序执行将终止。

需要注意的是，JVM在运行时还涉及其他一些重要的步骤，例如内存管理、垃圾回收、类加载等，这些步骤在运行Java程序时都是自动进行的，而不需要用户干预。

数据类型和变量

Java是一种强类型语言，所以在使用变量之前需要先声明其数据类型。JavaSE提供了丰富的数据类型，如int、double、boolean等。声明和使用变量的示例：

public class DataTypesDemo {
    public static void main(String[] args) {
        int age = 30;
        double salary = 50000.50;
        boolean isEmployed = true;
        char gender = 'M';
        String name = "John";
        System.out.println(name + " is " + age + " years old, earning $" + salary);
        System.out.println("Gender: " + gender + ", Employed: " + isEmployed);
    }
}

数据类型

JavaSE中的数据类型可以分为两类：

原始数据类型：原始数据类型是JavaSE中最基本的数据类型，它们用于存储简单的值。Java提供了8种原始数据类型：

1.整数类型（Integer Types）：用于表示整数值，包括：byte、short、int和long。

byte: 8位，范围：-128 到 127

short: 16位，范围：-32,768 到 32,767

int: 32位，范围：-2^31 到 2^31 - 1

long: 64位，范围：-2^63 到 2^63 - 1

2.浮点类型（Floating-Point Types）：用于表示带有小数部分的数值，包括：float和double。

float: 32位，范围：约 -3.4E+38 到 +3.4E+38，精度约为6-7位小数

double: 64位，范围：约 -1.7E+308 到 +1.7E+308，精度约为15位小数

3.字符类型（Character Type）：用于表示单个字符，使用char，它是16位的Unicode字符。

4.布尔类型（Boolean Type）：用于表示真或假，使用boolean，只有两个值：true或false。

引用数据类型：引用数据类型是指引用对象的变量，而不是直接存储实际值。JavaSE中的引用数据类型包括：

1.类（Class）：用于创建自定义的数据类型。

2.接口（Interface）：用于定义一组方法签名，供类实现。

3.数组（Array）：用于存储多个相同类型的数据元素的集合。

变量

在JavaSE中，变量用于存储数据，并为数据提供名称。每个变量都有一个特定的数据类型，它决定了变量可以存储的值类型和范围。在JavaSE中，变量的声明和初始化是分开的步骤。

变量声明：变量声明定义了变量的名称和类型。例如：

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

你还可以在声明变量的同时对其进行初始化：

int count = 0; // 声明一个整数类型的变量名为count，并将其初始化为0
String name = "John"; // 声明一个字符串类型的变量名为name，并将其初始化为"John"

注意：在JavaSE中，变量的作用域取决于它们的声明位置。在代码块（花括号内部）中声明的变量只能在该代码块内访问。而在方法中声明的变量只能在该方法内访问。类级别的变量（静态变量）和实例变量则可以在整个类中使用。

程序逻辑控制

在JavaSE中，逻辑控制用于控制程序的执行流程，使得程序可以根据不同条件做出不同的决策。JavaSE中的逻辑控制主要包括以下三种结构：

条件语句

条件语句用于在程序中根据给定的条件选择执行不同的代码块。JavaSE中有两种条件语句：

if语句：用于根据一个条件是否为真来执行不同的代码块。如果条件为真，则执行if语句后的代码块，否则，可以选择执行else语句后的代码块（可选）。

int age = 25;
if (age >= 18) {
    System.out.println("成年人");
} else {
    System.out.println("未成年人");
}

switch语句：用于根据表达式的值在一系列选项中进行选择。可以使用case标签指定不同的选项，并使用break语句跳出switch语句。

int dayOfWeek = 3;
String day;
switch (dayOfWeek) {
    case 1:
        day = "星期一";
        break;
    case 2:
        day = "星期二";
        break;
    // ...
    default:
        day = "未知";
}

循环语句

循环语句用于重复执行一段代码，直到满足退出条件。JavaSE中有三种常用的循环语句：

for循环：用于指定循环的初始条件、循环条件和循环步进，重复执行代码块。

for (int i = 1; i <= 5; i++) {
    System.out.println("循环次数：" + i);
}

while循环：在执行循环之前先检查循环条件是否为真，只有在条件为真的情况下才会执行代码块。

int count = 0;
while (count < 5) {
    System.out.println("循环次数：" + count);
    count++;
}

do-while循环：类似于while循环，但它会先执行一次代码块，然后再检查循环条件。

int num = 1;
do {
    System.out.println("循环次数：" + num);
    num++;
} while (num <= 5);

跳转语句

跳转语句用于在代码执行过程中控制跳转到指定位置。JavaSE中有三种跳转语句：

break：用于立即跳出循环（for循环、while循环、do-while循环或switch语句）。

continue：用于跳过本次循环的剩余代码，直接进入下一次循环迭代。

return：用于终止方法的执行，并返回相应的值。

逻辑控制结构在JavaSE中是非常重要和常用的，它们允许程序根据不同的情况做出不同的决策，并实现循环执行特定的代码块，以实现更复杂和灵活的程序逻辑。

数组

在JavaSE中，数组是一种用于存储多个相同类型数据元素的数据结构。数组在Java中是固定长度、有序且索引从0开始的集合。数组的长度在创建时就确定，并且不能改变。

声明和创建数组

在Java中声明数组时需要指定数组的数据类型和数组的长度。声明数组的语法如下：

dataType[] arrayName; // 声明数组

例如，要声明一个整数数组：

int[] numbers;

要创建一个数组并分配内存空间，可以使用new关键字：

numbers = new int[5]; // 创建一个包含5个整数元素的数组

或者在声明时直接创建并初始化数组：

int[] numbers = new int[] { 1, 2, 3, 4, 5 }; // 创建并初始化一个包含5个整数元素的数组

访问数组元素

可以使用索引（下标）来访问数组中的元素。索引从0开始，表示数组中的第一个元素，依次递增。例如：

int[] numbers = { 10, 20, 30, 40, 50 };
// 访问数组中的元素
int firstElement = numbers[0]; // 数组的第一个元素，值为10
int thirdElement = numbers[2]; // 数组的第三个元素，值为30

数组长度

使用length属性来获取数组的长度（即元素的个数）。数组的长度在创建时指定，并且是一个常量，无法修改。

int[] numbers = { 10, 20, 30, 40, 50 };
int arrayLength = numbers.length; // 数组的长度为5

遍历数组

可以使用循环结构来遍历数组中的所有元素。

使用for循环遍历数组：

int[] numbers = { 10, 20, 30, 40, 50 };
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

使用for-each循环遍历数组（增强型for循环）：

int[] numbers = { 10, 20, 30, 40, 50 };
for (int number : numbers) {
    System.out.println(number);
}

多维数组

Java中还支持多维数组，即数组的元素也可以是数组。例如，二维数组是由数组组成的数组。声明和创建二维数组的方法如下：

dataType[][] arrayName; // 声明二维数组
arrayName = new dataType[rowSize][colSize]; // 创建二维数组
int[][] matrix = new int[3][3]; // 创建一个3x3的二维数组
// 初始化二维数组
matrix[0][0] = 1;
matrix[0][1] = 2;
matrix[0][2] = 3;
// ...
// 或者可以在声明时直接创建并初始化二维数组
int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };

遍历二维数组可以使用嵌套的for循环：

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

数组在Java中是非常常用的数据结构，对于处理大量数据元素很有用，并且可以通过循环和索引对其进行有效访问和操作。

面向对象编程（OOP）

当谈到面向对象编程（Object-Oriented Programming，OOP），我们指的是一种编程范式，它的主要思想是将现实世界中的事物抽象为对象，并通过这些对象之间的交互来构建程序。在面向对象编程中，我们将程序看作是一系列对象的集合，每个对象都有自己的状态和行为，并且能够通过消息传递来与其他对象进行交互。以下是面向对象编程的核心概念：

类（Class）：

类是面向对象编程的基本构建块。它是对一组具有相同属性和行为的对象的抽象描述。类定义了对象的结构和行为，并且可以看作是创建对象的模板。例如，如果我们有一个类叫做"Car"，那么它可以定义汽车的属性（如颜色、品牌、型号）以及行为（如启动、加速、刹车）。

对象（Object）：

对象是类的实例化结果，它是内存中的实体，具有类所定义的属性和行为。每个对象都有独立的状态，而类定义了这些对象的公共行为。继续以上面的例子，我们可以创建"Car"类的多个对象，如"myCar"、"friendCar"等。

封装（Encapsulation）：

封装是面向对象编程的一种特性，它允许将数据和行为封装在类中，阻止外部直接访问和修改对象的内部状态。通过封装，我们可以隐藏对象的实现细节，只暴露必要的接口，从而提高代码的可维护性和安全性。

继承（Inheritance）：

继承是一种类之间的关系，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和行为。通过继承，子类可以复用父类的代码，并且可以在不修改父类的情况下增加新的功能。这有助于减少代码冗余并促进代码重用。

多态（Polymorphism）：

多态是指同一操作可以在不同的对象上产生不同的结果。它允许我们使用统一的接口来处理不同类的对象，从而提高代码的灵活性和可扩展性。多态有两种形式：静态多态（方法重载）和动态多态（方法重写，也称为覆盖）。

面向对象编程有助于组织代码并使其更易于理解和维护。它提供了一种模块化的方式来编写代码，使开发人员可以更专注于解决问题而不是处理复杂的实现细节。在现代软件开发中，面向对象编程已经成为主流，被广泛应用于各种类型的应用程序开发。

详细示例介绍请看后续博客，感谢。

异常

在JavaSE中，异常是在程序执行过程中出现的错误或异常情况的事件。Java中的异常处理机制允许程序在出现异常时采取适当的措施，以保持程序的稳定性和可靠性。

异常的分类

在JavaSE中，异常分为两种类型：

已检查异常（Checked Exceptions）：是在编译时被检查的异常。在方法中抛出已检查异常，要么通过try-catch语句捕获处理，要么在方法签名中使用throws关键字声明该异常，让调用方法来处理。

未检查异常（Unchecked Exceptions）：也称为运行时异常（Runtime Exceptions），是在运行时才会被检测到的异常。这些异常通常是由程序错误导致的，例如除以零或访问数组越界。在编写代码时，通常不需要显式处理未检查异常。

异常处理语法

在Java中，可以使用try-catch语句来捕获并处理异常。try块中包含可能抛出异常的代码，而catch块用于捕获异常并处理它们。

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理ExceptionType1类型的异常
} catch (ExceptionType2 e2) {
    // 处理ExceptionType2类型的异常
} finally {
    // 可选的finally块，在异常处理之后始终执行
}

抛出异常

在Java中，我们也可以手动抛出异常，即使用throw关键字。这可以用于表示某些条件下的异常情况，并将异常传递给调用者处理。

public void someMethod(int value) {
    if (value < 0) {
        throw new IllegalArgumentException("值不能为负数");
    }
    // 其他代码
}

自定义异常

除了使用Java提供的异常类型，我们还可以自定义异常类。自定义异常类通常继承自Exception或其子类，以便在程序中使用。

public class CustomException extends Exception {
    // 自定义异常类的构造函数
    public CustomException(String message) {
        super(message);
    }
}

异常的链式处理

在处理异常时，我们可以使用异常的链式处理，即在catch块中捕获异常后，继续抛出新的异常或重新抛出原有的异常。

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理ExceptionType1类型的异常，并抛出新的异常
    throw new CustomException("处理ExceptionType1异常时发生错误", e1);
} catch (ExceptionType2 e2) {
    // 处理ExceptionType2类型的异常，并重新抛出原有的异常
    throw e2;
} finally {
    // 可选的finally块，在异常处理之后始终执行
}

实践：异常处理的示例

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int result = divideNumbers(10, 0);
            System.out.println("结果：" + result);
        } catch (ArithmeticException e) {
            System.out.println("除法运算异常：" + e.getMessage());
        } finally {
            System.out.println("程序执行完毕。");
        }
    }
    public static int divideNumbers(int dividend, int divisor) {
        if (divisor == 0) {
            throw new ArithmeticException("除数不能为零");
        }
        return dividend / divisor;
    }
}

异常处理是JavaSE中重要的概念，它可以让我们在程序执行过程中处理潜在的错误情况，从而增加程序的健壮性和稳定性。使用适当的异常处理机制可以使程序更容易维护和调试。

总结

本篇博客涵盖了JavaSE基础知识的实战指南，希望通过这些简单的示例能够帮助你快速入门JavaSE编程。Java是一门强大而且广泛应用的编程语言，掌握好基础知识是成为优秀Java开发工程师的第一步。