JSP开发基础

1.1 变量、常量与数据类型

public class VariableExample {public static void main(String[] args) {
        // 变量声明
        int age = 25;
        double price = 19.99;
        boolean isStudent = true;
        char grade = 'A';
 
        // 常量定义
        final double PI = 3.14159;
        final String COMPANY = "Tech Corp";
 
        // 输出演示
        System.out.println("年龄：" + age);
        System.out.println("圆周率：" + PI);
        System.out.println("是否学生：" + isStudent);
    }
}

输出：年龄：25
圆周率：3.14159
是否学生：true

1.2 流程控制语句

流程控制语句是编程中用于控制程序执行顺序的语句，通过条件判断、循环和分支等方式，使程序能够根据不同的情况执行不同的逻辑，从而实现复杂的程序行为。

public class ControlFlowExample {public static void main(String[] args) {
        // if-else 条件判断
        int score = 85;
        if (score>= 90) {System.out.println("优秀");
        } else if (score>= 75) {System.out.println("良好");
        } else {System.out.println("继续努力");
        }
        // switch-case 分支结构
        int day = 3;
        switch(day) {case 1: System.out.println("星期一"); break;
            case 2: System.out.println("星期二"); break;
            case 3: System.out.println("星期三"); break;
            default: System.out.println("周末");
        }
        // for 循环累加
        int sum = 0;
        for(int i=1; i<=100; i++) {sum += i;}
        System.out.println("1-100 累加和：" + sum);
        // while 循环输入验证
        int input = 0;
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        while(input < 1 || input> 10) {System.out.print("请输入 1 -10 之间的数字：");
            input = scanner.nextInt();}
        System.out.println("您输入的是：" + input);
        // do-while 循环
        int factorial = 1, n = 5;
        int i = 1;
        do {
            factorial *= i;
            i++;
        } while(i <= n);
        System.out.println(n + "! =" + factorial);
    }
}

输出：良好
星期三
1-100 累加和：5050
请输入 1 -10 之间的数字：5
您输入的是：5
5! = 120

1.3 数组

数组是一种用于存储多个相同类型数据的容器，它通过索引访问元素，具有固定长度，可以方便地对数据进行批量操作。

public class ArrayExample {public static void main(String[] args) {
        // 一维数组声明与初始化
        int[] numbers = new int[5];          // 创建长度为 5 的整型数组
        numbers[0] = 10;                     // 给第一个元素赋值
        int[] scores = {85, 92, 78, 90};     // 声明并直接初始化数组
        
        // 数组遍历
        System.out.println("一维数组遍历：");
        for(int i=0; i<scores.length; i++){  // 使用 length 属性获取数组长度
            System.out.println("索引"+i+":"+scores[i]);
        }
        
        // 增强型 for 循环
        System.out.println("\n 增强 for 循环遍历：");
        for(int score : scores){             // 自动遍历数组元素
            System.out.print(score + " ");
        }
        
        // 二维数组操作
        int[][] matrix = {                   // 声明二维数组
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        
        System.out.println("\n\n 二维数组遍历：");
        for(int i=0; i<matrix.length; i++){   // 外层循环控制行
            for(int j=0; j<matrix[i].length; j++){ // 内层循环控制列
                System.out.print(matrix[i][j] + "\t");
            }
            System.out.println();            // 换行}
        
        // 数组排序
        java.util.Arrays.sort(scores);        // 使用 Arrays 工具类排序
        System.out.println("\n 排序后的数组：" + java.util.Arrays.toString(scores));
    }
}

输出：
一维数组遍历：
索引 0: 85
索引 1: 92
索引 2: 78
索引 3: 90

增强 for 循环遍历：
85 92 78 90

二维数组遍历：
1 2 3
4 5 6
7 8 9

排序后的数组：[78, 85, 90, 92]

1.4 面向对象程序设计

面向对象程序设计（Object-Oriented Programming，OOP）是一种以对象为核心，通过类和对象的封装、继承和多态等特性来组织代码和数据的编程范式。它强调将现实世界中的事物抽象为对象，并通过对象之间的交互来实现程序的功能。

// 父类
class Animal {
    private String name;    // 私有属性
    protected int age;      // 受保护属性
    
