一遍过JavaSE基础知识

文章目录

  • 前言
  • 安装Java Development Kit (JDK)
    • 安装jdk
    • 配置开发环境
    • 验证是否安装配置成功
  • 编写第一个Java程序
    • hello world
    • 运行Java程序的流程
  • 数据类型和变量
    • 数据类型
    • 变量
  • 程序逻辑控制
    • 条件语句
    • 循环语句
    • 跳转语句
  • 数组
    • 声明和创建数组
    • 访问数组元素
    • 数组长度
    • 遍历数组
    • 多维数组
  • 面向对象编程(OOP)
  • 异常
    • 异常的分类
    • 异常处理语法
    • 抛出异常
    • 自定义异常
    • 异常的链式处理
    • 实践:异常处理的示例
  • 总结

探索JavaSE基础知识,开启编程之旅!

如果你对Java编程语言感兴趣,或者想成为一名优秀的Java开发者,那么这篇博客绝对不容错过!

在这篇JavaSE基础知识的博客中,你将发现:

JavaSE的核心概念:深入解析Java的数据类型、变量、逻辑控制等基本要素,为你打下坚实的编程基础。

异常处理:了解如何在程序中处理错误和异常情况,让你的程序更加健壮和可靠。

数组与多维数组:掌握数组的创建、访问和遍历技巧,以及如何应用于多维数据结构。

自定义异常:学会如何创建并应用自己的异常类,让你的代码更加灵活和可读。

实用实践:通过实际案例演示,你将更深入理解JavaSE的应用场景,提升你的编程技能。

不论你是初学者还是有一定经验的开发者,这篇博客都能帮助你建立坚实的JavaSE基础,为你未来的学习和发展打下坚实的基础。

不要错过这个宝贵的学习机会!

拓展你的编程技能,JavaSE等你探索!Happy coding!

前言

作为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查看配置是否成功
一遍过JavaSE基础知识_第1张图片
一遍过JavaSE基础知识_第2张图片

编写第一个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
  1. 浮点类型(Floating-Point Types):用于表示带有小数部分的数值,包括:float和double。
  • float: 32位,范围:约 -3.4E+38 到 +3.4E+38,精度约为6-7位小数
  • double: 64位,范围:约 -1.7E+308 到 +1.7E+308,精度约为15位小数
  1. 字符类型(Character Type):用于表示单个字符,使用char,它是16位的Unicode字符。

  2. 布尔类型(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开发工程师的第一步。

你可能感兴趣的:(Java,JavaSE,jdk安装配置,Java基础)