excel导入导出的相关技术

1.EasyExcel生成Excel
在解析Excel时一行行读取，逐个解析。

package com.example.jsp.pojo;

import com.alibaba.excel.annotation.ExcelProperty;

public class Student {


    //思考一个问题：这些属性与表头中的哪一些内容对应？
    //value的值是表头的名字，index是对应表头的位置
    @ExcelProperty(value = "姓名",index = 0)
    private String name;
    @ExcelProperty(value = "性别",index = 1)
    private String sex;
    @ExcelProperty(value = "年龄",index = 2)
    private int age;
    @ExcelProperty(value = "班级",index = 3)
    private String className;

    public Student() {
    }

    public Student(String name, String sex, int age, String className) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.className = className;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return sex
     */
    public String getSex() {
        return sex;
    }

    /**
     * 设置
     * @param sex
     */
    public void setSex(String sex) {
        this.sex = sex;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return className
     */
    public String getClassName() {
        return className;
    }

    /**
     * 设置
     * @param className
     */
    public void setClassName(String className) {
        this.className = className;
    }

    public String toString() {
        return "Student{name = " + name + ", sex = " + sex + ", age = " + age + ", className = " + className + "}";
    }
}

package com.example.jsp.util;

import com.alibaba.excel.EasyExcel;
import com.example.jsp.pojo.Student;
import org.apache.poi.ss.formula.functions.T;

import java.util.ArrayList;
import java.util.List;

public class ExcelUtil {
    public static void main(String[] args) {
        String excelName="d:/学生信息.xlsx";
        List<Student> students=new ArrayList<>();
        for (int i = 0; i <100 ; i++) {
            Student student=new Student();
            student.setName("张三"+(i+1));
            student.setSex(i%2==0?"男":"女");
            student.setAge(i);
            student.setClassName("你猜");
            students.add(student);
        }
        String sheetName="学生信息";
        excelWriter(excelName,Student.class,sheetName,students);
    }

    private static <T> void  excelWriter(String excelName,Class<T> clazz, String sheetName,List<T> dataList) {
        EasyExcel.write(excelName,Student.class)
                .sheet(sheetName)
                .doWrite(dataList);
    }
}

2.抽象类，以及与普通类和接口的对比
在Java中，抽象类（Abstract Class） 是一种不能被直接实例化的特殊类，它的主要作用是为子类提供统一的模板和公共实现，同时强制子类重写某些关键方法（如果子类本身不是抽象类）。抽象类通过 abstract 关键字定义，既可以包含普通方法（有方法体），也可以包含抽象方法（无方法体，需用 abstract 修饰）。

抽象类的核心特点

1. 不能实例化
   抽象类本身不完整（可能包含未实现的抽象方法），因此无法通过 new 关键字创建对象。例如：

   abstract class Animal { ... }
   Animal animal = new Animal(); // 编译报错：Cannot instantiate the type Animal
   

2. 可以包含抽象方法和普通方法

   • 抽象方法：只有方法声明（返回值、方法名、参数列表），没有方法体（用 ; 结尾），必须用 abstract 修饰。抽象方法的作用是“强制子类实现”——如果子类不是抽象类，就必须重写父类所有的抽象方法。
   • 普通方法：有完整的方法体（包含具体实现），子类可以直接继承使用，也可以选择重写。

   示例：

   abstract class Animal {
       // 抽象方法（无方法体，强制子类实现）
       public abstract void eat();
       
       // 普通方法（有方法体，子类可直接使用）
       public void sleep() {
           System.out.println("动物在睡觉");
       }
   }
   

3. 可以包含成员变量和构造方法
   抽象类和普通类一样，能定义成员变量（实例变量、静态变量），也能有构造方法（用于初始化成员变量，子类创建对象时会先调用父类构造方法）。但构造方法不能直接用于创建抽象类的对象。

   示例：

   abstract class Animal {
       protected String name; // 成员变量
       
       // 构造方法
       public Animal(String name) {
           this.name = name;
       }
       
       public abstract void eat();
   }
   

4. 子类需“处理”抽象方法
   如果一个类继承了抽象类，那么它有两种选择：

   • 重写父类所有抽象方法：此时子类可以是普通类，能正常实例化。
   • 不重写全部抽象方法：此时子类必须也声明为抽象类（用 abstract 修饰），无法实例化。

   示例：

   // 1. 子类重写所有抽象方法（普通类）
   class Dog extends Animal {
       public Dog(String name) {
           super(name); // 调用父类构造方法
       }
       
       // 重写抽象方法 eat()
       @Override
       public void eat() {
           System.out.println(name + "在吃骨头");
       }
   }
   
   // 2. 子类不重写全部抽象方法（需声明为抽象类）
   abstract class Cat extends Animal {
       public Cat(String name) {
           super(name);
       }
       // 未重写 eat() 方法，因此 Cat 必须是抽象类
   }
   

为什么需要抽象类？

抽象类的核心价值在于“抽取共性、规范实现”：

• 抽取共性：将多个子类共有的属性和方法（如动物的“名字”“睡觉方法”）放在抽象类中，避免代码重复。
• 规范实现：通过抽象方法强制子类必须实现某些核心逻辑（如每种动物的“吃”法不同，抽象类定义 eat() 方法，子类必须根据自身特点实现）。

抽象类与普通类、接口的区别

对比维度	抽象类	普通类	接口（Java 8+）
实例化	不能	能	不能
方法类型	可包含抽象方法、普通方法	只能包含普通方法（无抽象方法）	默认抽象方法（可省略 abstract），可有静态方法、默认方法（default）
成员变量	可包含任意成员变量（非静态、静态）	同左	只能是静态常量（public static final，默认省略）
继承/实现	子类用 extends 单继承	子类用 extends 单继承	类用 implements 多实现
核心作用	为子类提供模板，抽取共性+规范实现	直接实例化，封装独立功能	定义规范（多实现场景）

典型使用场景

当需要定义一个“基础模板”，且这个模板中部分方法的实现由子类决定时，适合用抽象类。例如：

• 定义“图形（Shape）”抽象类，包含“面积（getArea()）”抽象方法，子类“圆形（Circle）”“矩形（Rectangle）”分别实现自己的面积计算逻辑。
• 定义“员工（Employee）”抽象类，包含“计算工资（calculateSalary()）”抽象方法，子类“全职员工”“兼职员工”按不同规则实现工资计算。

总结：抽象类是“半完整的类”，既提供了可复用的实现，又通过抽象方法约束了子类的行为，是连接“共性抽取”和“个性化实现”的桥梁。

问题：

把id写成了name,导致前端页面出错

形参加了双引号，导致判断逻辑出错