首页手记 Java主流技术入门教程

Java主流技术入门教程

标签：

Java

概述

本文全面介绍了Java语言的基础知识和开发环境搭建，涵盖了Java主流技术的各个方面，包括基本语法、面向对象编程、常用框架入门、Web开发基础、调试与异常处理等内容，帮助读者快速掌握Java开发技能。

Java简介与环境搭建

Java语言简介

Java是一种广泛使用的面向对象编程语言，由Sun Microsystems（已被Oracle收购）开发。Java的设计目的是编写一次、到处运行（Write Once, Run Anywhere），因此它可以在多种平台上运行，包括Windows、Linux、macOS等。Java广泛应用于Web应用开发、Android开发、桌面应用程序以及企业级应用开发等。

Java的主要特点包括：

平台无关性：Java字节码可以在任何实现了Java虚拟机（JVM）的平台上运行。
面向对象：支持面向对象的编程思想，包括封装、继承和多态。
自动垃圾回收：自动管理内存，减少内存泄漏的风险。
丰富的类库：提供了广泛的类库，支持各种功能，如网络编程、图形界面开发等。
安全性：提供了一套安全机制，确保代码的执行安全。

Java开发环境搭建

安装Java开发环境

下载Java SDK：首先，从Oracle官方网站下载Java开发套件（JDK）。选择适合自己操作系统的JDK版本。
安装JDK：运行下载的安装程序，按照向导提示完成JDK的安装。安装过程中，确保记住安装路径。
环境变量配置：
- Windows：设置环境变量JAVA_HOME指向JDK的安装路径，设置PATH环境变量包含%JAVA_HOME%\bin。
- Linux/Mac：更新~/.bashrc或~/.zshrc文件，包含以下内容：
```
export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH
```
  然后运行source ~/.bashrc或source ~/.zshrc使更改生效。
验证安装：打开命令行工具，输入java -version检查Java是否正确安装。

安装IDE

Eclipse：Eclipse是一个流行的开源集成开发环境（IDE），支持多种编程语言，包括Java。
1. 访问Eclipse官方网站下载安装包。
2. 根据提示完成Eclipse的安装。
3. 打开Eclipse，安装必要的插件，如Java开发工具（JDT）。
IntelliJ IDEA：IntelliJ IDEA是一款强大的Java集成开发环境，分为免费的社区版和付费的专业版。
1. 访问IntelliJ IDEA官方网站下载安装包。
2. 安装完成后，启动IDEA并配置Java环境。
NetBeans：NetBeans是一个多功能的开发环境，支持Java，还有其他语言。
1. 访问NetBeans官方网站下载安装包。
2. 按照向导完成安装并配置Java环境。

第一个Java程序示例

下面是一个简单的Java程序，用于打印“Hello, World!”。

打开Eclipse或IntelliJ IDEA，创建一个新的Java项目。
在项目中创建一个新的Java类，命名为HelloWorld。
在HelloWorld类中编写以下代码：

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

运行程序。在Eclipse中，右键点击HelloWorld类，选择Run As -> Java Application。在IntelliJ IDEA中，点击运行按钮或者使用快捷键Shift + F10。

运行结果：

Hello, World!

Java基本语法

数据类型与变量

Java是一种强类型语言，所有变量在使用前都必须声明其类型。

基本数据类型

Java的基本数据类型包括整型、浮点型、字符型和布尔型。

整型
- byte：8位，取值范围-128到127。
- short：16位，取值范围-32768到32767。
- int：32位，取值范围-2147483648到2147483647。
- long：64位，取值范围-9223372036854775808到9223372036854775807。
浮点型
- float：32位，单精度。
- double：64位，双精度。
字符型
- char：16位，表示一个Unicode字符。
布尔型
- boolean：表示true或false。

变量声明

变量声明语句的基本格式为：

数据类型 变量名 = 初始值;

示例：

