JavaSE学习：新手入门与初级教程

概述

本文旨在帮助Java新手入门并掌握JavaSE的核心知识，包括开发环境搭建、基本语法、数据类型、流程控制、面向对象编程、常用类与接口以及异常处理和输入输出操作。通过本文的学习，您将能够快速掌握Java的基础知识并进行简单的项目开发。

Java语言简介

Java 是一种广泛应用于企业级应用、移动应用、大数据处理等领域的编程语言。它具有跨平台性，即一次编写，到处运行（Write Once, Run Anywhere）。Java 的设计目标包括简单性、面向对象、分布式计算支持、解释执行、安全可靠、健壮性等。Java 的应用程序可以运行在任何支持 Java 的操作系统上，包括 Windows、Linux、macOS 等。

Java开发环境搭建

安装JDK

1. 访问 Oracle 官方网站下载最新版本的 JDK（Java Development Kit）。
2. 安装 JDK，确保安装路径正确。
3. 配置环境变量：
   • 设置 JAVA_HOME 环境变量为 JDK 的安装路径。
   • 设置 PATH 环境变量包括 %JAVA_HOME%\bin。

安装并配置IDE

1. 下载并安装 IntelliJ IDEA 或 Eclipse。
2. 打开 IDE，创建新的 Java 项目。
3. 配置项目 JDK 版本，确保与安装的 JDK 版本一致。
4. 编写简单的 "Hello World" 程序。

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

安装并配置文本编辑器

1. 下载并安装任意文本编辑器，如 VS Code 或 Sublime Text。
2. 安装 Java 扩展或插件，以便语法高亮和代码补全。
3. 创建并编译简单的 Java 文件。

javac HelloWorld.java
java HelloWorld

验证安装

1. 打开命令行工具，输入 java -version 查看 Java 版本。
2. 运行简单的 Java 程序，确保安装正确。

javac HelloWorld.java
java HelloWorld

Java基本语法概述

Java程序结构

Java 程序通常由一个或多个文件组成，每个文件包含一个或多个类。每个 Java 类文件的主文件名必须与主类名相同。

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

注释

Java 支持三种注释格式：单行注释、多行注释和文档注释。

// 单行注释
/*
多行注释
*/
/**
 * 这是文档注释
 */

包（Package）与导入（Import）

包用于组织类，导入语句用于引入其他包中的类。

package com.example;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        System.out.println(input);
    }
}

注释示例

// 示例程序
public class Example {
    /**
     * 这是一个示例方法。
     * @param input 输入参数
     * @return 返回结果
     */
    public int exampleMethod(int input) {
        return input * 2;
    }
}

JavaSE数据类型与变量

数据类型详解

Java 中的数据类型分为基本数据类型和引用数据类型。

基本数据类型

• byte：1 字节，范围为 -128 到 127。
• short：2 字节，范围为 -32768 到 32767。
• int：4 字节，范围为 -2147483648 到 2147483647。
• long：8 字节，范围为 -9223372036854775808 到 9223372036854775807。
• float：4 字节，单精度浮点数。
• double：8 字节，双精度浮点数。
• char：2 字节，表示 Unicode 字符。
• boolean：1 字节，表示布尔值，取值为 true 或 false。

引用数据类型

• String：代表字符串
• 数组：一组相同类型的数据
• 类：自定义的数据类型
• 接口：定义行为规范

变量的定义与使用

变量用于存储数据，必须先声明再使用。

int age = 30;
double salary = 5000.50;
String name = "Alice";
boolean isStudent = true;

变量名必须遵循 Java 的命名规则，以字母、下划线或美元符号开头，后跟字母、数字、下划线或美元符号。变量名不区分大小写。

常量的定义与使用

常量用于存储固定值，使用 final 关键字定义。

final int MAX_VALUE = 100;
final String PI = "3.14159";

JavaSE流程控制

条件语句

Java 中的条件语句主要包括 if、else if、else 和 switch。

if 语句

int age = 20;

if (age >= 18) {
    System.out.println("成年");
} else {
    System.out.println("未成年");
}

switch 语句

int num = 2;

switch (num) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    case 3:
        System.out.println("Wednesday");
        break;
    default:
        System.out.println("Other");
        break;
}

循环结构

