1
2
3
4
5

文档注释：
/** 
*文档注释
*与多行差不多
*/

1
2
3

int a = 3;
double b = 5.0;
a = (int)b;

1
2
3
4
5
6

//if else语句
if(){
	语句1;
}else{
	语句2;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

//switch语句
switch(表达式) {
    case 值1:
        语句块1;
        break;
    case 值2:
        语句块2;
        break;
    …
    case 值n:
        语句块n;
        break;
    default:
        语句块n+1;
    break;
}

1
2
3
4

//while语句
while(条件表达式) {
    语句块;
}

1
2
3
4

//do while语句
do {
    语句块;
}while(条件表达式);

1
2
3
4

//for循环语句
for(赋值语句;条件语句;迭代语句) {
    语句块;
}

1
2
3
4

//foreach 循环语句，用于遍历
for(类型 变量名:集合) {
    语句块;
}

1
2

//return;
return 变量;    //方法结束，并返回与方法类型相同变量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

//break;
break;          //跳出循环  
break label（标识代码块的标签）;
public static void main(String[] args) {
        label: for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.println(j);
                if (j % 2 != 0) {
                    break label;
                }
            }
        }
    }
/*break label;可以终止执行一个或者几个任意代码块，这些代码块不必是一个循环或一个 switch 语句的一部分。同时这种扩展的 break 语句带有标签，可以明确指定从何处重新开始执行。*/

1
2
3

//continue;
continue;       //跳出本次循环
//同样支持label

1
2
3