int age = 25;
double salary = 3000.5;
char grade = 'A';
boolean isStudent = true;

数据类型转换

Java支持数据类型之间的转换，包括隐式转换和显式转换。

隐式转换：系统自动进行的类型转换，通常是从小范围类型向大范围类型转换，不需要额外操作。
示例：
```
int num1 = 100;
long num2 = num1; // 隐式转换，int -> long
```

显式转换：需要使用类型转换符进行转换。
示例：

double num1 = 100.5;
int num2 = (int) num1; // 显式转换，double -> int

流程控制语句

Java中的流程控制语句包括选择语句和循环语句。

选择语句

选择语句用于根据条件执行不同的代码块。

if语句

if (条件) {
   // 代码块
}

示例：

int x = 10;
if (x > 5) {
   System.out.println("x 大于 5");
}

if-else语句

if (条件) {
   // 代码块
} else {
   // 代码块
}

示例：

int x = 3;
if (x > 5) {
   System.out.println("x 大于 5");
} else {
   System.out.println("x 小于或等于 5");
}

if-else if-else语句

if (条件1) {
   // 代码块
} else if (条件2) {
   // 代码块
} else {
   // 代码块
}

示例：

int x = 2;
if (x > 5) {
   System.out.println("x 大于 5");
} else if (x == 5) {
   System.out.println("x 等于 5");
} else {
   System.out.println("x 小于 5");
}

循环语句

循环语句用于重复执行某些代码块，直到满足特定条件为止。

for循环

for (初始化; 条件; 更新) {
   // 代码块
}

示例：

for (int i = 1; i <= 5; i++) {
   System.out.println("i 的值是：" + i);
}

while循环

while (条件) {
   // 代码块
}

示例：

int i = 1;
while (i <= 5) {
   System.out.println("i 的值是：" + i);
   i++;
}

do-while循环

do {
   // 代码块
} while (条件);

示例：

int j = 1;
do {
   System.out.println("j 的值是：" + j);
   j++;
} while (j <= 5);

数组与字符串操作

数组操作

数组是一种基本数据结构，可以存储一组相同类型的变量。

声明和初始化数组

数据类型[] 数组名 = new 数据类型[数组长度];
// 或者
数据类型[] 数组名 = {元素1, 元素2, ...};

示例：

int[] numbers = new int[5];
int[] numbers = {1, 2, 3, 4, 5};

访问数组元素

数组名[索引];

示例：

int[] numbers = {1, 2, 3, 4, 5};
System.out.println(numbers[0]); // 输出 1

遍历数组

for (int i = 0; i < 数组长度; i++) {
   // 代码块
}

示例：

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
   System.out.println(numbers[i]);
}

字符串操作

字符串是Java中最常用的引用数据类型之一，通过String类表示。

创建字符串

String str = "Hello, World!";
String str = new String("Hello, World!");

字符串操作

// 获取长度
int length = str.length();

// 拼接字符串
String str1 = "Hello";
String str2 = " World";
String result = str1 + str2;

// 获取子串
String sub = str.substring(0, 5);

// 替换子串
String newStr = str.replace("World", "Java");

// 转换大小写
String upper = str.toUpperCase();
String lower = str.toLowerCase();

示例：

String str = "Hello, World!";
System.out.println(str.length()); // 输出 13
String result = str.substring(0, 5) + str.substring(7);
System.out.println(result); // 输出 Hello,Java!

方法定义与调用

方法是Java中用于执行特定任务的代码块，可以包含参数，并返回结果。

定义方法

访问修饰符 返回类型 方法名(参数列表) {
    // 代码块
    return 返回值;
}

示例：

public int sum(int a, int b) {
    return a + b;
}

调用方法

返回类型 变量名 = 方法名(参数值);

示例：

int result = sum(3, 4);
System.out.println(result); // 输出 7

类与对象

Java是一种面向对象的编程语言，通过类和对象实现面向对象的核心特性。

