首页手记 Java零基础入门：轻松掌握Java编程

Java零基础入门：轻松掌握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编程的基本知识。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

隔江千里

手记
篇

粉丝

39

获赞与收藏

182

关注作者，订阅最新文章

相关文章推荐

0基础入门Java，1元轻松搞定

0基础入门Java，1元轻松搞定

Python简要介绍--轻松掌握编程乐趣

零基础入门Java，限时1元，17号就开班！

限时一元！零基础入门java趁现在！

阅读免费教程

Java并发工具

23个小节 19133 310

Java 并发原理入门教程

26个小节 38736 565

Java 入门教程

50个小节 339376 3141

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Java零基础入门：轻松掌握Java编程

Java简介

Java开发环境搭建

Windows环境变量配置

Linux环境变量配置

第一个Java程序

变量与数据类型

基本数据类型

示例代码

运算符与表达式

算术运算符

示例代码

关系运算符

示例代码

逻辑运算符

示例代码

流程控制语句

if语句

示例代码

switch语句

示例代码

for循环

示例代码

while循环

示例代码

do-while循环

示例代码

break语句

示例代码

continue语句

示例代码

return语句

示例代码

类与对象

定义类

创建对象

访问成员变量

方法与构造函数

方法

构造函数

示例代码

继承与多态

继承

多态

示例代码

String类与StringBuffer类

String类

示例代码

StringBuffer类

示例代码

数组

数组定义

示例代码

集合框架

List接口

示例代码

Set接口

示例代码

Map接口

示例代码

异常的概念

示例代码

异常处理机制

示例代码

自定义异常

示例代码

输入输出流

示例代码

文件与目录操作

示例代码

常见文件操作示例

写入文件

读取文件

创建目录

删除文件

复制文件

示例代码

相关文章推荐