一文写清楚 Java17 所有基础内容【真小白教程、全面示例！！！】

前言

Java 17作为2021年9月发布的长期支持(LTS)版本，是Java语言发展的重要里程碑。它不仅引入了密封类(Sealed Classes)等革命性新特性，还优化了开发环境配置、简化了Switch表达式、增强了模式匹配功能，并提供了更友好的文本块支持。本指南将从零开始，全面介绍Java 17的基础知识，帮助初学者快速掌握Java编程的核心概念与最新特性。

一、Java环境安装与配置

1.1 Java 17简介与下载

Java 17是Java语言的最新LTS版本，提供长期支持至2029年，这意味着它将是企业级应用开发的首选版本。对于初学者，Java 17的语法和特性已经足够稳定，是学习Java的理想起点。
推荐下载OpenJDK 17：由于Oracle JDK 17的免费期已于2024年9月结束，初学者应选择免费且开源的OpenJDK 17版本。以下是几种主要的OpenJDK 17发行版：

Oracle：收购 Sun 后，由 Oracle 接管维护【最为推荐！！！】https://www.oracle.com/cn/java/technologies/downloads/#jdk17-windows
Eclipse Temurin：由Eclipse基金会维护（官网：https://adoptium.net/）
Azul Zulu：由Azul Systems维护，提供商业支持（官网：https://www.azul.com/downloads/）
Red Hat OpenJDK：由Red Hat维护，适合企业使用（官网：https://developers.redhat.com/products/openjdk/download）

1.2 安装与配置环境变量

Windows系统安装

下载并安装JDK 17
- 访问Eclipse Temurin官网，下载Windows版本
- 运行下载的EXE文件，选择安装路径（如C:\Program Files\Java\jdk-17）
- 安装完成后，关闭安装向导
配置环境变量
- 右键点击"此电脑"，选择"属性"，点击"高级系统设置"
- 在"系统属性"窗口中，点击"环境变量"
- 在"系统变量"区域，点击"新建"，添加以下变量：
  - 变量名：JAVA_HOME
  - 变量值：JDK安装路径（如C:\Program Files\Java\jdk-17）
- 在"系统变量"区域，找到Path变量，点击"编辑"，添加%JAVA_HOME%\bin
验证安装
- 打开命令提示符（Win+R，输入cmd）
- 输入以下命令查看版本信息：

java -version
javac

macOS系统安装

使用Homebrew安装（推荐）
- 打开终端，执行以下命令安装Homebrew（如未安装）：

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

- 安装OpenJDK 17：

brew install openjdk@17

- 配置环境变量：

echo 'export PATH="/opt/homebrew/opt/openjdk@17/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

- 验证安装：

java -version

直接下载安装
- 访问Eclipse Temurin官网，下载macOS版本
- 双击下载的DMG文件，将JDK安装到系统中
- 配置环境变量（同上）

Linux系统安装（以Ubuntu为例）

使用apt安装（推荐）
- 更新软件包列表：

sudo apt update

- 安装OpenJDK 17：

sudo apt install openjdk-17-jdk

手动下载安装
- 下载JDK包：

wget --header="Cookie: oraclelicense=accept-securebackup-cookie" https://download.oracle.com/java/17/archive/jdk-17.0.10_linux-x64_bin.tar.gz

- 解压安装包：

tar -zxvf jdk-17.0.10_linux-x64_bin.tar.gz

- 配置环境变量：

sudo nano /etc/profile

在文件末尾添加：

export JAVA_HOME=/path/to/your/jdk-17
export PATH=$PATH:$JAVA_HOME/bin

保存并退出，执行：

source /etc/profile

- 验证安装：

java -version

1.3 编写第一个Java程序

完成环境配置后，我们可以编写第一个Java程序：

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

编译与运行：

编译：javac HelloWorld.java
运行：java HelloWorld

二、Java基础语法

2.1 数据类型

Java是一种强类型语言，所有变量都必须先声明类型再使用。Java 17支持以下基本数据类型：

类型	大小	取值范围	默认值	示例
byte	1字节	-128 到 127	0	byte age = 25;
short	2字节	-32,768 到 32,767	0	short port = 8080;
int	4字节	-2^{31 到 2}31-1	0	int count = 100;
long	8字节	-2^{63 到 2}63-1	0L	long population = 10_000_000L;
float	4字节	±3.40282347E+38	0.0f	float price = 19.99f;
double	8字节	±1.7976931348623157E+308	0.0d	double pi = 3.1415926535;
boolean	1位	true 或 false	false	boolean isReady = true;
char	2字节	Unicode字符	‘\u0000’	char initial = ‘J’;
示例代码：

