Java主流技术实战入门指南

概述

本文详细介绍了Java主流技术实战的相关内容，包括环境搭建、基础语法、面向对象编程、常见框架入门、异常处理以及项目实战。通过这些内容的学习，读者可以全面掌握Java开发的基本技能和实战经验。文中涵盖了从安装JDK到配置环境变量，再到使用Spring Boot搭建Web项目等实用技巧。

Java环境搭建与配置

安装Java开发工具包（JDK）

安装Java开发工具包（JDK）是开始使用Java进行开发的第一步。JDK包含了Java编译器、Java运行时环境（JRE）、Java文档工具和Java调试工具等。以下是安装JDK的步骤：

1. 访问Oracle官方网站或国内其他可信的JDK下载站点下载JDK安装包。
2. 执行下载的JDK安装程序，按照安装向导进行操作。

示例安装步骤如下：

1. 访问Oracle官方网站（https://www.oracle.com/java/technologies/javase-jdk11-downloads.html）下载JDK 11版本。
2. 双击下载的安装包，按照提示完成安装过程。

配置环境变量

为了方便使用Java命令，需要配置环境变量。以下是配置环境变量的步骤：

1. 查找JDK的安装路径。例如，安装路径为 C:\Program Files\Java\jdk-11.0.1。
2. 配置系统环境变量。打开控制面板，选择“系统和安全” -> “系统” -> “高级系统设置” -> “环境变量”。

3. 在“系统变量”区域，点击“新建”添加以下变量：

   • 变量名：JAVA_HOME
   • 变量值：C:\Program Files\Java\jdk-11.0.1（请根据实际路径修改）
4. 编辑 Path 变量，添加新的路径：%JAVA_HOME%\bin。

示例代码：

# 查找JDK安装路径
java -version

# 配置环境变量
set JAVA_HOME=C:\Program Files\Java\jdk-11.0.1
set PATH=%JAVA_HOME%\bin;%PATH%

测试安装是否成功

安装完成后，可以通过运行以下命令来测试JDK是否安装成功：

java -version

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

java version "11.0.1" 2018-12-04 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.1+13-LTS)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.1+13-LTS, mixed mode)

Java基础语法学习

数据类型与变量

Java中的数据类型分为基本数据类型和引用数据类型。基本数据类型包括整型、浮点型、字符型和布尔型。以下是一些常见的基本数据类型的示例代码：

public class DataTypesExample {
    public static void main(String[] args) {
        // 整型
        byte byteVar = 127;
        short shortVar = 32767;
        int intVar = 2147483647;
        long longVar = 9223372036854775807L;

        // 浮点型
        float floatVar = 3.14f;
        double doubleVar = 2.718281828459045;

        // 字符型
        char charVar = 'A';

        // 布尔型
        boolean booleanVar = true;

        System.out.println("byteVar: " + byteVar);
        System.out.println("shortVar: " + shortVar);
        System.out.println("intVar: " + intVar);
        System.out.println("longVar: " + longVar);
        System.out.println("floatVar: " + floatVar);
        System.out.println("doubleVar: " + doubleVar);
        System.out.println("charVar: " + charVar);
        System.out.println("booleanVar: " + booleanVar);
    }
}

控制结构（if语句、switch语句）

控制结构用于控制程序的执行流程。以下是if语句和switch语句的示例代码：

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

        // if 语句
        if (num > 0) {
            System.out.println("num is greater than 0");
        } else if (num == 0) {
            System.out.println("num is equal to 0");
        } else {
            System.out.println("num is less than 0");
        }

        // switch 语句
        String color = "blue";
        switch (color) {
            case "red":
                System.out.println("Color is red");
                break;
            case "green":
                System.out.println("Color is green");
                break;
            case "blue":
                System.out.println("Color is blue");
                break;
            default:
                System.out.println("Unknown color");
        }
    }
}

循环结构（for、while、do-while）

