Java零基础入门：轻松掌握Java编程-原创手记-慕课网

概述

本文详细介绍了Java零基础入门所需的知识，包括环境搭建、基础语法、面向对象编程、常用类与接口、异常处理及文件操作等。通过学习，读者可以快速掌握Java编程的基本技能，从搭建开发环境到编写简单的Java程序，每一步都有详细指导。希望这篇指南能帮助初学者顺利入门Java编程。

Java简介与环境搭建

Java简介

Java是一种广泛使用的面向对象编程语言，由Sun Microsystems公司（现为Oracle公司）在1995年推出。Java的主要特点包括：

跨平台性：Java程序可以在任何支持Java的平台上运行，这主要得益于Java虚拟机（JVM）的存在。
面向对象：Java支持数据封装、继承和多态等面向对象编程的基本特性。
易于学习和使用：Java语言简洁、清晰，易于学习和使用。
安全性：Java为应用程序提供高级的安全特性，包括安全沙盒、代码签名等。
丰富的库支持：Java提供了大量的标准库，可以满足各种编程需求。
多线程支持：Java支持多线程编程，使得程序可以同时执行多个任务。
广泛的应用领域：Java可以应用于Web开发、桌面应用、移动应用、大数据处理、云计算等多个领域。

Java开发环境搭建

为了编写和运行Java程序，首先需要搭建一个Java开发环境。以下是搭建环境的步骤：

安装JDK：Java Development Kit（JDK）是Java开发工具包，包含Java编译器、Java运行时环境、Javadoc文档生成工具等。首先访问Oracle官方网站下载JDK安装包。
环境变量配置：安装完成后，需要将JDK的安装路径添加到系统环境变量中，以便在命令行中使用Java命令。

Windows环境变量配置

打开“控制面板” -> “系统和安全” -> “系统” -> “高级系统设置”。
点击“环境变量”按钮。
在“系统变量”中新建变量JAVA_HOME，值为JDK的安装路径，如C:\Program Files\Java\jdk-17。
在“系统变量”中找到Path变量，编辑其值，在末尾添加;%JAVA_HOME%\bin。

Linux环境变量配置

打开终端，编辑系统环境变量文件，如~/.bashrc或~/.profile。

添加以下环境变量配置：

export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH

保存文件，运行以下命令使配置生效：
```
source ~/.bashrc
```
验证安装：打开命令行窗口，输入以下命令验证JDK是否安装成功：
```
java -version
```
如果成功输出Java版本信息，说明安装成功。

第一个Java程序

编写第一个Java程序，可以按照以下步骤操作：

创建一个文本文件，命名为HelloWorld.java。

编写程序代码：

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

编译Java程序：
```
javac HelloWorld.java
```
运行程序：
```
java HelloWorld
```
输出：
```
Hello, World!
```

Java基础语法

变量与数据类型

在Java中，变量用于存储数据。不同的数据类型决定了变量可以存储的数据类型和大小。

Java的数据类型分为两种：基本数据类型和引用数据类型。

基本数据类型

基本数据类型有8种：byte、short、int、long、float、double、char和boolean。

数据类型	描述	大小（位）	范围
byte	有符号字节整数	8	-128 到 127
short	有符号短整数	16	-32,768 到 32,767
int	有符号整数	32	-2,147,483,648 到 2,147,483,647
long	有符号长整数	64	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
float	单精度浮点数	32	约等于 1.4E-45 到 3.4E+38
double	双精度浮点数	64	约等于 4.9E-324 到 1.8E+308
char	16位Unicode字符	16	一个字符
boolean	布尔值	1	true 或 false

示例代码

public class DataTypesExample {
    public static void main(String[] args) {
        byte b = 127;
        short s = 32767;
        int i = 1000;
        long l = 1234567890123456789L;
        float f = 3.14f;
        double d = 3.14159;
        char c = 'A';
        boolean bool = true;

        System.out.println("byte: " + b);
        System.out.println("short: " + s);
        System.out.println("int: " + i);
        System.out.println("long: " + l);
        System.out.println("float: " + f);
        System.out.println("double: " + d);
        System.out.println("char: " + c);
        System.out.println("boolean: " + bool);
    }
}

运算符与表达式

Java支持多种运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和条件运算符。

算术运算符