public class DatatypesExample {
    public static void main(String[] args) {
        byte smallNumber = 127; // 最大值
        short mediumNumber = 32767; // 最大值
        int largeNumber = 2147483647; // 最大值
        long veryLargeNumber = 9223372036854775807L; // 最大值
        float price = 19.99f;
        double distance = 123456789.123456789d;
        boolean isJavaFun = true;
        char myInitial = 'A';
        System.out.println("smallNumber: " + smallNumber);
        System.out.println("mediumNumber: " + mediumNumber);
        System.out.println("largeNumber: " + largeNumber);
        System.out.println("veryLargeNumber: " + veryLargeNumber);
        System.out.println("price: " + price);
        System.out.println("distance: " + distance);
        System.out.println("isJavaFun: " + isJavaFun);
        System.out.println("myInitial: " + myInitial);
    }
}

2.2 变量与常量

变量是程序中可以存储和操作数据的容器，常量则是不可修改的固定值。

public class VariablesAndConstants {
    // 常量定义
    public static final double PI = 3.1415926535;
    public static void main(String[] args) {
        // 变量声明与初始化
        int number = 10;
        String name = "Java";
        boolean isJava17LTS = true;
        // 打印变量和常量
        System.out.println("Number: " + number);
        System.out.println("Name: " + name);
        System.out.println("PI: " + PI);
        System.out.println("Is Java 17 LTS: " + isJava17LTS);
    }
}

2.3 运算符

Java支持多种运算符，用于执行各种操作：

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        // 算术运算符
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));
        // 赋值运算符
        a += b; // a = a + b
        System.out.println("a += b: " + a);
        // 比较运算符
        System.out.println("a == b: " + (a == b));
        System.out.println("a != b: " + (a != b));
        System.out.println("a > b: " + (a > b));
        System.out.println("a < b: " + (a < b));
        System.out.println("a >= b: " + (a >= b));
        System.out.println("a <= b: " + (a <= b));
        // 逻辑运算符
        boolean x = true;
        boolean y = false;
        System.out.println("x && y: " + (x && y));
        System.out.println("x || y: " + (x || y));
        System.out.println "!x: " + (!x));
    }
}

2.4 控制结构

条件语句

public class ControlStructures {
    public static void main(String[] args) {
        int score = 85;
        // if语句
        if (score >= 60) {
            System.out.println("及格");
        }
        // if-else语句
        if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 80) {
            System.out.println("良好");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }
        // switch语句（传统写法）
        String dayType;
        String day = "Monday";
        switch (day) {
            case "Monday":
            case "Tuesday":
            case "Wednesday":
            case "Thursday":
            case "Friday":
                dayType = "Weekday";
                break;
            case "Saturday":
            case "Sunday":
                dayType = "Weekend";
                break;
            default:
                dayType = "Invalid day";
                break;
        }
        System.out.println("Day type: " + dayType);
    }
}

循环语句

public class LoopsExample {
    public static void main(String[] args) {
        // for循环
        System.out.println("For loop");
        for (int i = 1; i <= 5; i++) {
            System.out.println("Iteration: " + i);
        }
        // while循环
        System.out.println("\nWhile loop");
        int j = 1;
        while (j <= 5) {
            System.out.println("Iteration: " + j);
            j++;
        }
        // do-while循环
        System.out.println("\nDo-while loop");
        int k = 1;
        do {
            System.out.println("Iteration: " + k);
            k++;
        } while (k <= 5);
        // for-each循环
        System.out.println("\nFor-each loop");
        String[] fruits = {"Apple", "Banana", "Orange"};
        for (String fruit : fruits) {
            System.out.println("Fruit: " + fruit);
        }
    }
}

2.5 数组

数组是存储同类型数据的集合，Java支持一维和多维数组。

public class ArraysExample {
    public static void main(String[] args) {
        // 一维数组
        int[] numbers = new int[5];
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;
        System.out.println("一维数组元素");
        for (int number : numbers) {
            System.out.println(number);
        }
        // 二维数组
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        System.out.println("\n二维数组元素");
        for (int[] row : matrix) {
            for (int element : row) {
                System.out.print(element + " ");
            }
            System.out.println();
        }
    }
}

2.6 方法

方法是一段可重复使用的代码块，用于执行特定任务。