循环结构用于重复执行一段代码。以下是for、while、do-while循环的示例代码：

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

        // while 循环
        int j = 0;
        while (j < 5) {
            System.out.println("while loop: " + j);
            j++;
        }

        // do-while 循环
        int k = 0;
        do {
            System.out.println("do-while loop: " + k);
            k++;
        } while (k < 5);
    }
}

数组和字符串操作

数组是一组相同类型的变量的集合，而字符串是Java中预定义的对象类型。以下是数组和字符串操作的示例代码：

public class ArrayStringExample {
    public static void main(String[] args) {
        // 数组
        int[] numbers = new int[5];
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;

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

        // 字符串
        String message = "Hello, World!";
        System.out.println("Original: " + message);
        System.out.println("Length: " + message.length());
        System.out.println("Substring: " + message.substring(0, 5));
        System.out.println("ToUpperCase: " + message.toUpperCase());
        System.out.println("ToLowerCase: " + message.toLowerCase());
        System.out.println("Split: " + Arrays.toString(message.split(", ")));
    }
}

Java面向对象编程

类与对象

在Java中，类是对象的蓝图，而对象是类的实例。以下是一个简单的类和对象的示例代码：

public class Car {
    // 成员变量
    private String brand;
    private int year;

    // 构造函数
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    // 成员方法
    public String getBrand() {
        return brand;
    }

    public int getYear() {
        return year;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public void display() {
        System.out.println("Brand: " + brand + ", Year: " + year);
    }
}

public class CarExample {
    public static void main(String[] args) {
        Car myCar = new Car("Toyota", 2020);
        myCar.display();

        myCar.setBrand("Honda");
        myCar.setYear(2019);
        myCar.display();
    }
}

封装性

封装性是指将对象的数据和方法封装起来，使对象内部的数据对外界不可见。以下是一个封装性的示例代码：

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 int getAge() {
        return age;
    }

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

    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        } else {
            System.out.println("Invalid age.");
        }
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class PersonExample {
    public static void main(String[] args) {
        Person person = new Person("John", 30);
        person.display();

        person.setAge(35);
        person.display();
    }
}

继承性

继承性允许一个类继承另一个类的属性和方法。以下是一个继承性的示例代码：

public class Animal {
    protected String name;
    protected int age;

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

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class Dog extends Animal {
    private String breed;

    public Dog(String name, int age, String breed) {
        super(name, age);
        this.breed = breed;
    }

    public void display() {
        super.display();
        System.out.println("Breed: " + breed);
    }
}

public class DogExample {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy", 5, "Labrador");
        myDog.display();
    }
}

多态性

多态性允许子类重写父类的方法，可以在运行时调用不同的实现。以下是一个多态性的示例代码：

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

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

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

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

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

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

常见Java框架入门

Servlet与JSP简介

Servlet是运行在服务器端的Java代码，可以生成动态网页。JSP是JavaServer Pages，允许在网页中嵌入Java代码。以下是Servlet和JSP的简单示例代码：

Servlet示例代码

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloWorldServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>Hello World from Servlet!</h1>");
    }
}

JSP示例代码

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Hello World from JSP</title>
</head>
<body>
    <h1>Hello World from JSP!</h1>
</body>
</html>

Spring框架基础

Spring是一个轻量级的Java开发框架，支持IoC（控制反转）和AOP（面向切面编程）。以下是Spring框架的基础示例代码：

Spring IoC容器示例代码

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringExample {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        HelloWorld helloWorld = (HelloWorld) context.getBean("helloWorld");
        helloWorld.getMessage();
    }
}

class HelloWorld {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("Message: " + message);
    }
}

// beans.xml
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="helloWorld" class="com.example.HelloWorld">
        <property name="message" value="Hello World from Spring!" />
    </bean>
</beans>

MyBatis框架基础

MyBatis是一个持久层框架，可以简化数据库操作。以下是MyBatis框架的基础示例代码：