运算符	功能	示例	结果
+	加法	a + b	10
-	减法	a - b	2
*	乘法	a * b	20
/	除法	a / b	2
%	取余	a % b	0

示例代码

public class ArithmeticOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        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	false
!=	不等于	a != b	true
>	大于	a > b	true
<	小于	a < b	false
>=	大于等于	a >= b	true
<=	小于等于	a <= b	false

示例代码

public class RelationalOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        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));
    }
}

逻辑运算符

运算符	功能	示例	结果
&&	逻辑与	a && b	true
\|\|	逻辑或	a	b	true
!	逻辑非	!a	false

示例代码

public class LogicalOperators {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a && b: " + (a && b));
        System.out.println("a || b: " + (a || b));
        System.out.println("!a: " + (!a));
    }
}

流程控制语句

Java中的流程控制语句主要包括条件语句（if、switch）、循环语句（for、while、do-while）和跳转语句（break、continue、return）。

if语句

结构	功能	示例	结果
if (条件)	单分支	if (a > b) { ... }	根据条件执行
if (条件) {} else {}	双分支	if (a > b) {} else {}	根据条件执行不同分支
if (条件1) {} else if (条件2) {} else {}	多分支	if (a > b) {} else if (a == b) {} else {}	根据多个条件执行不同分支

示例代码

public class IfStatement {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        if (a > b) {
            System.out.println("a > b");
        } else if (a == b) {
            System.out.println("a == b");
        } else {
            System.out.println("a < b");
        }
    }
}

switch语句

结构	功能	示例	结果
switch (变量) { case 值1: ... break; case 值2: ... break; ... default: ... }	多分支	switch (a) { case 0: ... break; case 1: ... break; default: ... }	根据变量值执行不同分支

示例代码

public class SwitchStatement {
    public static void main(String[] args) {
        int a = 1;

        switch (a) {
            case 0:
                System.out.println("a is 0");
                break;
            case 1:
                System.out.println("a is 1");
                break;
            default:
                System.out.println("a is neither 0 nor 1");
        }
    }
}

for循环

结构	功能	示例	结果
for (初始化; 条件; 更新) { ... }	遍历循环	for (int i = 0; i < 5; i++) { ... }	按条件执行循环

示例代码

public class ForLoop {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i: " + i);
        }
    }
}

while循环

结构	功能	示例	结果
while (条件) { ... }	按条件执行循环	while (a > 0) { ... }	按条件执行循环

示例代码

public class WhileLoop {
    public static void main(String[] args) {
        int a = 5;

        while (a > 0) {
            System.out.println("a: " + a);
            a--;
        }
    }
}

do-while循环

结构	功能	示例	结果
do { ... } while (条件);	至少执行一次循环	do { ... } while (a > 0);	至少执行一次循环

示例代码

public class DoWhileLoop {
    public static void main(String[] args) {
        int a = 5;

        do {
            System.out.println("a: " + a);
            a--;
        } while (a > 0);
    }
}

break语句

结构	功能	示例	结果
break;	跳出循环或switch	break;	结束当前循环或switch

示例代码

public class BreakStatement {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            if (i == 3) {
                break;
            }
            System.out.println("i: " + i);
        }
    }
}

continue语句

结构	功能	示例	结果
continue;	跳过当前循环迭代	continue;	跳过当前循环迭代

示例代码

public class ContinueStatement {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            if (i == 2) {
                continue;
            }
            System.out.println("i: " + i);
        }
    }
}

return语句

结构	功能	示例	结果
return;	返回方法	return;	结束方法，返回控制流

示例代码

public class ReturnStatement {
    public static int sum(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = sum(10, 5);
        System.out.println("sum: " + result);
    }
}

Java面向对象编程

类与对象

面向对象是Java的核心特性之一。在Java中，所有事物都是对象，每个对象都是某个类的实例。类是对象的蓝图，定义了对象的属性（数据成员）和行为（方法）。

定义类

类由关键字class定义，包含成员变量和成员方法。例如：

public class Person {
    // 成员变量
    private String name;
    private int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 成员方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

创建对象

创建对象的语法是：

Person person = new Person("张三", 20);

访问成员变量

System.out.println(person.getName()); // 输出 "张三"
System.out.println(person.getAge());  // 输出 20

方法与构造函数

方法

方法用于实现类的行为。在类中定义方法，使用public、private等修饰符来限定访问权限。

public void sayHello() {
    System.out.println("Hello, " + name);
}

构造函数

构造函数用于创建新的对象实例。构造函数与类名相同，并且没有返回类型。

public Person(String name, int age) {
    this.name = name;
    this.age = age;
}

示例代码

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, " + name);
    }

    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 20);
        person.sayHello();
        System.out.println(person.toString());
    }
}