Java 中的循环结构包括 for、while 和 do-while。

for 循环

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

while 循环

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

do-while 循环

int j = 0;
do {
    System.out.println(j);
    j++;
} while (j < 5);

跳转语句

Java 提供了 break 和 continue 两种跳转语句。

break 语句

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    System.out.println(i);
}

continue 语句

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    System.out.println(i);
}

JavaSE面向对象编程

类与对象

类是对象的模板，包含属性和方法。对象是类的实例。

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 introduce() {
        System.out.println("My name is " + name + ", I am " + age + " years old.");
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 25);
        person.introduce();
        person.setName("Bob");
        person.setAge(30);
        person.introduce();
    }
}

继承与多态

继承允许一个类继承另一个类的属性和方法，多态允许子类重写父类的方法。

public class Animal {
    public void sound() {
        System.out.println("Animal sound");
    }
}

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog sound");
    }
}

public class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat sound");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.sound();

        Animal dog = new Dog();
        dog.sound();

        Animal cat = new Cat();
        cat.sound();
    }
}

封装与抽象类

封装是将数据和操作数据的方法封装在一起，抽象类是用于定义通用接口的类。

public abstract class Shape {
    public abstract double area();
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        System.out.println("Circle area: " + circle.area());

        Shape rectangle = new Rectangle(4, 6);
        System.out.println("Rectangle area: " + rectangle.area());
    }
}

JavaSE常用类与接口

String 类

String 类用于处理文本字符串。

public class Main {
    public static void main(String[] args) {
        String str = "Hello World!";
        System.out.println("Length: " + str.length());
        System.out.println("Substring: " + str.substring(6));
        System.out.println("Contains: " + str.contains("World"));
        System.out.println("Replace: " + str.replace("World", "Java"));
        System.out.println("ToUpperCase: " + str.toUpperCase());
    }
}

数值类型包装类

Java 为基本数据类型提供了对应的包装类，如 Integer、Double 等。

public class Main {
    public static void main(String[] args) {
        int number = 123;
        Integer num = Integer.valueOf(number);
        System.out.println(num + 1); // 输出 124

        String str = "123";
        Integer num2 = Integer.valueOf(str);
        System.out.println(num2 + 1); // 输出 124
    }
}

常用集合框架

Java 提供了丰富的集合框架，包括 List、Set 和 Map。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        // List
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        System.out.println("List: " + list);

        // Set
        Set<String> set = new HashSet<>();
        set.add("Dog");
        set.add("Cat");
        set.add("Fish");
        System.out.println("Set: " + set);

        // Map
        Map<String, String> map = new HashMap<>();
        map.put("Name", "Alice");
        map.put("Age", "25");
        System.out.println("Map: " + map);
    }
}

JavaSE异常处理与输入输出

异常类与异常处理机制

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

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException: " + e.getMessage());
        } finally {
            System.out.println("Finally block");
        }
    }
}

文件输入输出操作

Java 提供了多种方式来处理文件的输入和输出。

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        String content = "Hello, World!";
        String filePath = "output.txt";

        try {
            // 写入文件
            PrintWriter writer = new PrintWriter(new FileWriter(filePath));
            writer.println(content);
            writer.close();

            // 读取文件
            String fileContent = new String(Files.readAllBytes(Paths.get(filePath)));
            System.out.println("File content: " + fileContent);
        } catch (IOException e) {
            System.out.println("IOException: " + e.getMessage());
        }
    }
}

流对象使用示例

Java 的 I/O 操作可以使用流（Stream）对象来实现。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Main {
    public static void main(String[] args) {
        String sourceFilePath = "source.txt";
        String targetFilePath = "target.txt";

        try {
            // 读取文件
            InputStream inputStream = new FileInputStream(sourceFilePath);

            // 写入文件
            OutputStream outputStream = new FileOutputStream(targetFilePath);

            int byteRead;
            while ((byteRead = inputStream.read()) != -1) {
                outputStream.write(byteRead);
            }

            inputStream.close();
            outputStream.close();
        } catch (IOException e) {
            System.out.println("IOException: " + e.getMessage());
        }
    }
}

通过以上内容，您应该已经掌握了 JavaSE 的基础知识。进一步的学习可以参考更多在线教程，如慕课网（https://www.imooc.com/）。