类的定义

访问修饰符 class 类名 {
    // 成员变量
    // 成员方法
}

示例：

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

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

    // 成员方法
    public void displayInfo() {
        System.out.println("品牌：" + brand + ", 年份：" + year);
    }
}

创建对象

类名 对象名 = new 类名(参数列表);

示例：

Car myCar = new Car("Toyota", 2020);

访问成员变量和调用成员方法

对象名.成员变量名;
对象名.成员方法名();

示例：

myCar.displayInfo(); // 输出 品牌：Toyota, 年份：2020

面向对象编程

类与对象的概念

类与对象的关系

类：定义了对象的结构和行为，是面向对象的核心概念。
对象：是类的实例化，通过new关键字创建。

示例：

public class Rectangle {
    int width;
    int height;

    public void displayArea() {
        System.out.println("面积：" + (width * height));
    }
}

public class Test {
    public static void main(String[] args) {
        Rectangle rect = new Rectangle();
        rect.width = 10;
        rect.height = 20;
        rect.displayArea(); // 输出 面积：200
    }
}

继承与多态

继承

继承是一个类可以继承另一个类的属性和方法。

class BaseClass {
    // 成员变量和方法
}

class DerivedClass extends BaseClass {
    // 成员变量和方法
}

示例：

public class Animal {
    void eat() {
        System.out.println("动物吃东西");
    }
}

public class Dog extends Animal {
    void bark() {
        System.out.println("狗叫");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 输出 动物吃东西
        dog.bark(); // 输出 狗叫
    }
}

多态

多态允许子类对象被当作父类对象来使用。

示例：

public class Test {
    public static void animalEat(Animal animal) {
        animal.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        animalEat(dog); // 输出 动物吃东西
    }
}

抽象类与接口

抽象类

抽象类是一种不能实例化的类，主要用于继承。

abstract class AbstractClass {
    abstract void abstractMethod();
    void concreteMethod() {
        System.out.println("具体方法");
    }
}

示例：

public abstract class Animal {
    public abstract void eat();
    public void sleep() {
        System.out.println("睡觉");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃东西");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 输出 狗吃东西
        dog.sleep(); // 输出 睡觉
    }
}

接口

接口是一种定义行为的抽象类型，允许一个类实现多个接口。

interface InterfaceName {
    void method1();
    void method2();
}

示例：

public interface Moveable {
    void move();
}

public class Car implements Moveable {
    @Override
    public void move() {
        System.out.println("车移动");
    }
}

public class Test {
    public static void main(String[] args) {
        Car car = new Car();
        car.move(); // 输出 车移动
    }
}

包的概念及使用

包是Java中用于组织类和接口的一种机制，可以将相关的类和接口组织在一起。

定义包

package 包名;

使用包

import 包名.类名;

示例：

// 文件位置：src/com/example/package/Example.java
package com.example.package;

public class Example {
    public void display() {
        System.out.println("这是一个包中的类");
    }
}

// 文件位置：src/com/example/Test.java
import com.example.package.Example;

public class Test {
    public static void main(String[] args) {
        Example example = new Example();
        example.display(); // 输出 这是一个包中的类
    }
}

实际项目案例

项目案例1：一个简单的图书管理系统

定义图书类

public class Book {
   private String title;
   private String author;
   private int year;

   public Book(String title, String author, int year) {
       this.title = title;
       this.author = author;
       this.year = year;
   }

   public void displayInfo() {
       System.out.println("书名：" + title + ", 作者：" + author + ", 年份：" + year);
   }
}

定义图书管理类

public class BookManager {
   private List<Book> books = new ArrayList<>();

   public void addBook(Book book) {
       books.add(book);
   }

   public void displayAllBooks() {
       for (Book book : books) {
           book.displayInfo();
       }
   }
}

主类