public class MethodsExample {
    // 计算两个整数之和的方法
    public static int add(int a, int b) {
        return a + b;
    }
    // 计算面积的方法（重载）
    public static double area(double radius) {
        return Math.PI * radius * radius;
    }
    public static double area(double width, double height) {
        return width * height;
    }
    public static void main(String[] args) {
        // 调用add方法
        int sum = add(10, 20);
        System.out.println("10 + 20 = " + sum);
        // 调用area方法（圆）
        double circleArea = area(5.0);
        System.out.println("圆面积（半径5）: " + circleArea);
        // 调用area方法（矩形）
        double rectangleArea = area(10.0, 20.0);
        System.out.println("矩形面积（长10，宽20）: " + rectangleArea);
    }
}

三、面向对象编程（OOP）

Java是一种面向对象的语言，其核心概念包括类、对象、继承、多态、接口和包。

3.1 类与对象

public class ClassAndObject {
    // 定义Person类
    static class Person {
        // 属性
        String name;
        int age;
        // 构造方法
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        // 方法
        public void sayHello() {
            System.out.println("Hello, my name is " + name + ", I'm " + age + " years old.");
        }
    }
    public static void main(String[] args) {
        // 创建对象
        Person person1 = new Person("Alice", 30);
        Person person2 = new Person("Bob", 25);
        // 调用方法
        person1.sayHello();
        person2.sayHello();
    }
}

3.2 继承

public class InheritanceExample {
    // 父类Animal
    static class Animal {
        String name;
        public Animal(String name) {
            this.name = name;
        }
        public void eat() {
            System.out.println(name + " is eating.");
        }
        public void sleep() {
            System.out.println(name + " is sleeping.");
        }
    }
    // 子类Dog继承自Animal
    static class Dog extends Animal {
        public Dog(String name) {
            super(name);
        }
        // 重写父类方法
        @Override
        public void eat() {
            System.out.println(name + " is eating bones.");
        }
        // 子类特有方法
        public void bark() {
            System.out.println(name + " is barking: Woof!");
        }
    }
    public static void main(String[] args) {
        Animal animal = new Animal("Generic Animal");
        Dog dog = new Dog("Buddy");
        animal.eat();
        animal.sleep();
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

3.3 多态

多态是面向对象编程的三大特性之一，Java中主要通过方法重写实现。

public class PolymorphismExample {
    // 父类Shape
    static abstract class Shape {
        // 抽象方法
        public abstract void draw();
    }
    // 子类Circle继承自Shape
    static class Circle extends Shape {
        @Override
        public void draw() {
            System.out.println("Drawing a circle");
        }
    }
    // 子类Rectangle继承自Shape
    static class Rectangle extends Shape {
        @Override
        public void draw() {
            System.out.println("Drawing a rectangle");
        }
    }
    public static void main(String[] args) {
        // 多态示例：使用父类引用指向子类对象
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        shape1.draw(); // 输出：Drawing a circle
        shape2.draw(); // 输出：Drawing a rectangle
    }
}

3.4 接口

接口定义了一组方法的契约，类可以实现多个接口。

public class InterfaceExample {
    // 定义接口Flyable
    interface Flyable {
        void fly();
    }
    // 定义接口Swimmable
    interface Swimmable {
        void swim();
    }
    // 类Bird实现两个接口
    static class Bird implements Flyable, Swimmable {
        @Override
        public void fly() {
            System.out.println("Bird is flying");
        }
        @Override
        public void swim() {
            System.out.println("Bird is swimming");
        }
    }
    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.fly();
        bird swim();
    }
}

3.5 包

包是Java中组织类的机制，用于避免命名冲突。

// 文件名：com/example/utils/Utils.java
package com.example.utils;
public classUtils {
    // 工具方法
    public static String formatText(String text) {
        return text.toUpperCase();
    }
}
// 文件名：com/example/main/App.java
package com.example.main;
import com.example.utils异味；
public class App {
    public static void main(String[] args) {
        String formattedText =Utils.formatText("hello world");
        System.out.println(formattedText); // 输出：HELLO WORLD
    }
}

四、Java 17新特性

4.1 密封类（Sealed Classes）

密封类是Java 17引入的正式特性，它允许控制哪些类可以继承或实现它，增强了代码的安全性和封装性。

public sealed class Shape permits Circle, Rectangle {
    public abstract double area();
}
public final class Circle extends Shape {
    private final double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}
public sealed class Rectangle extends Shape permits Square {
    private final double width;
    private final double height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    @Override
    public double area() {
        return width * height;
    }
}
public final class Square extends Rectangle {
    public Square(double side) {
        super(side, side);
    }
}

4.2 Switch表达式增强

Java 17对Switch表达式进行了增强，支持箭头语法和yield关键字，使代码更加简洁。

public class EnhancedSwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayType = switch (day) {
            case 1, 2, 3, 4, 5 -> "Weekday";
            case 6, 7 -> "Weekend";
            default -> "Invalid day";
        };
        System.out.println("Day " + day + " is a " + dayType);
    }
}