`+

用concat()方法 字符串1.concat(字符串2);

1

字符串名.length();

1
2
3

字符串名.toLowerCase()：全字母转化成小写

字符串名.toUpperCase()：全字母转化成大写

1

字符串名.trim()

1
2
3

substring(int beginIndex)：从索引（beginIndex）处开始至结尾

substring(int beginIndex，int endIndex)：从beginIndex到endIndex

1
2
3
4
5
6
7

str.split(String sign)
str.split(String sign,int limit)
/*
str 为需要分割的目标字符串;
sign 为指定的分割符，可以是任意字符串。
limit 表示分割后生成的字符串的限制个数，如果不指定，则表示不限制，直到将整个目标字符串完全分割为止。
*/

1

字符串.replace(String oldChar, String newChar)

1

字符串.replaceFirst(String regex, String replacement)

1

字符串.replaceAll(String regex, String replacement)

1
2
3
4
5
6
7

str1.equals(str2);
//注意，equals() 方法比较字符串对象中的字符。而==运算符比较两个对象引用看它们是否引用相同的实例。
例：
String s1 = "Hello";
String s2 = new String(s1);
System.out.println(s1.equals(s2)); // 输出true
System.out.println(s1 == s2); // 输出false

1

str1.equalsIgnoreCase(str2);

1

str.compareTo(String otherstr);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

str.indexOf(value)
str.indexOf(value,int fromIndex)
/*
str 表示指定字符串；
value 表示待查找的字符（串）；
fromIndex 表示查找时的起始索引，如果不指定 fromIndex，则默认从指定字符串中的开始位置（即 fromIndex 默认为 0）开始查找。
*/
例：
String s = "Hello Java";
int size = s.indexOf('v');    // size的结果为8

1
2
3

str.indexOf(value)
str.indexOf(value,int fromIndex)
//同上

1

字符串名.charAt(索引值)

1
2

上面在讲字符串String转化int时提到了Integer.parse(str)
其实这里就是用了这个int包装类。我们讲int装箱成Integer就是为了使用这个类的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

定义：
type[] arrayName;    // 数据类型[] 数组名;
type arrayName[];    // 数据类型 数组名[];
例：int[] score

分配空间
arrayName = new type[size]  // 数组名 = new 数据类型[数组长度];
例：score = new int[10];

初始化
type[] arrayName = new type[]{值 1,值 2,值 3,值 4,• • •,值 n};
或
number[0] = 1;
number[1] = 2;
number[2] = 3;
number[3] = 5;
number[4] = 8;

1
2
3
4

初始化
type[][] arrayName = new type[][]{值 1,值 2,值 3,…,值 n};    // 在定义时初始化
type[][] arrayName = new type[size1][size2];    // 给定空间，在赋值
type[][] arrayName = new type[size][];    // 数组第二维长度为空，可变化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

/*
public：修饰后变为共用，可以被其他类和程序访问。相似的还有protect、无和private，后续会详细区分区别
abstract：修饰后变为抽象类，抽象类无法实例化，后续会详细讲解
final：如果类被 final 修饰，则不允许被继承。
class：声明类的关键字
class_name：类的名称
extends：表示继承其他类，就是作为其他类的子类
implements：表示实现某些接口，后续会详细讲解
*/
[public][abstract|final]class<class_name>[extends<class_name>][implements<interface_name>] {
    // 定义属性部分
    [public|protected|private][static][final]<type><variable_name>
/*
    public：同上
    static：修饰后表示静态变量，可以不通过实例化对象调用
	final：表示将该成员变量声明为常量，其值无法更改。
    type：变量类型，int、byte、......
    variable_name：变量名称
*/
    …
    // 定义方法部分
     [public|private|protected][static]<void|return_type><method_name>([paramList]) {
        // 方法体
    }
/*
	public：同上
	static：同上
	void|return_type：方法类型
	method_name：方法名字
	paramList：所需参数列表
*/
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Teacher {
    private String name;    // 教师名称
    private double salary;    // 工资
    private int age;    // 年龄
}
public Teacher(String name,double salary,int age) {
    this.name = name;    // 设置教师名称
    this.salary = salary;    // 设置教师工资
    this.age = age;    // 设置教师年龄
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Dog {
    // 定义一个jump()方法
    public void jump() {
        System.out.println("正在执行jump方法");
    }
    // 定义一个run()方法，run()方法需要借助jump()方法
    public void run() {
        this.jump();
        System.out.println("正在执行 run 方法");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//只能在构造方法中使用，且只能在第一个语句执行
public class Student {
    String name;
    // 无参构造方法（没有参数的构造方法）
    public Student() {
        this("张三"); //调用有参构造方法
    }
    // 有参构造方法
    public Student(String name) {
        this.name = name;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

//new
类名 对象名 = new 类名()；
    
//反射（**后续详解**）
//调用 java.lang.Class 或者 java.lang.reflect.Constuctor 类的 newlnstance() 实例方法
 java.lang.Class Class 类对象名称 = java.lang.Class.forName(要实例化的类全称);
类名 对象名 = (类名)Class类对象名称.newInstance();

//clone()不常用
//使用该方法创建对象时，要实例化的类必须继承 java.lang.Cloneable 接口。
类名对象名 = (类名)已创建好的类对象名.clone();

//调用 java.io.ObjectlnputStream 对象的 readObject() 方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class Person {
    public String name; // 姓名
    public int age; // 年龄
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void tell() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
    
    public static void main(String[] args) {
        new Person("张三", 30).tell(); // 匿名对象
    }
}

1
2
3
4

Student stu = null;
stu.Name = "李子文";
stu.Sex = true;
stu.Age = 15;

1
2
3
4
5

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

1
2
3

Test() {
        m = 0;
    }

1
2
3

    Test(int m) {
        this.m = m;
    }

1

package 包名;

1
2

example.Test test = new example.Test();
//创建example包里的Test类的对象

1
2
3
4
5

import 包名+类名;
import example.Test;//导入某包某类
import example.*;   //导入某包所有类

//写了这个语句后，之前

1
2
3
4
5

 修饰符 class class_name extends extend_class {
    // 类的主体
}

//表明该类继承extend_class类

1

super(parameter-list);

1
2

super.member
super.member()

1
2
3

fatherClass obj = new sonClass();
//Animal cat = new cat();
//Cat cat = new cat();

1
2
3

sonClass obj = (sonClass) fatherClass;
//需要强制类型转化
//Dog dog = (Dog) animal；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

[public] interface interface_name [extends interface1_name[, interface2_name,…]] {
    [public] [static] [final] type constant_name = value; 
    [public] [abstract] returnType method_name(parameter_list);   
}
/*
public：表示接口的修饰符，当没有修饰符时，则使用默认的修饰符，此时该接口的访问权限仅局限于所属的包；

interface_name：表示接口的名称。

extends：表示接口的继承关系；

interface1_name：表示要继承的接口名称；

constant_name：表示变量名称，一般是 static 和 final 型的；

returnType：表示方法的返回值类型；

parameter_list：表示参数列表，在接口中的方法是没有方法体的。
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

<public> class <class_name> [extends superclass_name] [implements interface1_name[, interface2_name…]] {
    // 主体
}
/*
public：类的修饰符；

superclass_name：需要继承的父类名称；

interface1_name：要实现的接口名称。可以实现多个接口
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

class jdbcTest1{
    public static void main(String[] args) throws Exception {
        //注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //获取数据库链接
        Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useSSL=false","liernian","123456");
        //获取执行者对象
        Statement stat = con.createStatement();
        //执行sql语句并返回结果
        String sql = "select * from users";
        ResultSet res = stat.executeQuery(sql);
        //处理结果
        while(res.next()){
            System.out.println(res.getString("username")+"\t"+res.getString("email"));
        }
        //释放资源
        con.close();
    }
}

/*输出如下
*test1   test1@runoob.com
*test2   test2@runoob.com
*test3   test3@runoob.com
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

package com.web.servlet;

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebServlet;

import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/miracle")
public class IndexServlet implements Servlet {    //接入Servlet接口
    @Override  //重写Servlet的init()，该方法在启动容器的时候自动调用，方法体为空，并抛出异常至ServletException
    public void init(ServletConfig servletConfig) throws ServletException {  }
    @Override //重写Servlet的getServletConfig()，方法体为返回空
    public ServletConfig getServletConfig(){return null;}
    @Override //重写Servlet的 service()，该方法用于处理用户请求，参数为servlet的请求和返回，方法体逻辑为获取get请求的username参数，若参数值为liuhuaqing，返回可以访问，反之，则返回无法访问。并抛出异常至ServletException()
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        String userName = servletRequest.getParameter("userName"); 
        servletResponse.setContentType("text/html;charset=utf-8"); //避免返回时出现乱码
        PrintWriter writer = servletResponse.getWriter();//导入write对象，用于调用PrintWriter的println方法。
        if ("liuhuaqing".equals(userName)){
            writer.println("可以访问");
        } else {
            writer.println("无法访问");
        }
                    writer.close();
    }
    @Override //重写getServletInfo()，方法体返回空
    public String getServletInfo(){ return null; }
    @Override //重写destroy()，无方法体
    public void destroy(){   }
}

1
2
3
4

1.在Web资源被访问前，检查request对象，修改请求头和请求正文，或对请求执行预处理操作。
2.将请求传递到下一个过滤器或目标资源。
3.在Web资源被访问后，检查response对象，修改响应头和响应正文。
（并不是必须将请求传递到下一个过滤器或目标资源，也可也自行处理，并发送响应给客户端，也可以请求转发或重定向到其他Web资源）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package com.web.servlet; // 替换成你自己的包名

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

/**
 * 注意：我们现在继承HttpServlet，这是一个更方便的抽象类。
 */
@WebServlet("/miracle")
public class IndexServlet extends HttpServlet {

    /**
     * 处理GET和POST请求的通用方法。
     * 因为Filter已经完成了权限检查，所以这里的代码可以假设用户是合法的。
     * Servlet的职责变得更加单一：只为合法用户提供服务。
     */
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 注意：这里的response编码已经在Filter中设置过了，但为了代码健壮性，再设置一次也无妨。
        // response.setContentType("text/html;charset=UTF-8");

        PrintWriter writer = response.getWriter();
        writer.println("<h1>欢迎, " + request.getParameter("userName") + "!</h1>");
        writer.println("<p>你已成功通过Filter的验证，可以访问此核心资源。</p>");
        writer.close();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

package com.web.servlet; // 替换成你自己的包名

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebFilter;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * 一个用于身份验证的过滤器
 *
 * @WebFilter注解用于声明这是一个Filter。
 * "urlPatterns"属性指定了这个过滤器要拦截的URL模式。
 * "/miracle"意味着任何访问"/miracle"这个路径的请求都会先被这个Filter拦截。
 */
@WebFilter(urlPatterns = "/miracle")
public class AuthFilter implements Filter { //接入Filter接口

    @Override  //重写init
    public void init(FilterConfig filterConfig) throws ServletException {
        // Filter初始化时调用，通常用于加载一些资源。这里我们暂时不需要。
        System.out.println("AuthFilter 初始化...");
    }

    /**
     * 核心方法：每次请求匹配的URL时，都会执行此方法。
     *
     * @param request  请求对象
     * @param response 响应对象
     * @param chain    过滤器链，这是最重要的部分！
     */
    @Override //重写doFilter
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("AuthFilter 开始工作...");

        // 1. 在请求到达Servlet前进行处理
        // 统一设置编码 (这是一个非常好的实践)
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=UTF-8");

        // 2. 执行安全检查
        String userName = request.getParameter("userName");

        if ("liuhuaqing".equals(userName)) {
            // 用户名正确，放行！
            // 调用chain.doFilter()将请求传递给下一个过滤器或目标Servlet，Filter链可在web.xml中配置
            System.out.println("用户名正确，放行！");
            chain.doFilter(request, response);
        } else {
            // 用户名错误，拦截！
            // 直接向客户端返回错误信息，不调用chain.doFilter()
            System.out.println("用户名错误，拦截！");
            PrintWriter writer = response.getWriter();
            writer.println("<h1>非法访问，禁止入内！</h1>");
            writer.println("<p>你的用户名不正确，无法访问受保护的资源。</p>");
            writer.close();
        }

        // 3. 在Servlet处理完请求，响应返回客户端前，也可以进行处理（这里我们没做）
        System.out.println("AuthFilter 工作结束。");
    }

    @Override
    public void destroy() {
        // Filter销毁时调用。
        System.out.println("AuthFilter 销毁...");
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

<%--
  Created by IntelliJ IDEA.
  User: 28105
  Date: 2025/7/16
  Time: 14:44
  To change this template use File | Settings | File Templates.
--%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.util.*,java.text.SimpleDateFormat" %>
<!DOCTYPE html>
<html>
<head>
  <title>JSP语法大全示例</title>
</head>
<body>
<!-- 1. JSP注释（不会输出到页面） -->
<%-- 这是JSP注释，不会被浏览器看到 --%>

<!-- 2. HTML注释（会输出到页面源码） -->
<!-- 这是HTML注释，浏览器可以看到 -->

<!-- 3. JSP脚本元素 -->
<%-- 声明变量 --%>
<%
  String name = "JSP学习者";
  int age = 20;
  List<String> fruits = Arrays.asList("苹果", "香蕉", "橙子");
  request.setAttribute("city", "北京");
  session.setAttribute("user", "Tom");
  application.setAttribute("appName", "JSP示例应用");
%>

<%-- 4. JSP表达式（输出内容到页面） --%>
<h2>欢迎，<%= name %>！</h2>
<p>你的年龄是：<%= age %></p>

<%-- 5. JSP声明（定义方法或变量） --%>
<%!
  public String getCurrentTime() {
    return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
  }
%>
<p>当前时间：<%= getCurrentTime() %></p>

<%-- 6. JSP指令（已在顶部使用） --%>
<%-- page、include、taglib --%>

<%-- 7. JSP动作元素 --%>
<jsp:useBean id="person" class="java.util.HashMap" scope="page" />
<%
  ((Map)pageContext.getAttribute("person")).put("gender", "男");
%>


<%-- 8. include指令和动作 --%>
<%-- 静态包含 --%>
<%-- <%@ include file="header.jsp" %> --%>
<%-- 动态包含 --%>
<%-- <jsp:include page="footer.jsp" /> --%>

<%-- 9. JSP内置对象 --%>
<p>request city: <%= request.getAttribute("city") %></p>
<p>session user: <%= session.getAttribute("user") %></p>
<p>application appName: <%= application.getAttribute("appName") %></p>
<p>contextPath: <%= request.getContextPath() %></p>
<p>服务器IP: <%= request.getLocalAddr() %></p>

<%-- 10. JSP条件语句和循环 --%>
<h3>喜欢的水果：</h3>
<ul>
  <% for(String fruit : fruits) { %>
  <li><%= fruit %></li>
  <% } %>
</ul>

<%-- 11. JSP异常处理 --%>
<%
  try {
    int result = 10 / 2;
    out.println("10 / 2 = " + result);
  } catch(Exception e) {
    out.println("发生异常：" + e.getMessage());
  }
%>

<%-- 13. EL表达式 --%>
<h3>EL表达式演示：</h3>
<p>城市：${city}</p>
<p>用户：${sessionScope.user}</p>
<p>应用名：${applicationScope.appName}</p>
<p>年龄：${age}</p>
<p>喜欢的水果第一个：${fruits[0]}</p>

<%-- 14. 表单与请求参数 --%>
<form method="post">
  请输入你的爱好：<input type="text" name="hobby" />
  <input type="submit" value="提交" />
</form>
<%
  String hobby = request.getParameter("hobby");
  if(hobby != null && !hobby.isEmpty()) {
%>
<p>你的爱好是：<%= hobby %></p>
<% } %>

<%-- 15. 跳转与重定向 --%>
<%--
<%
    // response.sendRedirect("https://www.baidu.com");
    // pageContext.forward("other.jsp");
%>
--%>

<%-- 16. JSP页面指令 errorPage 和 isErrorPage --%>
<%--
<%@ page errorPage="error.jsp" %>
--%>

<hr>
<p style="color:gray;">本页面演示了JSP的常用语法，建议结合源码和运行结果一起学习。</p>
</body>
</html>