public class Main {
   public static void main(String[] args) {
       BookManager manager = new BookManager();

       Book book1 = new Book("Java编程思想", "Bruce Eckel", 2014);
       Book book2 = new Book("Effective Java", "Joshua Bloch", 2011);

       manager.addBook(book1);
       manager.addBook(book2);

       manager.displayAllBooks();
   }
}

Java常用框架入门

Spring框架简介

Spring是一个开源的轻量级Java开发框架，旨在简化企业应用开发。Spring框架的核心是Spring容器，它负责管理对象的创建、配置和依赖注入。

使用Spring的基本步骤

定义配置文件：配置文件通常使用XML格式，定义组件的bean及其依赖关系。
使用注解：通过注解简化配置，如@Component、@Autowired等。
自动装配：Spring容器会自动装配依赖关系。

示例：

// 使用注解定义组件
@Component
public class Example {
    @Autowired
    private AnotherComponent anotherComponent;
}

// 配置文件
<bean id="example" class="com.example.Example">
    <property name="anotherComponent" ref="anotherComponent"/>
</bean>

Hibernate框架简介

Hibernate是一个开源的对象关系映射（ORM）工具，用于简化Java应用中的持久化操作。它遵循JPA（Java Persistence API）规范。

主要特点

对象关系映射：将Java对象映射到数据库表。
查询语言：支持HQL（Hibernate查询语言），便于查询操作。
缓存机制：提高数据访问性能。

使用Hibernate的基本步骤

定义实体类：实体类表示数据库中的表。
映射实体类：通过注解或XML文件将实体类映射到数据库表。
配置Hibernate：在配置文件中设置数据库连接信息。
创建会话：通过SessionFactory创建Session对象。
CRUD操作：执行增删改查操作。

示例：

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
}

// 配置文件
<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>
    </session-factory>
</hibernate-configuration>

MyBatis框架简介

MyBatis是一个持久层框架，基于SQL映射，简化了数据库操作。

主要特点

SQL映射：将SQL语句映射到Java代码。
动态SQL：支持动态生成SQL语句。
缓存：支持一级缓存和二级缓存，提高性能。

使用MyBatis的基本步骤

定义配置文件：配置数据库连接信息。
定义映射文件：定义SQL语句及其参数和结果映射。
编写Java代码：通过MyBatis API执行SQL语句。

示例：

// 映射文件
<sqlMap namespace="User">
    <select id="getUser" parameterType="int" resultType="User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</sqlMap>

// Java代码
SqlSessionFactory factory = SqlSessionFactoryBuilder.build(configuration);
SqlSession session = factory.openSession();
User user = session.selectOne("User.getUser", 1);

实际项目案例

项目案例2：一个简单的用户管理系统

用户实体类

@Entity
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String name;
   private String email;

   // Getter 和 Setter 方法
}

用户管理类

public class UserManager {
   private SessionFactory sessionFactory;

   public UserManager(SessionFactory sessionFactory) {
       this.sessionFactory = sessionFactory;
   }

   public void addUser(User user) {
       Session session = sessionFactory.openSession();
       session.beginTransaction();
       session.save(user);
       session.getTransaction().commit();
       session.close();
   }

   public User getUserById(Long id) {
       Session session = sessionFactory.openSession();
       User user = session.get(User.class, id);
       session.close();
       return user;
   }
}

主类

public class Main {
   public static void main(String[] args) {
       Configuration configuration = new Configuration();
       configuration.configure("hibernate.cfg.xml"); // 配置文件路径
       SessionFactory sessionFactory = configuration.buildSessionFactory();

       UserManager userManager = new UserManager(sessionFactory);

       User user = new User();
       user.setName("张三");
       user.setEmail("zhangsan@example.com");

       userManager.addUser(user);

       User retrievedUser = userManager.getUserById(1L);
       System.out.println(retrievedUser.getName() + " " + retrievedUser.getEmail());
   }
}

Java Web开发基础

Servlet与JSP简介

Servlet