    // 构造方法
    public Animal(String name, int age) {
        this.name = name;  // this 指代当前对象
        this.age = age;
    }
    
    // 成员方法
    public void eat() {System.out.println(name + "正在吃东西");
    }
    
    // 静态方法
    public static void animalType() {System.out.println("这是动物类");
    }
}
// 子类继承
class Dog extends Animal {
    private String breed;   // 新增属性
    
    public Dog(String name, int age, String breed) {super(name, age);  // 调用父类构造方法
        this.breed = breed;
    }
    
    // 方法重写
    @Override
    public void eat() {System.out.println("狗狗" + super.age + "岁正在啃骨头"); // 访问父类属性
    }
    
    // 新增方法
    public void bark() {System.out.println("汪汪叫！");
    }
}
public class OOPExample {public static void main(String[] args) {
        // 创建对象
        Animal cat = new Animal("小花", 2);
        cat.eat();                   // 调用实例方法
        
        Dog myDog = new Dog("旺财", 3, "金毛");
        myDog.eat();                // 调用重写方法
        myDog.bark();               // 调用子类特有方法
        
        // 多态示例
        Animal animal = new Dog("小黑", 1, "泰迪");  // 父类引用指向子类对象
        animal.eat();                // 实际调用子类方法
        
        // 静态方法调用
        Animal.animalType();         // 通过类名调用静态方法}
}

输出：
小花正在吃东西
狗狗 3 岁正在啃骨头
汪汪叫！
狗狗 1 岁正在啃骨头
这是动物类

1.5 集合类的应用

集合类（Collection Classes）是面向对象编程中用于存储和管理对象的容器类

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
public class CollectionExample {public static void main(String[] args) {
        // ArrayList 示例
        ArrayList<String> fruits = new ArrayList<>();
        fruits.add("苹果");      // 添加元素
        fruits.add("香蕉");
        fruits.add(1, "橙子");   // 在索引 1 插入元素
        
        System.out.println("当前列表：" + fruits);
        System.out.println("第二个元素：" + fruits.get(1));
        fruits.remove("香蕉");    // 删除元素
        System.out.println("删除后：" + fruits);
        
        // HashMap 示例
        HashMap<Integer, String> weekDays = new HashMap<>();
        weekDays.put(1, "星期一");  // 添加键值对
        weekDays.put(2, "星期二");
        weekDays.put(3, "星期三");
        
        System.out.println("\n 键 2 对应的值：" + weekDays.get(2));
        weekDays.replace(3, "星期三", "周四"); // 替换值
        System.out.println("遍历 HashMap：");
        for(HashMap.Entry<Integer, String> entry : weekDays.entrySet()) {System.out.println(entry.getKey() + "->" + entry.getValue());
        }
        
        // 迭代器遍历
        System.out.println("\n 使用迭代器遍历 ArrayList：");
        Iterator<String> it = fruits.iterator();
        while(it.hasNext()) {System.out.println(it.next());
        }
    }
}

输出：
当前列表：[苹果, 橙子, 香蕉]
第二个元素：橙子
删除后：[苹果, 香蕉]

键 2 对应的值：星期二
遍历 HashMap：
1 -> 星期一
2 -> 星期二
3 -> 周四

使用迭代器遍历 ArrayList：
苹果
香蕉

1.6 异常处理语句

异常处理语句是编程中用于处理程序运行时可能出现的错误或异常情况的代码结构。它允许程序在遇到异常时，能够捕获并处理这些异常，而不是直接崩溃或终止运行，从而提高程序的健壮性和可靠性。

public class ExceptionExample {public static void main(String[] args) {
        try {int[] arr = new int[3];
            arr[5] = 10;                    // 数组越界异常
        } catch (ArrayIndexOutOfBoundsException e) {System.out.println("捕获数组越界异常：" + e.getMessage());
        }
        