继承与多态

继承

继承允许一个类继承另一个类的属性和方法。可以通过关键字extends实现继承。

public class Student extends Person {
    private String school;

    public Student(String name, int age, String school) {
        super(name, age);
        this.school = school;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", school=" + school + "]";
    }
}

多态

多态允许子类覆盖父类的方法，通过对象的多态性，可以使用父类类型的变量引用子类对象。

public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 20);
        Student student = new Student("李四", 22, "清华大学");

        person.sayHello(); // 输出 "Hello, 张三"
        student.sayHello(); // 输出 "Hello, 李四"
    }
}

示例代码

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void sayHello() {
        System.out.println("Hello, " + name);
    }

    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

public class Student extends Person {
    private String school;

    public Student(String name, int age, String school) {
        super(name, age);
        this.school = school;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", school=" + school + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 20);
        Student student = new Student("李四", 22, "清华大学");

        person.sayHello(); // 输出 "Hello, 张三"
        student.sayHello(); // 输出 "Hello, 李四"
    }
}

Java常用类与接口

String类与StringBuffer类

String类

String类是不可变的，一旦创建，就不能修改。常用方法包括length()、charAt()、substring()、equals()、split()。

示例代码

public class StringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";

        System.out.println("Length: " + str.length());
        System.out.println("Char at 0: " + str.charAt(0));
        System.out.println("Substring: " + str.substring(7, 12));
        System.out.println("Equals: " + str.equals("Hello, World!"));
        String[] split = str.split(", ");
        System.out.println("Split: " + Arrays.toString(split));
    }
}

StringBuffer类

StringBuffer类是可变的，可以修改其内容。常用方法包括append()、insert()、delete()、toString()。

示例代码

public class StringBufferExample {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("Hello, World!");

        sb.append(" Java");
        sb.insert(6, " C++");
        sb.delete(12, 17);

        System.out.println("StringBuffer: " + sb.toString());
    }
}

数组

数组定义

数组是一种固定大小的数据结构，用于存储相同类型的多个元素。定义数组的方法如下：

int[] array = new int[5];
array[0] = 1;
array[1] = 2;
// ...

示例代码

public class ArrayExample {
    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;

        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Number " + i + ": " + numbers[i]);
        }
    }
}

集合框架

Java集合框架提供了大量的接口和实现类，用于存储和操作集合对象。常用的接口包括List、Set、Map。

List接口

List接口表示一个有序集合，允许元素重复。常用的实现类包括ArrayList、LinkedList。

示例代码

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        for (String item : list) {
            System.out.println("Item: " + item);
        }
    }
}

Set接口

Set接口表示一个不包含重复元素的集合。常用的实现类包括HashSet、TreeSet。

示例代码

import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("A");
        set.add("B");
        set.add("C");
        set.add("A");

        for (String item : set) {
            System.out.println("Item: " + item);
        }
    }
}

Map接口

Map接口表示一个键值对集合，每个键对应一个值。常用的实现类包括HashMap、TreeMap。

示例代码

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("A", 1);
        map.put("B", 2);
        map.put("C", 3);

        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

异常处理

异常的概念

在Java中，异常是指程序执行过程中发生的异常情况，例如除以零、数组越界等。Java使用Throwable类作为所有异常的父类，分为Error（系统错误）、Exception（程序错误）两类。

示例代码

public class ExceptionExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

        try {
            int result = a / b;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Divide by zero error: " + e.getMessage());
        } finally {
            System.out.println("Finally block");
        }
    }
}

异常处理机制

Java使用try-catch-finally语句来处理异常。

try：包含可能抛出异常的代码。
catch：捕获并处理异常。
finally：无论是否发生异常，都会执行的代码块。

示例代码

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

        try {
            int result = a / b;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Divide by zero error: " + e.getMessage());
        } finally {
            System.out.println("Finally block");
        }
    }
}

自定义异常

自定义异常通过继承Exception或RuntimeException类实现。自定义异常通常用于特定场景，为程序提供更详细的异常信息。