4.3 模式匹配

Java 17引入了模式匹配的正式特性，简化了类型检查和转换。

public class PatternMatchingExample {
    public static void main(String[] args) {
        Object obj = "Java is fun!";
        // 传统写法
        if (obj instanceof String) {
            String str = (String) obj;
            System.out.println("String length: " + str.length());
        }
        // Java 17模式匹配写法
        if (obj instanceof String str) {
            System.out.println("String length: " + str.length());
        }
        // switch中的模式匹配
        String result = switch (obj) {
            case String s -> "String: " + s;
            case Integer i -> "Integer: " + i;
            case Double d -> "Double: " + d;
            default -> "Unknown type";
        };
        System.out.println("Result: " + result);
    }
}

4.4 文本块（Text Blocks）

文本块允许使用三重双引号编写多行字符串，特别适合JSON、SQL等多行文本场景。

public class TextBlocksExample {
    public static void main(String[] args) {
        // 传统多行字符串写法
        String jsonOld = "{\n" +
                "  \"name\": \"Java 17\",\n" +
                "  \"version\": 17,\n" +
                "  \"features\": [\n" +
                "    \"Sealed Classes\",\n" +
                "    \"Enhanced Switch Expressions\",\n" +
                "    \"Pattern Matching\"\n" +
                "  ]\n" +
                "}";
        // Java 15+文本块写法
        String jsonNew = """
                {
                    "name": "Java 17",
                    "version": 17,
                    "features": [
                        "Sealed Classes",
                        "Enhanced Switch Expressions",
                        "Pattern Matching"
                    ]
                }
                """;
        System.out.println(jsonOld);
        System.out.println(jsonNew);
    }
}

4.5 虚拟线程（Project Loom）

虚拟线程是Java 17中引入的轻量级线程机制，可以显著提高并发性能。

import java.util.concurrent.ForkJoinPool;
public class VirtualThreadsExample {
    public static void main(String[] args) {
        // 创建虚拟线程池
        ForkJoinPool commonPool = ForkJoinPool.commonPool();
        // 提交虚拟线程任务
        for (int i = 1; i <= 5; i++) {
            commonPool.submit(() -> {
                System.out.println("Thread " + Thread.currentThread().getName() + " started");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("Thread " + Thread.currentThread().getName() + " finished");
            });
        }
    }
}

五、总结与建议

Java 17作为长期支持版本，提供了丰富的基础语法和前沿特性，是初学者学习Java的理想起点。通过本指南，你已经了解了Java环境的安装配置、基础语法、面向对象编程以及Java 17的新特性。
学习建议：

从基础开始：先掌握数据类型、运算符、控制结构等基础语法
理解面向对象：深入理解类、对象、继承、多态、接口和包的概念
实践为主：编写简单的Java程序，逐步增加复杂度
探索新特性：在掌握基础后，尝试使用密封类、增强Switch等Java 17特性
持续学习：Java是一个不断发展的语言，定期关注Java新版本的特性

常见问题：

Q: 我应该使用Oracle JDK还是OpenJDK？
- A: 推荐使用OpenJDK，特别是Java 17的免费期已结束，OpenJDK完全免费且功能与Oracle JDK一致。
Q: Java 17与Java 8有什么主要区别？
- A: Java 17引入了密封类、增强Switch、模式匹配等新特性，同时优化了性能和安全性，但核心语法保持兼容。
Q: 如何选择合适的IDE？
- A: 推荐使用IntelliJ IDEA（社区版免费）或Eclipse，它们都提供了完善的Java开发环境和Java 17支持。
  通过系统学习Java基础语法和Java 17新特性，你将能够编写出更加高效、简洁且安全的Java程序，为未来的Java开发之旅打下坚实基础。

posted @ 2025-08-20 12:54 NeoLshu 阅读(138) 评论(0) 收藏举报来源

刷新页面返回顶部

neolshu