Servlet是运行在服务器端的小程序，处理客户端请求并生成响应。Servlet容器负责管理和调度Servlet的运行。

JSP

JSP（Java Server Pages）是一种动态网页技术标准，允许在HTML中嵌入Java代码，生成动态内容。

Servlet与JSP的关系

Servlet：主要用于处理请求和响应。
JSP：主要用于生成动态内容，可以包含服务器端的Java代码。

示例：

@WebServlet("/hello")
public class HelloWorldServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.println("<html>");
        out.println("<body>");
        out.println("<h1>Hello, World!</h1>");
        out.println("</body>");
        out.println("</html>");
    }
}

MVC设计模式

MVC（Model-View-Controller）是一种常见的软件架构模式，用于分离关注点，提高代码的可维护性。

Model：负责数据处理和业务逻辑。
View：负责显示数据。
Controller：负责处理输入，调用Model和View。

示例：

// Model
public class User {
    private String name;
    private int age;
    // Getter 和 Setter 方法
}

// Controller
@WebServlet("/user")
public class UserController extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        User user = new User();
        user.setName("John");
        user.setAge(30);
        request.setAttribute("user", user);
        RequestDispatcher dispatcher = request.getRequestDispatcher("/WEB-INF/views/user.jsp");
        dispatcher.forward(request, response);
    }
}

// View (user.jsp)
<html>
<body>
<h1>用户信息</h1>
<p>姓名: ${user.name}</p>
<p>年龄: ${user.age}</p>
</body>
</html>

Tomcat服务器配置与使用

Tomcat简介

Tomcat是一个开源的Servlet容器，支持Java Servlet和JSP技术。

配置Tomcat

下载Tomcat：访问Tomcat官方网站下载对应版本的Tomcat。
解压安装：将下载的压缩包解压到指定目录。
配置服务器端口：编辑conf/server.xml文件，修改<Connector>标签的端口号。
部署应用：将应用部署到Tomcat的webapps目录下。

示例：

<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" />
  </Engine>
</Server>

运行Tomcat

打开命令行工具，导航到Tomcat的bin目录，运行启动脚本。

Windows：
```
start.bat
```
Linux/Mac：
```
./startup.sh
```

访问http://localhost:8080验证Tomcat是否启动成功。

实际项目案例

项目案例3：一个简单的博客系统

博客实体类

@Entity
public class Blog {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String title;
   private String content;

   // Getter 和 Setter 方法
}

博客管理类

public class BlogManager {
   private SessionFactory sessionFactory;

   public BlogManager(SessionFactory sessionFactory) {
       this.sessionFactory = sessionFactory;
   }

   public void addBlog(Blog blog) {
       Session session = sessionFactory.openSession();
       session.beginTransaction();
       session.save(blog);
       session.getTransaction().commit();
       session.close();
   }

   public Blog getBlogById(Long id) {
       Session session = sessionFactory.openSession();
       Blog blog = session.get(Blog.class, id);
       session.close();
       return blog;
   }
}

博客Servlet

@WebServlet("/blog")
public class BlogServlet extends HttpServlet {
   @Override
   protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       Configuration configuration = new Configuration();
       configuration.configure("hibernate.cfg.xml");
       SessionFactory sessionFactory = configuration.buildSessionFactory();
       BlogManager blogManager = new BlogManager(sessionFactory);

       Blog blog = blogManager.getBlogById(1L);

       request.setAttribute("blog", blog);
       RequestDispatcher dispatcher = request.getRequestDispatcher("/WEB-INF/views/blog.jsp");
       dispatcher.forward(request, response);
   }
}

博客JSP页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<h1>博客信息</h1>
<p>标题: ${blog.title}</p>
<p>内容: ${blog.content}</p>
</body>
</html>

Java调试与异常处理

常见错误类型与调试方法

Java中的错误和异常分为以下几类：