示例代码

public class CustomExceptionExample extends Exception {
    public CustomExceptionExample(String message) {
        super(message);
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            throw new CustomExceptionExample("This is a custom exception");
        } catch (CustomExceptionExample e) {
            System.out.println("Caught custom exception: " + e.getMessage());
        }
    }
}

输入输出与文件操作

输入输出流

Java提供了丰富的输入输出流类，用于处理文件和数据流。常见的输入输出流包括InputStream、OutputStream、Reader、Writer等。

示例代码

import java.io.*;

public class FileIOExample {
    public static void main(String[] args) throws IOException {
        String filePath = "example.txt";

        // 写入文件
        try (FileWriter writer = new FileWriter(filePath)) {
            writer.write("Hello, World!");
        }

        // 读取文件
        try (FileReader reader = new FileReader(filePath)) {
            int ch;
            while ((ch = reader.read()) != -1) {
                System.out.print((char) ch);
            }
        }
    }
}

文件与目录操作

Java提供了java.nio.file包中的类和接口，用于处理文件和目录操作。

示例代码

import java.nio.file.*;

public class FileOperationsExample {
    public static void main(String[] args) throws IOException {
        Path filePath = Paths.get("example.txt");

        // 写入文件
        Files.write(filePath, List.of("Hello, World!"));

        // 读取文件
        List<String> lines = Files.readAllLines(filePath);
        System.out.println(lines);

        // 创建目录
        Path dirPath = Paths.get("exampleDir");
        Files.createDirectory(dirPath);

        // 列出目录内容
        List<Path> paths = Files.list(dirPath).collect(Collectors.toList());
        System.out.println(paths);

        // 删除文件
        Files.delete(filePath);
    }
}

常见文件操作示例

写入文件

import java.io.*;

public class WriteToFileExample {
    public static void main(String[] args) throws IOException {
        String filePath = "example.txt";
        try (FileWriter writer = new FileWriter(filePath)) {
            writer.write("Hello, World!");
        }
    }
}

读取文件

import java.io.*;

public class ReadFromFileExample {
    public static void main(String[] args) throws IOException {
        String filePath = "example.txt";
        try (FileReader reader = new FileReader(filePath)) {
            int ch;
            while ((ch = reader.read()) != -1) {
                System.out.print((char) ch);
            }
        }
    }
}

创建目录

import java.nio.file.*;

public class CreateDirectoryExample {
    public static void main(String[] args) throws IOException {
        Path dirPath = Paths.get("exampleDir");
        Files.createDirectory(dirPath);
    }
}

删除文件

import java.nio.file.*;

public class DeleteFileExample {
    public static void main(String[] args) throws IOException {
        Path filePath = Paths.get("example.txt");
        Files.delete(filePath);
    }
}

复制文件

import java.nio.file.*;

public class CopyFileExample {
    public static void main(String[] args) throws IOException {
        Path sourcePath = Paths.get("example.txt");
        Path targetPath = Paths.get("example_copy.txt");
        Files.copy(sourcePath, targetPath);
    }
}

示例代码

import java.io.*;
import java.nio.file.*;

public class FileOperationsExamples {
    public static void main(String[] args) throws IOException {
        String filePath = "example.txt";
        Path dirPath = Paths.get("exampleDir");
        Path sourcePath = Paths.get("example.txt");
        Path targetPath = Paths.get("example_copy.txt");

        // 写入文件
        try (FileWriter writer = new FileWriter(filePath)) {
            writer.write("Hello, World!");
        }

        // 读取文件
        try (FileReader reader = new FileReader(filePath)) {
            int ch;
            while ((ch = reader.read()) != -1) {
                System.out.print((char) ch);
            }
        }

        // 创建目录
        Files.createDirectory(dirPath);

        // 列出目录内容
        List<Path> paths = Files.list(dirPath).collect(Collectors.toList());
        System.out.println(paths);

        // 删除文件
        Files.delete(filePath);

        // 复制文件
        Files.copy(sourcePath, targetPath);
    }
}

总结，Java是一种强大的编程语言，支持面向对象编程、丰富的API和强大的异常处理机制。通过学习Java，可以开发各种类型的应用程序，从简单的控制台程序到复杂的Web应用程序。希望本文能够帮助你快速掌握Java编程的基本知识。