手记

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

隔江千里
2024-11-15 18:43:17浏览 138
概述

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

Java简介与环境搭建

Java简介

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

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

Java开发环境搭建

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

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

Windows环境变量配置

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

Linux环境变量配置

  1. 打开终端，编辑系统环境变量文件，如~/.bashrc或~/.profile。
  2. 添加以下环境变量配置： 
    export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH

  3. 保存文件，运行以下命令使配置生效：

    source ~/.bashrc
  4. 验证安装：打开命令行窗口，输入以下命令验证JDK是否安装成功： 
    java -version

    如果成功输出Java版本信息，说明安装成功。

第一个Java程序

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

  1. 创建一个文本文件，命名为HelloWorld.java。
  2. 编写程序代码： 
    public class HelloWorld {
   public static void main(String[] args) {
       System.out.println("Hello, World!");
   }
}
  3. 编译Java程序： 
    javac HelloWorld.java
  4. 运行程序： 
    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编程的基本知识。

相关标签
Java
0人推荐
随时随地看视频
慕课网APP