        try {checkAge(15);                   // 调用可能抛出异常的方法
        } catch (Exception e) {System.out.println("捕获自定义异常：" + e.getMessage());
        } finally {System.out.println("finally 块始终执行");
        }
    }
    
    // 自定义异常方法
    static void checkAge(int age) throws Exception {if(age < 18) {throw new Exception("年龄不足 18 岁"); // 抛出检查型异常
        }
    }
}

输出：
捕获数组越界异常：Index 5 out of bounds for length 3
捕获自定义异常：年龄不足 18 岁
finally 块始终执行

2.2 在 JSP 中引入 JavaScript

<%-- 在 JSP 页面中引入 JavaScript --%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JavaScript 示例 </title>
    <%-- 内部脚本 --%>
    <script type="text/javascript">
        function showAlert() {alert("页面加载完成！");  // 弹出警告框
        }
    </script>
    <%-- 外部脚本引入 --%>
    <script src="js/external.js"></script>
</head>
<body onload="showAlert()">
    <%-- 内联脚本 --%>
    <button onclick="document.write(' 按钮被点击！')">点击我 </button>
</body>
</html>

2.3 JavaScript 数据类型与运算符

// 变量声明
var username = "Alice";        // 字符串类型
let age = 25;                  // 数字类型
const PI = 3.14;               // 常量
// 类型转换
let score = "100";             
let numScore = parseInt(score); // 字符串转数字
// 对象操作
let person = {                 // 对象字面量
    name: "Bob",
    hobbies: ["阅读", "编程"]
};
console.log(person.name);      // 访问属性
// 数组操作
let colors = ["red", "green"];
colors.push("blue");           // 添加元素
console.log(colors[1]);        // 输出 green
// 类型运算符
console.log(typeof age);       // 输出 number
console.log(score === 100);    // 严格相等判断，输出 false

2.4 JavaScript 流程控制语句

// if-else 判断
let temperature = 28;
if(temperature> 30) {console.log("天气炎热");
} else if(temperature> 20) {console.log("温度适宜");  // 执行此分支
} else {console.log("注意保暖");
}
// switch 语句
let day = new Date().getDay();
switch(day) {case 0: console.log("周日"); break;
    case 1: console.log("周一"); break;
    // ... 其他情况
    default: console.log("工作日");
}
// for 循环
for(let i=0; i<5; i++) {console.log(` 第 ${i}次循环 `); // 模板字符串
}
// while 循环
let count = 3;
while(count> 0) {console.log(count);
    count--;
}

2.5 JavaScript 应用实例

<pre class="io-enlighter-pre"><code class="gl" data-enlighter-language="javascript" data-enlighter-linenumbers="true" data-enlighter-lineoffset=""data-enlighter-highlight="">&lt;script>
// 表单验证函数
function validateForm() {let email = document.getElementById("email").value;
    if(email.indexOf("@") === -1) {        // 检查邮箱格式
        alert("请输入有效的邮箱地址");
        return false;
    }
    return true;
}
// DOM 操作示例
window.onload = function() {let btn = document.getElementById("changeColor");
    btn.onclick = function() {document.body.style.backgroundColor = "#f0f0f0";}
}
// 异步请求示例
function fetchData() {fetch('https://api.example.com/data')
        .then(response => response.json())
        .then(data => console.log(data))
        .catch(error => console.error("请求失败:", error));
}
&lt;/script></code></pre>

JSP 开发的关键在于平衡 Java 代码与 HTML 的融合，遵循 ” 展示逻辑与业务逻辑分离 ” 的原则，才能构建出可维护性高的 Web 应用程序。