运行时错误：不受程序控制的错误，例如内存溢出。
编译时错误：源代码不符合Java语言规范。
运行时异常：程序运行时抛出的异常，通常由编程错误引起。

调试方法

断点调试：设置断点，逐行执行程序。
日志输出：通过打印日志信息追踪程序状态。
单元测试：编写单元测试用例验证代码正确性。

示例：

public class Test {
    public static void main(String[] args) {
        int a = 0;
        int b = 10;
        try {
            int result = b / a; // 除零错误
        } catch (ArithmeticException ex) {
            System.out.println("除零错误");
        }
    }
}

异常处理机制

Java提供了强大的异常处理机制，通过try-catch块捕获异常，通过finally块执行清理工作，通过throw抛出异常。

try-catch块

try {
    // 可能抛出异常的代码
} catch (ExceptionType ex) {
    // 处理异常的代码
}

示例：

public class Test {
    public static void main(String[] args) {
        try {
            int a = 0;
            int b = 10;
            int result = b / a;
        } catch (ArithmeticException ex) {
            System.out.println("除零错误");
        }
    }
}

finally块

try {
    // 可能抛出异常的代码
} finally {
    // 无论是否捕获到异常都会执行的代码
}

示例：

public class Test {
    public static void main(String[] args) {
        try {
            int a = 0;
            int b = 10;
            int result = b / a;
        } catch (ArithmeticException ex) {
            System.out.println("除零错误");
        } finally {
            System.out.println("finally块执行");
        }
    }
}

日志记录与管理

日志记录是程序调试和维护的重要手段，Java提供了多种日志框架，如Log4j、SLF4J等。

SLF4J

SLF4J（Simple Logging Facade for Java）是一个简单的日志门面，支持多种日志实现。

日志配置

添加依赖：在项目的pom.xml或build.gradle中添加日志实现库依赖。
配置日志文件：通过配置文件控制日志输出格式和级别。

示例：

<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>

# 日志配置文件
log4j.rootLogger=DEBUG, stdout, file
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.File=example.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

日志示例

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Test {
    private static final Logger logger = LoggerFactory.getLogger(Test.class);

    public static void main(String[] args) {
        logger.debug("这是一个调试日志");
        logger.info("这是一个信息日志");
        logger.warn("这是一个警告日志");
        logger.error("这是一个错误日志");
    }
}

通过日志记录可以方便地追踪程序运行状态，提高调试效率和程序的可维护性。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

动漫人物

手记
篇

粉丝

18

获赞与收藏

71

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19367 315

Java 并发原理入门教程

26个小节 39106 568

Java 入门教程

50个小节 342514 3164

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Java主流技术入门教程

Java语言简介

Java开发环境搭建

安装Java开发环境

安装IDE

第一个Java程序示例

数据类型与变量

基本数据类型

变量声明

数据类型转换

流程控制语句

选择语句

循环语句

数组与字符串操作

数组操作

字符串操作

方法定义与调用

定义方法

调用方法

类与对象

类的定义

创建对象

访问成员变量和调用成员方法

类与对象的概念

类与对象的关系

继承与多态

继承

多态

抽象类与接口

抽象类

接口

包的概念及使用

定义包

使用包

实际项目案例

项目案例1：一个简单的图书管理系统

Spring框架简介

相关概念

使用Spring的基本步骤

Hibernate框架简介

主要特点

使用Hibernate的基本步骤

MyBatis框架简介

主要特点

使用MyBatis的基本步骤

实际项目案例

项目案例2：一个简单的用户管理系统

Servlet与JSP简介

Servlet

JSP

Servlet与JSP的关系

MVC设计模式

Tomcat服务器配置与使用

Tomcat简介

配置Tomcat

运行Tomcat

实际项目案例

项目案例3：一个简单的博客系统

常见错误类型与调试方法

调试方法

异常处理机制

try-catch块

finally块

日志记录与管理

SLF4J

日志配置

日志示例

阅读免费教程