MyBatis示例代码

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.Reader;
import java.util.List;

public class MyBatisExample {
    public static void main(String[] args) {
        try {
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
            SqlSession session = sqlSessionFactory.openSession();

            List<User> users = session.selectList("selectAllUsers");
            for (User user : users) {
                System.out.println("User: " + user.getName());
            }

            session.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class User {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

// mybatis-config.xml
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

// UserMapper.xml
<mapper namespace="com.example.UserMapper">
    <select id="selectAllUsers" resultType="com.example.User">
        SELECT * FROM users
    </select>
</mapper>

Java异常处理

异常的概念与作用

异常是指程序在执行过程中遇到的问题，可能导致程序中断。Java中使用异常处理机制来捕获和处理这些异常。

异常的分类与处理

Java中的异常分为两种类型：检查异常和非检查异常。检查异常需要在方法声明中声明，非检查异常不需要声明。

捕获异常示例代码

import java.io.IOException;

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

抛出异常示例代码

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

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            throw new CustomException("Custom exception occurred");
        } catch (CustomException e) {
            System.out.println("Caught custom exception: " + e.getMessage());
        }
    }
}

自定义异常类

自定义异常类可以扩展Exception或其子类。以下是一个自定义异常类的示例代码：

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

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

Java项目实战

简单的Web应用开发

开发一个简单的Web应用，使用Servlet和JSP。以下是简单的Web应用开发步骤：

Web应用目录结构

WebApp
│
├── index.jsp
├── WEB-INF
│   ├── web.xml
│   └── lib
│       └── servlet-api.jar
└── HelloWorldServlet.java

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Simple Web Application</title>
</head>
<body>
    <h1>Welcome to the Simple Web Application</h1>
    <a href="HelloWorldServlet">Click here to see the servlet output</a>
</body>
</html>

HelloWorldServlet.java

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloWorldServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>Hello World from Servlet!</h1>");
    }
}

web.xml

<web-app>
    <servlet>
        <servlet-name>HelloWorldServlet</servlet-name>
        <servlet-class>com.example.HelloWorldServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloWorldServlet</servlet-name>
        <url-pattern>/HelloWorldServlet</url-pattern>
    </servlet-mapping>
</web-app>

使用Spring Boot搭建一个小型Web项目

Spring Boot简化了Spring应用的开发过程，提供了自动配置功能。以下是使用Spring Boot搭建一个小型Web项目的步骤：

创建Spring Boot项目

1. 使用Spring Initializr创建一个新的Spring Boot项目。
2. 选择依赖项：Web、Thymeleaf（可选）。

控制器示例代码

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {
    @GetMapping("/")
    public String hello(Model model) {
        model.addAttribute("message", "Hello World from Spring Boot!");
        return "index";
    }
}

Thymeleaf模板示例代码

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Spring Boot Example</title>
</head>
<body>
    <h1 th:text="${message}"></h1>
</body>
</html>

主类示例代码

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

部署Spring Boot应用

部署Spring Boot应用，可以使用Spring Boot的内置Tomcat服务器，也可以部署到外部服务器如Apache Tomcat。

使用内置Tomcat服务器

直接运行Application主类，Spring Boot会启动内置的Tomcat服务器。

部署到外部Tomcat服务器

1. 将应用打包成WAR文件。
2. 将WAR文件部署到外部Tomcat服务器。

mvn clean package
mv target/my-app-1.0-SNAPSHOT.war tomcat/webapps/my-app.war

调试Spring Boot应用

调试Spring Boot应用，可以使用IDE自带的调试工具，如IntelliJ IDEA或Eclipse的调试功能。

以上是Java主流技术入门指南，涵盖了环境搭建、基础语法、面向对象编程、常见框架入门、异常处理以及项目实战。通过这些内容的学习，可以掌握Java开发的基本技能和实战经验。