Java主流技术学习涵盖从基础入门到高级应用的全面内容，包括Java开发环境的搭建、面向对象编程、常用框架如Spring和MyBatis的使用，以及Web开发和数据库集成等关键技术。本文旨在帮助新手快速掌握Java开发的核心技能和最佳实践。
Java主流技术学习：新手入门全攻略Java基础入门
Java简介
Java是一种广泛使用的面向对象编程语言，具备平台无关性、安全性、高效性等特点，适用于开发桌面应用、Web应用、移动应用和企业级应用。Java语言支持自动内存管理，开发环境丰富，拥有大量的库和框架，使得开发过程更加高效。
Java开发环境主要包括Java编译器（javac）、Java虚拟机（JVM）、Java类库（JDK）和开发工具（IDE如Eclipse、IntelliJ IDEA）。
安装Java开发环境
安装Java开发环境需要以下步骤：
-
下载Java JDK
访问Oracle官方网站下载最新的Java JDK：https://www.oracle.com/java/technologies/javase-downloads.html或者选择OpenJDK，它是Java的一个开源实现，同样支持Java应用的开发：
https://openjdk.java.net/install/ -
安装Java JDK
下载后，根据操作系统进行安装。在安装过程中，确保选择安装Java Development Kit（JDK），这样可以包含编译Java程序所需的所有工具。 -
配置环境变量
安装完成后，需要配置环境变量。编辑PATH环境变量，添加Java安装目录的bin文件夹路径，例如：export PATH=$PATH:/path/to/java/jdk/bin验证安装是否成功，可以在命令行中输入以下命令：
java -version javac -version
第一个Java程序
创建第一个Java程序可以按照以下步骤进行：
-
创建Java文件
使用文本编辑器创建一个名为HelloWorld.java的文件，并输入以下代码：public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } } -
编译Java文件
打开命令行，切换到包含Java文件的目录，使用javac命令编译Java文件：javac HelloWorld.java -
运行Java程序
编译成功后，会在同一目录下生成一个名为HelloWorld.class的字节码文件。使用java命令运行程序：java HelloWorld
简单的Java程序实例
除了Hello World程序，还可以尝试以下简单程序：
public class SumCalculator {
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
int sum = num1 + num2;
System.out.println("Sum: " + sum);
}
}Java面向对象编程
类和对象
在Java中，类是对象的蓝图，定义了对象的属性和行为。对象是类的具体实例，具有类定义的属性和方法。以下是一个简单的类和对象的示例：
public class Person {
// 属性
private String name;
private int age;
// 方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void showDetails() {
System.out.println("Name: " + name + ", Age: " + age);
}
}
// 创建Person对象
public class Main {
public static void main(String[] args) {
Person person = new Person("Alice", 25);
person.showDetails();
}
}实际应用示例
例如，可以创建一个表示汽车的类：
public class Car {
private String make;
private String model;
private int year;
public Car(String make, String model, int year) {
this.make = make;
this.model = model;
this.year = year;
}
public void displayCarDetails() {
System.out.println("Make: " + make + ", Model: " + model + ", Year: " + year);
}
}
// 创建Car对象
public class Main {
public static void main(String[] args) {
Car car = new Car("Toyota", "Camry", 2020);
car.displayCarDetails();
}
}继承与多态
继承允许一个类继承另一个类的属性和方法。多态允许子类覆盖父类的方法，实现不同的行为。以下是一个继承和多态的示例：
// 父类
public class Animal {
public void makeSound() {
System.out.println("Animal makes sound");
}
}
// 子类
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Dog barks");
}
}
// 子类
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Cat meows");
}
}
// 测试类
public class Main {
public static void main(String[] args) {
Animal animal = new Animal();
animal.makeSound();
Animal dog = new Dog();
dog.makeSound();
Animal cat = new Cat();
cat.makeSound();
}
}实际应用示例
例如，可以创建一个表示不同类型的动物类：
public class Bird extends Animal {
@Override
public void makeSound() {
System.out.println("Bird chirps");
}
}
public class Main {
public static void main(String[] args) {
Animal bird = new Bird();
bird.makeSound();
}
}封装与抽象
封装允许将数据和方法绑定在一起，防止外部直接访问内部数据。抽象通过接口或抽象类定义行为，不关心具体实现。以下是一个封装和抽象的示例：
// 定义一个抽象接口
public interface Drawable {
void draw();
}
// 定义一个具体实现
public class Circle implements Drawable {
@Override
public void draw() {
System.out.println("Drawing a circle");
}
}
// 定义一个具体实现
public class Square implements Drawable {
@Override
public void draw() {
System.out.println("Drawing a square");
}
}
// 测试类
public class Main {
public static void main(String[] args) {
Drawable circle = new Circle();
circle.draw();
Drawable square = new Square();
square.draw();
}
}Java常用框架入门
Spring框架简介
Spring框架是一个广泛应用的企业级Java开发框架，提供了IoC（控制反转）和AOP（面向切面编程）等核心功能。Spring框架主要分为几个模块，如核心容器、数据访问、Web开发等。
Spring Boot快速入门
Spring Boot简化了Spring应用程序的开发，提供了自动配置和快速启动的功能。以下是一个简单的Spring Boot应用示例：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@RestController
class HelloController {
@GetMapping("/")
public String hello() {
return "Hello, World!";
}
}实际应用示例
例如，可以创建一个简单的REST API：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@RestController
class UserController {
@GetMapping("/users")
public String hello() {
return "Hello, User!";
}
}MyBatis框架基础
MyBatis是一个持久层框架，用于处理数据库操作。以下是一个简单的MyBatis示例：
-
数据库准备
假设有一个用户表users，包含id和name两个字段。 -
创建Mapper接口
public interface UserMapper { User selectUserById(int id); } -
创建Mapper XML文件
<mapper namespace="com.example.UserMapper"> <select id="selectUserById" resultType="com.example.User"> SELECT id, name FROM users WHERE id = #{id} </select> </mapper> -
配置文件
<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="com/example/UserMapper.xml" /> </mappers> </configuration> -
测试代码
import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactoryBuilder; public class Main { public static void main(String[] args) { String resource = "mybatis-config.xml"; SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource)); SqlSession session = factory.openSession(); UserMapper mapper = session.getMapper(UserMapper.class); User user = mapper.selectUserById(1); System.out.println(user.getName()); } }
Java Web开发基础
Servlet与JSP
Servlet是Java EE的一部分，用于处理HTTP请求和响应。JSP（JavaServer Pages）是一种动态网页技术，可以在网页中嵌入Java代码。
-
创建Servlet
import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; @WebServlet("/HelloServlet") public class HelloServlet extends HttpServlet { protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html"); response.getWriter().println("<h1>Hello, World!</h1>"); } } - 创建JSP页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Hello, World!</title> </head> <body> <h1>Hello, World!</h1> </body> </html>
MVC设计模式
MVC（Model-View-Controller）是一种常见的软件架构模式，用于分离应用程序的各个组件。Spring MVC是一个流行的实现方式。
-
创建Controller
import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.ResponseBody; @Controller public class HelloController { @GetMapping("/") @ResponseBody public String hello() { return "Hello, World!"; } } -
配置Spring MVC
<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 class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/views/" /> <property name="suffix" value=".jsp" /> </bean> </beans> -
创建View
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Hello, World!</title> </head> <body> <h1>Hello, World!</h1> </body> </html> -
实际应用示例
例如，可以创建一个简单的Web应用，展示一个动态页面：@Controller public class SimpleController { @GetMapping("/greeting") @ResponseBody public String greeting() { return "Hello, Spring MVC!"; } }
Tomcat服务器配置
Tomcat是Apache的开源Java Servlet容器，用于部署和运行Java Web应用。以下是Tomcat的基本配置步骤：
-
安装Tomcat
下载并解压Tomcat到指定目录。 -
配置
server.xml
编辑conf/server.xml文件，配置端口和服务：<Server port="8005" shutdown="SHUTDOWN"> <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" /> <Engine name="Catalina" defaultHost="localhost"> <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true" /> </Engine> </Server> -
部署应用
将应用放置在webapps目录下，Tomcat会自动检测并部署应用。 -
启动Tomcat
进入Tomcat目录，执行以下命令启动Tomcat：bin/startup.sh访问
http://localhost:8080查看应用是否成功启动。
数据库与Java集成
JDBC连接数据库
JDBC（Java Database Connectivity）是Java访问数据库的标准接口。以下是一个简单的JDBC示例：
-
加载驱动
import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.Statement; public class JdbcExample { public static void main(String[] args) { try { Class.forName("com.mysql.jdbc.Driver"); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } -
连接数据库
Connection conn = null; try { conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password"); } catch (SQLException e) { e.printStackTrace(); } - 执行SQL语句
Statement stmt = null; ResultSet rs = null; try { stmt = conn.createStatement(); rs = stmt.executeQuery("SELECT * FROM users"); while (rs.next()) { System.out.println(rs.getInt("id") + " " + rs.getString("name")); } } catch (SQLException e) { e.printStackTrace(); } finally { try { if (rs != null) rs.close(); if (stmt != null) stmt.close(); if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace(); } }
实际应用示例
例如，可以创建一个简单的应用程序来查询数据库：
public class DatabaseQueryExample {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
stmt = conn.createStatement();
rs = stmt.executeQuery("SELECT * FROM users");
while (rs.next()) {
System.out.println(rs.getString("name"));
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
} finally {
try {
if (rs != null) rs.close();
if (stmt != null) stmt.close();
if (conn != null) conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}ORM技术简介
ORM（Object-Relational Mapping）技术用于将对象映射到关系数据库。常见的ORM框架有Hibernate、MyBatis等。
Hibernate框架基础
Hibernate是一个流行的ORM框架。以下是一个简单的Hibernate示例：
-
创建实体类
import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private int id; private String name; // Getter and Setter methods } -
配置文件
<hibernate-configuration> <session-factory> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">password</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="hibernate.hbm2ddl.auto">update</property> <property name="hibernate.show_sql">true</property> <mapping class="com.example.User" /> </session-factory> </hibernate-configuration> -
测试代码
import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public class HibernateExample { public static void main(String[] args) { SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory(); Session session = sessionFactory.openSession(); session.beginTransaction(); User user = new User(); user.setName("Alice"); session.save(user); session.getTransaction().commit(); session.close(); } }
Java调试与异常处理
常见调试工具
Java提供了多种调试工具，如JDB（Java Debugger）和IDE内置调试器（如Eclipse、IntelliJ IDEA）。以下是一个使用IDE调试器的基本步骤：
-
设置断点
在代码中设置断点。 -
启动调试模式
使用IDE的调试模式启动应用。 - 单步执行
通过单步执行、步过和步出等方式调试代码。
实际调试示例
例如，可以在以下代码中设置断点并调试：
public class DebugExample {
public static void main(String[] args) {
int a = 10;
int b = 0;
int result = a / b;
System.out.println("Result: " + result);
}
}异常处理机制
Java通过异常处理机制处理程序中的错误。异常处理通常使用try-catch-finally结构。
-
基本用法
public class ExceptionExample { public static void main(String[] args) { try { int result = 10 / 0; } catch (ArithmeticException e) { System.out.println("ArithmeticException caught: " + e.getMessage()); } finally { System.out.println("Finally block executed."); } } } -
自定义异常
public class MyException extends Exception { public MyException(String message) { super(message); } } public class CustomExceptionExample { public static void main(String[] args) { try { throw new MyException("Custom exception occurred."); } catch (MyException e) { System.out.println("MyException caught: " + e.getMessage()); } } }
实际异常处理示例
例如，可以在以下代码中处理输入验证异常：
public class InputValidationExample {
public static void main(String[] args) {
try {
String input = "";
if (input.isEmpty()) {
throw new IllegalArgumentException("Input is empty.");
}
System.out.println("Input is valid.");
} catch (IllegalArgumentException e) {
System.out.println("IllegalArgumentException caught: " + e.getMessage());
}
}
}日志管理
日志管理是开发和维护应用的重要部分。Java提供了多种日志框架，如Log4j、SLF4J等。以下是一个使用SLF4J的基本示例：
-
引入依赖
<dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>1.7.30</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-simple</artifactId> <version>1.7.30</version> </dependency> -
使用日志
import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class LoggingExample { private static final Logger logger = LoggerFactory.getLogger(LoggingExample.class); public static void main(String[] args) { logger.debug("Debug message"); logger.info("Info message"); logger.warn("Warn message"); logger.error("Error message"); } }
以上是Java主流技术学习的全攻略。从基础入门到高级应用，Java提供了强大的功能和技术支持，使得开发过程更加高效和灵活。希望这篇文章能帮助你掌握Java开发的核心技术和最佳实践。
随时随地看视频
