---

简答题

一，ANY

（一）大于运算符（>）

当列的值大于子查询的最小值时，此比较运算符与 ANY 运算符的计算结果为 TRUE。

（二）小于运算符（

当列的值小于子查询的最大值时，此比较运算符与 ANY 运算符的计算结果为 TRUE。

二，ALL

（一）大于运算符（>）

当指定列的值大于返回列表的最大值时，此比较运算符与 ALL 运算符的计算结果为 TRUE。

（二）小于运算符（

当指定列的值小于返回列表的最小值时，此比较运算符与 ALL 运算符的计算结果为 TRUE。

三，知识点

1. SQL语句查询中，在做多表连接查询时只有满足连接条件的记录才包含在查询结果中，这种连接是内连接。
2. 外键约束最能体现表与表之间的关系，能保证数据一致性、完整性，让多张表之间形成关联。
3. 有A表(5条记录)和B表(7条记录)，执行”SELECT * FROM A,B”以后，产生的记录为35条。
4. 当一个程序运行时，内部可能包含多条顺序执行流（任务），每一个顺序执行流就是“线程”，多个线程之间相互独立并发执行，资源共享。
5. 对于ServerSocket，有以下代码ServerSocket ss = new ServerSocket(9000);以上代码用于创建一个服务端的socket对象（端口占用9000），调用getLocalPort方法代表获取占用本机的端口号，调用accept方法能够阻塞当前线程，当有客户端连接请求过来时该方法能够返回一个Socket对象。想要与客户端进行通信，首先要先调用accept方法获取到客户端连接过来的Socket对象，然后通过客户端的Socket对象的getInputStream()和getOutputStream()获取到输入输出的字节流，最后才能实现与客户端的通信。
6. @BeforeClass注解标记的方法会在所有测试方法执行前执行一次。
7. 注解是一种标记，可以标记类、方法、属性、局部变量、方法参数、构造方法、包；@Override注解标记的方法为重写方法；@Deprecated注解标记方法表明该方法已废弃，不建议调用。
8. Java 泛型是 Java SE 5（jdk1.5） 中引入的一项新特性，它提供了一种在编译时期检查类型安全的机制，避免了程序运行时的类型转换异常。通过泛型，可以让类或方法在定义时不指定具体的类型，而是使用一个类型参数来代替。这个类型参数可以在实例化或调用方法时被具体的类型所替换。
9. 在Java的IO操作中，flush()方法可以用来刷新流的缓冲区。
10. static关键字可以修饰类的初始化快、属性、方法、内部类，和访问权限无关。
11. super代表超类/父类的引用，可以使用super访问父类的有效访问权限内的属性及方法，也可以在当前类的构造方法中访问父类的构造方法。
12. 子类可以继承父类的私有属性和方法，但没有访问权限；子类不可继承代码块；Java中接口可以继承多个接口；子类不能继承父类的构造方法，可以且至少有一个构造方法必须调用父类的构造方法。
13. final关键字是java中的修饰符，它代表最终的、最后的。它修饰变量时代表这个变量不能改变（我们一般称为常量），它修饰方法时，代表这个方法不能被重写（我们一般称为最终方法），它修饰类时，代表这个类不能被继承（我们一般称为最终类），final不能修饰接口。因为final一旦修饰了接口就代表该接口不能被其他类实现，就失去了接口的意义。
14. 循环语句中，continue语句代表结束本次循环，继续下一次循环；break语句代表结束整个循环。
15. 表达式1/29的计算结果，Java语言中整型与整型运算不可能会产生浮点型的结果，因此1/2=0，再用09=0，所以结果为0。
16. Map集合的键不能重复，如果重复，之前添加的数据将会被覆盖。
17. union和union all关键字都是将两个结果集合并为一个，但这两者从使用和效率上来说都有所不同，union后会筛选掉重复的记录，union all不会去除重复记录；union后会按照字段的顺序进行排序，union all只是简单的将两个结果合并后就返回，因为union做的事多于union all，因此当数据量大时，从效率上来说union all要比union快。
18. ArrayList实现了基于动态数组的数据结构，LinkedList基于双向链表的数据结构，ArrayList访问元素效率高，随机增加、删除元素效率低。
19. String substring(int beginIndex)从指定下标beginIndex开始截取，一直截取到末尾【包含开始下标的字符】。String substring(int beginIndex, int endIndex)从开始下标beginIndex截取到结束下标endIndex之前【包含开始下标的这个字符，但是不包含结束下标的那个字符】。
20. 当两张表中的数据刚好匹配时，左、右、内、全外连接查询的结果的数量可能相同 。
21. TRUNC(input [, n]) ：将数字值截断，参数n表示截断到的小数位，如果n被忽略，则默认为0，为负数则取小数点前n位。
22. GRANT CREATE VIEW TO 表名：允许创建表。
23. void start() 使该线程开始执行，Java虚拟机负责调用该线程的run()方法；void sleep() 使线程进入阻塞状态，在指定（单位为毫秒）到达之后进入就绪状态；void interrupt() 中断线程阻塞状态，而不是中断线程；void join() 只有当前线程等待加入的（join）线程完成，才能继续往下执行。
24. 冒泡排序的思路核心是一次比较相邻的；两个数，将小数放在前面，大数放在后面,显然，在这个过程中，元素间的比较次数应大于等于交换次数；直接选择排序的思路核心是N（N为需要排列的元素个数）从1开始，每一轮从待排数列中选择第N小（或大）的数放到排序列表的第N个位置；快速排序的思路核心是通过一轮的排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后再按照此方法对两部分数据分别进行一轮排序，整个排序轮次递归进行，使整个数据编程一个有序数列。
25. TCP/IP模型包括应用层、传输层、网络层和网络接口层； OSI模型包括（应用层、表示层、会话层）、（传输层）、（网络层）和（数据链路层、物理层）。
26. Java提供的四个元注解（用于修饰注解的注解）@Target、@Retention、@Documented和@Inherited。
27. 异常的捕获顺序应该先捕获范围小的再捕获范围大的，ArrayIndexOutOfBoundsException属于Exception子类。
28. 所有异常都继承自java.lang.Throwable类。
29. Java反射就是Java程序在运行时，可以加载、探知、使用编译期间完全未知的类。
30. 网络协议通常由语义，语法，时序三要素组成。
31. File类的作用是代表一个特定的文件或目录，FileInputStream与ObjectInputStream属于字节流，FileReader属于字符流。
32. java.lang包下的类不需要手动导入，声明包在程序第一行，导包关键字import。
33. 方法相同才会引起重载和重写！同一个类相同方法名但是形参列表不同会引起重载，与返回值类型无关；重写是子类继承父类，返回值类型可以兼容。
34. 重载关系是同一个类中，有两个或以上的方法方法名相同，参数列表不同。参数列表不同包括：参数类型不同、参数的数量不同、参数的顺序不同。与返回值无关。
35. NOT NULL, UNIQUE, PRIMARY KEY, FOREIGN KEY,CHECK数据库约束。
36. 事务的4大特性（ACID），原子性，一致性，隔离性，持久性。

实操题

1+X 中级实操考试（id：2496）

/**
 *处理日期的工具类
 */
public class DateUtil {
	private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	/**
	 * 使用全局变量： sdf，将字符串转换为java.util.Date类型并返回
	 * 注意，不能声明任何形式的异常抛出，否则测试用例无法通过
	 * @param stringDate
	 * @return
	 */
	public static Date convertFromStringToDate(String stringDate) {
		// 补全代码：
		Date date = null;
		try {
			date = sdf.parse(stringDate);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}
	
	/**
	 * 使用全局变量： sdf，将日期转换成字符串
	 * @param date 需要被转换的日期
	 * @return 转换之后的字符串形式的日期
	 */
	public static String convertFromDateToString(Date date) {
		// 补全或替换代码
		return sdf.format(date);
	}
}

/**
 * 接口实现类
 */
public class SBDaoImpl implements SBDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilSB> ou = new ObjectUtilSB>();
        ObjectUtilBook> bookUtil = new ObjectUtilBook>();

        public int add(Book book){
                String sql = "insert into book values(?,?,?,?)";
                return bookUtil.add(sql, book.getName(),book.getAuthor(),book.getPrice(),book.getNum());
        }
        /**
	 * 依据书名查询书籍
         * @param bname 书名
	 * @return 有的话返回书籍对象（唯一），没有的话返回null
	 */
	public Book findByName(String bname){
                // 请补全sql语句
                String sql = "select * from book where name=?";
                Book b = ou.getOne(sql, Book.class, bname);
                return b;
        }

        /**
	 * 查询所有书籍中价钱最贵的书籍名称
	 * @return 返回书籍名称
	 */
	public String queryExpensiveBook(){
                // 请补全sql语句
                String sql = "select * from book where price=(select max(price) from book)";
                Book b = ou.getOne(sql, Book.class);
                return b.getName();
        }

        /**
	 * 依据学生的姓名来删除学生
	 * @param name 学生姓名
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteStudent(String name){
              // 请补全sql语句
              String sql = "delete from student where name=?";
              int a = ou.delete(sql, name);
              if(a>0){
                        return true;
              }else{
                        return false;  
              }
        }

        /**
	 * 根据学生姓名、旧密码、新密码来更新密码
	 * 如果学生姓名和旧密码不正确，则不更新
	 * 如果学生姓名和旧密码正确，则更新
	 *
	 * @param name 姓名
	 * @param oldPwd 旧密码
	 * @param newPwd 新密码
	 */
	public void changePwd(String name,String oldPwd,String newPwd){
                // 1.先判断学生姓名和旧密码是否正确
                // 请补全sql语句
                String sql1 = "select * from student where name=? and pwd=?";
                Student s = ou.getOne(sql1, Student.class, name, oldPwd);

                // 2.姓名和旧密码正确，则更新；姓名和旧密码不正确，则不更新
                if(s!=null){
                        // 请补全sql语句
                        String sql2 = "update student set pwd=? where name=?";
                        ou.update(sql2, newPwd, name);
                }
        }

        /**
	 * 借书
	 * @param sb 需要借阅的书籍信息
	 * @return 借书成功返回true，借书失败返回false
	 */
        public boolean borrow(SB sb) {
                // 1.首先依据要借的书名来获取书籍对象
                Book b = findByName(sb.getBname());
                
                // 2.有书则借书，并返回true；没有书则不借书，并返回false
                if(b!=null&&b.getNum()>0){
                        // 往 sb 表中插入相关信息：学生姓名，书籍名称，借书时间。自增id和还书时间不用插入。
                        // 请补全sql语句
                        String sql1 = "insert into sb(sname,bname,begintime) values(?,?,?)";
                        ou.add(sql1,sb.getSname(),sb.getBname(),DateUtil.convertFromDateToString(sb.getBeginTime()));
                        // 更新 book 表中对应书籍的数量减1
                        // 请补全sql语句
                        String sql2 = "update book set num=num-1 where name=?";
                        ou.update(sql2, sb.getBname());
                        return true;
                }else{
                        return false;
                }
        }

        /**
	 * 还书
	 * @param sb 需要归还的书籍信息
	 * @return 还书成功返回true，还书失败返回false
	 */
	public boolean giveBack(SB sb){
                //1.首先查询某人是否在某个时间借阅了某书，但是还没有归还
                // 请补全sql语句
                String sql = "select * from sb where sname=? and bname=? and begintime=? and endtime is null";
                String btime = DateUtil.convertFromDateToString(sb.getBeginTime());
                SB f = ou.getOne(sql, SB.class, sb.getSname(),sb.getBname(), btime);

                //2.借了则归还，并返回true；没有借则不用归还，并返回false
                if(f!=null){
                        // 根据借书人、借书名称、借书时间来更新 sb 表中的还书时间为当前时间
                        // 请补全sql语句
                        String sql1 = "update sb set endtime=? where sname=? and bname=? and begintime=?";
                        ou.update(sql1, DateUtil.convertFromDateToString(new Date()),sb.getSname(),sb.getBname(),DateUtil.convertFromDateToString(sb.getBeginTime()));
                        // 更新 book 表中对应书籍的数量加1
                        // 请补全sql语句
                        String sql2 = "update book set num=num+1 where name=?";
                        ou.update(sql2, sb.getBname());
                        return true;
                }else{
                        return false;
                }
        }
}

public interface SBDao {
	public int add(Book book);
	 /**
	 * 依据书名查询书籍
     * 判断依据：1、是否有书名，2、数量是否大于0
	 * @param bname 书名
	 * @return 有的话返回书籍对象，没有的话返回null
	 */
	public Book findByName(String bname);

	/**
	 * 查询所有书籍中价钱最贵的书籍名称
	 * @return 返回书籍名称
	 */
	public String queryExpensiveBook();
	
	/**
	 * 依据学生的姓名来删除学生
	 * @param name 学生姓名
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteStudent(String name);

	/**
	 * 根据学生名称、旧密码、新密码来更新密码
	 * 如果学生名称和旧密码不正确，则不更新
	 * 如果学生名称和旧密码正确，则更新
	 *
	 * @param name 姓名
	 * @param oldPwd 旧密码
	 * @param newPwd 新密码
	 */
	public void changePwd(String name,String oldPwd,String newPwd);

	 /**
	 * 借书
	 * @param sb 需要借阅的书籍信息
	 * @return 借书成功返回true，借书失败返回false
	 */
	public boolean borrow(SB sb);

	 /**
	 * 还书
	 * @param sb 需要归还的书籍信息
	 * @return 还书成功返回true，还书失败返回false
	 */
	public boolean giveBack(SB sb);
}

1+X 中级实操考试（id：2498）

//已经提供Member类的属性，补充完成该类的有参（四个参数）及无参构造方法
// 有参构造
public Member(String name, String pwd, float score, int rank) {
	this.name = name;
	this.pwd = pwd;
	this.score = score;
	this.rank = rank;
}

// 无参构造
public Member() {}

/**
 * 使用全局变量： sdf，将字符串转换为java.util.Date类型并返回
 * 注意，不能声明任何形式的异常抛出，否则测试用例无法通过
 * @param stringDate
 * @return
 */
public static Date convertFromStringToDate(String stringDate) {
	// 补全代码：
	Date date = null;
	try {
		date = sdf.parse(stringDate);
	} catch (ParseException e) {
		e.printStackTrace();
	}
	return date;
}

/**
 * 查询所有商品中价钱最贵的商品名称
 * @return 返回商品名称
 */
public String queryExpensiveGoods() {
            // 请补全sql语句
            String sql = "select name from goods where price = (select max(price) from goods)";
            Goods g = goodsUtil.getOne(sql, Goods.class);
            return g.getName();
    }

/**
 * 查询所有商品的总价值金额
 * @return 返回所有商品的总价值金额
 */
public double querySum() {
            String sql = "select * from goods";
            double sum = 0;
            ListGoods> list = goodsUtil.getList(sql, Goods.class);
            for (Goods goods : list) {
                    // 请补全代码
                    sum += goods.getPrice() * goods.getNum();
            }
            return sum;
    }

/**
 * 依据商品名称来删除商品
 * @param name 商品名称
 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
 */
public boolean deleteGoods(String name) {
            // 请补全sql语句
            String sql = "delete from goods where name=?";
            int a = goodsUtil.delete(sql, name);
            if(a>0){
                      return true;
            }else{
                      return false;  
            }
    }

/**
 * 根据会员的积分来更新会员的等级
 * 0
public void updateRank() {
            // 请补全sql语句
            String sql = "update member set `rank`=case when score;
            memberUtil.update(sql); 
    }

/**
 * 给每个会员的密码加密
 * 加密规则：密码的逆序。
 * 如：原来的密码是123，加密后为321。
 */
public void updatePwd(){
            // 请补全sql语句
            String sql = "update member set pwd = reverse(pwd)";
            memberUtil.update(sql); 
    }

/**
 * 依据会员名称来删除会员
 * @param name 会员名称
 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
 */
public boolean deleteMember(String name) {
            // 请补全sql语句
            String sql = "delete from member where name=?";
            int a = memberUtil.delete(sql, name);
            if(a>0){
                      return true;
            }else{
                      return false;  
            }
    }

/**
 * 查询一共有多少笔订单
 * @return 返回订单数量
 */
public int queryNum() {
            String sql = "select * from `order`;";
            ListOrder> o = orderUtil.getList(sql, Order.class); 
            SetInteger> s = new HashSetInteger>();
            for (Order order : o) {
                    // 请补全语句
                    s.add(order.getId());
            }
            return s.size();
    }

/**
 * 查询消费金额最多的人
 * @return 返回会员名称
 */
public String queryMax() {
            // 请补全sql语句
            String sql = "select * from `order` where mname=(select mname from `order` group by mname order by sum(num*price) desc limit 1)";
            Order o = orderUtil.getOne(sql, Order.class); 
            return o.getMname();
    }

/**
 * 依据订单号来删除订单
 * @param id 订单号
 * @return 存在订单号则删除，并返回true；不存在则不删除，并返回false
 */
public boolean deleteOrder(int id) {
            // 请补全sql语句
            String sql = "delete from `order` where id=?";
            int a = orderUtil.delete(sql, id);
            if(a>0){
                      return true;
            }else{
                      return false;  
            }
    }

/**
 *处理日期的工具类
 */
public class DateUtil {
	private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	/**
	 * 使用全局变量： sdf，将字符串转换为java.util.Date类型并返回
	 * 注意，不能声明任何形式的异常抛出，否则测试用例无法通过
	 * @param stringDate
	 * @return
	 */
	public static Date convertFromStringToDate(String stringDate) {
		// 补全代码：
		Date date = null;
		try {
			date = sdf.parse(stringDate);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}
	
	/**
	 * 使用全局变量： sdf，将日期转换成字符串
	 * @param date 需要被转换的日期
	 * @return 转换之后的字符串形式的日期
	 */
	public static String convertFromDateToString(Date date) {
		// 补全或替换代码
		String stringDate = null;
        if (date != null) {
            stringDate = sdf.format(date);
        }
        return stringDate;
	}
}

1+X 中级实操考试（id：2660）

public interface CourseDao {
	 /**
	 * 根据课程名称来更新课程难度
	 * @return 更新成功返回true，没有更新成功返回false
	 */
	public boolean updateDifficultyByName(String name,String difficulty);

	 /**
	 * 根据课程名称来查询课程
	 * @return 返回课程对象
	 */
	public Course queryCourse(String name);

	/**
	 * 插入课程
	 * @param c 课程对象
	 * @return
	 */
	public int add(Course c);

	/**
	 * 依据课程名称来删除课程
	 * @param name 课程名称
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteCourse(String name);
}

public interface ScoreDao {
	/**
	 * 查询至少考了2门课程的学生姓名
	 * @return 返回所有满足条件的学生姓名的集合
	 */
	public SetString> queryName();

	 /**
	 * 查询平均成绩最高的学生姓名
	 * @return 返回学生姓名
	 */
	public String queryAvgMax();

	/**
	 * 插入成绩
	 * @param score 成绩对象
	 * @return
	 */
	public int add(Score score);

	/**
	 * 依据学生姓名和课程名称来删除成绩
	 * @param sname 学生姓名
	 * @param cname 课程名称
	 * @return 存在则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteScore(String sname,String cname);
}

public interface StudentDao {
	 /**
	 * 查询最小年龄的学生姓名
	 * @return 返回学生姓名
	 */
	public String queryMinAge();

	/**
	 * 查询学生总人数
	 * @return 返回总人数
	 */
	public int queryNum();

	/**
	 * 插入学生
	 * @param s 学生对象
	 * @return
	 */
	public int add(Student s);

	/**
	 * 依据学生姓名来删除学生
	 * @param name 学生姓名
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteStudent(String name);
}

/**
 * 接口实现类
 */
public class CourseDaoImpl implements CourseDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilCourse> courseUtil = new ObjectUtilCourse>();

         /**
	 * 根据课程名称来更新课程难度
	 * @return 更新成功返回true，没有更新成功返回false
	 */
	public boolean updateDifficultyByName(String name,String difficulty){
                // 请补全sql语句
                String sql = "update course set difficulty=? where name=?";
                int a = courseUtil.update(sql, difficulty, name);
                if(a>0){
                        return true;
                }else{
                        return false;  
                }
        }


         /**
	 * 根据课程名称来查询课程
	 * @return 返回课程对象
	 */
	public Course queryCourse(String name) {
                // 请补全sql语句
                String sql = "select * from course where name=?";
                return courseUtil.getOne(sql, Course.class, name);
        }

        /**
	 * 插入课程
	 * @param c 课程对象
	 * @return
	 */
	public int add(Course c) {
                String sql = "insert into course values(?,?,?)";
                return courseUtil.add(sql, c.getName(),c.getTeacher(),c.getDifficulty());
        }

        /**
	 * 依据课程名称来删除课程
	 * @param name 课程名称
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteCourse(String name) {
                String sql = "delete from course where name=?";
                int a = courseUtil.delete(sql, name);
                if(a>0){
                          return true;
                }else{
                          return false;  
                }
        }
}

/**
 * 接口实现类
 */
public class ScoreDaoImpl implements ScoreDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilScore> scoreUtil = new ObjectUtilScore>();

        /**
	 * 查询至少考了2门课程的学生姓名
	 * @return 返回所有满足条件的学生姓名的集合
	 */
	public SetString> queryName() {
                // 查询出满足条件的成绩集合
                String sql = "select * from score where sname in(select sname from score group by sname having count(*)>=2)";
                ListScore> li = scoreUtil.getList(sql, Score.class);
                SetString> s = new HashSetString>();
                // 把集合 li 中的每个成绩对象的名字取出来放进集合 s 中,并返回
                // 请补全以下代码
                for (Score score : li) {
                        s.add(score.getSname());
                }
                return s;
        }


        /**
	 * 查询平均成绩最高的学生姓名
	 * @return 返回学生姓名
	 */
	public String queryAvgMax() {
                // 请补全sql语句
                String sql = "select * from score where sname=(select sname from score group by sname order by avg(score) desc limit 1)";
                Score s = scoreUtil.getOne(sql, Score.class);
                return s.getSname();
        }

        /**
	 * 插入成绩
	 * @param score 成绩对象
	 * @return
	 */
	public int add(Score score) {
                String sql = "insert into score values(?,?,?)";
                return scoreUtil.add(sql, score.getSname(),score.getCname(),score.getScore());
        }

        /**
	 * 依据学生姓名和课程名称来删除成绩
	 * @param sname 学生姓名
	 * @param cname 课程名称
	 * @return 存在则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteScore(String sname,String cname) {
                String sql = "delete from score where sname=? and cname=?";
                int a = scoreUtil.delete(sql, sname, cname);
                if(a>0){
                          return true;
                }else{
                          return false;  
                }
        }
}

/**
 * 接口实现类
 */
public class StudentDaoImpl implements StudentDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilStudent> studentUtil = new ObjectUtilStudent>();

        /**
	 * 查询最小年龄的学生姓名
	 * @return 返回学生姓名
	 */
	public String queryMinAge() {
                // 请补全sql语句
                String sql = "select * from student order by age limit 1";
                Student g = studentUtil.getOne(sql, Student.class);
                return g.getName();
        }

        /**
	 * 查询学生总人数
	 * @return 返回总人数
	 */
	public int queryNum() {
                String sql = "select * from student";
                ListStudent> list = studentUtil.getList(sql, Student.class);
                // 请修改以下代码，保证返回值为总人数，假设所有学生名字都不一样
                int num = list.size();
                return num;
        }

        /**
	 * 插入学生
	 * @param s 学生对象
	 * @return
	 */
	public int add(Student s) {
                // 请补全sql语句
                String sql = "insert into student values(?,?,?,?,?)";
                return studentUtil.add(sql, s.getName(),s.getPwd(),s.getAge(),s.getGrade(),s.getRate());
        }

        /**
	 * 依据学生姓名来删除学生
	 * @param name 学生姓名
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteStudent(String name) {
                String sql = "delete from student where name=?";
                int a = studentUtil.delete(sql, name);
                if(a>0){
                          return true;
                }else{
                          return false;  
                }
        }
}

1+X 中级实操考试（id：2846）

public interface CourseDao {
	 /**
	 * 根据课程名称来更新课程难度
	 * @return 更新成功返回true，没有更新成功返回false
	 */
	public boolean updateDifficultyByName(String name,String difficulty);

	 /**
	 * 根据课程名称来查询课程
	 * @return 返回课程对象
	 */
	public Course queryCourse(String name);

	/**
	 * 插入课程
	 * @param c 课程对象
	 * @return
	 */
	public int add(Course c);

	/**
	 * 依据课程名称来删除课程
	 * @param name 课程名称
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteCourse(String name);
}

public interface ScoreDao {
	/**
	 * 查询至少考了2门课程的学生姓名
	 * @return 返回所有满足条件的学生姓名的集合
	 */
	public SetString> queryName();

	 /**
	 * 查询平均成绩最大的学生姓名
	 * @return 返回学生姓名
	 */
	public String queryAvgMax();

	/**
	 * 插入成绩
	 * @param score 成绩对象
	 * @return
	 */
	public int add(Score score);

	/**
	 * 依据学生姓名和课程名称来删除成绩
	 * @param sname 学生姓名
	 * @param cname 课程名称
	 * @return 存在则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteScore(String sname,String cname);
}

public interface StudentDao {
	 /**
	 * 查询最大年龄的学生姓名
	 * @return 返回学生姓名
	 */
	public String queryMaxAge();

	/**
	 * 查询年龄大于20岁的学生总人数
	 * @return 返回总人数
	 */
	public int queryNum();

	/**
	 * 插入学生
	 * @param s 学生对象
	 * @return
	 */
	public int add(Student s);

	/**
	 * 依据学生姓名来删除学生
	 * @param name 学生姓名
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteStudent(String name);
}

/**
 * 接口实现类
 */
public class CourseDaoImpl implements CourseDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilCourse> courseUtil = new ObjectUtilCourse>();

         /**
	 * 根据课程名称来更新课程难度
	 * @return 更新成功返回true，没有更新成功返回false
	 */
	public boolean updateDifficultyByName(String name,String difficulty){
                // 请补全sql语句
                String sql = "update course set difficulty=? where name=?";
                int a = courseUtil.update(sql, difficulty, name);
                if(a>0){
                        return true;
                }else{
                        return false;  
                }
        }


         /**
	 * 根据课程名称来查询课程
	 * @return 返回课程对象
	 */
	public Course queryCourse(String name) {
                // 请补全sql语句
                String sql = "select * from course where name=?";
                return courseUtil.getOne(sql, Course.class, name);
        }

        /**
	 * 插入课程
	 * @param c 课程对象
	 * @return
	 */
	public int add(Course c) {
                String sql = "insert into course values(?,?,?)";
                return courseUtil.add(sql, c.getName(),c.getTeacher(),c.getDifficulty());
        }

        /**
	 * 依据课程名称来删除课程
	 * @param name 课程名称
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteCourse(String name) {
                String sql = "delete from course where name=?";
                int a = courseUtil.delete(sql, name);
                if(a>0){
                          return true;
                }else{
                          return false;  
                }
        }
}

/**
 * 接口实现类
 */
public class ScoreDaoImpl implements ScoreDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilScore> scoreUtil = new ObjectUtilScore>();

        /**
	 * 查询至少考了2门课程的学生姓名
	 * @return 返回所有满足条件的学生姓名的集合
	 */
	public SetString> queryName() {
                // 查询出满足条件的成绩集合
                String sql = "select * from score where sname in(select sname from score group by sname having count(*)>=2)";
                ListScore> li = scoreUtil.getList(sql, Score.class);
                SetString> s = new HashSetString>();
                // 把集合 li 中的每个成绩对象的名字取出来放进集合 s 中,并返回
                // 请补全以下代码
                for (Score score : li) {
                        s.add(score.getSname());
                }

                return s;
        }


        /**
	 * 查询平均成绩最大的学生姓名
	 * @return 返回学生姓名
	 */
	public String queryAvgMax() {
                // 请补全sql语句
                String sql = "select * from score where sname=(select sname from score group by sname order by avg(score) desc limit 1)";
                Score s = scoreUtil.getOne(sql, Score.class);
                return s.getSname();
        }

        /**
	 * 插入成绩
	 * @param score 成绩对象
	 * @return
	 */
	public int add(Score score) {
                String sql = "insert into score values(?,?,?)";
                return scoreUtil.add(sql, score.getSname(),score.getCname(),score.getScore());
        }

        /**
	 * 依据学生姓名和课程名称来删除成绩
	 * @param sname 学生姓名
	 * @param cname 课程名称
	 * @return 存在则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteScore(String sname,String cname) {
                String sql = "delete from score where sname=? and cname=?";
                int a = scoreUtil.delete(sql, sname, cname);
                if(a>0){
                          return true;
                }else{
                          return false;  
                }
        }
}

/**
 * 接口实现类
 */
public class StudentDaoImpl implements StudentDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilStudent> studentUtil = new ObjectUtilStudent>();

        /**
	 * 查询最大年龄的学生姓名
	 * @return 返回学生姓名
	 */
	public String queryMaxAge() {
                // 请补全sql语句
                String sql = "select * from student where age =(select max(age) from student)";
                Student g = studentUtil.getOne(sql, Student.class);
                return g.getName();
        }

        /**
	 * 查询年龄大于20岁的学生总人数
	 * @return 返回总人数
	 */
	public int queryNum() {
                String sql = "select * from student where age>20";
                ListStudent> list = studentUtil.getList(sql, Student.class);
                // 请修改以下代码，保证返回值为总人数，假设所有学生名字都不一样
                int num = list.size();
                return num;
        }

        /**
	 * 插入学生
	 * @param s 学生对象
	 * @return
	 */
	public int add(Student s) {
                // 请补全sql语句
                String sql = "insert into student values(?,?,?,?,?)";
                return studentUtil.add(sql, s.getName(),s.getPwd(),s.getAge(),s.getGrade(),s.getRate());
        }

        /**
	 * 依据学生姓名来删除学生
	 * @param name 学生姓名
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteStudent(String name) {
                String sql = "delete from student where name=?";
                int a = studentUtil.delete(sql, name);
                if(a>0){
                          return true;
                }else{
                          return false;  
                }
        }
}

1+X 中级实操考试（id：3097）

public interface SBDao {
	public int add(Book book);
	 /**
	 * 依据书名查询书籍
     * 判断依据：1、是否有书名，2、数量是否大于0
	 * @param bname 书名
	 * @return 有的话返回书籍对象，没有的话返回null
	 */
	public Book findByName(String bname);

	/**
	 * 查询所有书籍中价钱最贵的书籍名称
	 * @return 返回书籍名称
	 */
	public String queryExpensiveBook();
	
	/**
	 * 依据学生的姓名来删除学生
	 * @param name 学生姓名
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteStudent(String name);

	/**
	 * 根据学生名称、旧密码、新密码来更新密码
	 * 如果学生名称和旧密码不正确，则不更新
	 * 如果学生名称和旧密码正确，则更新
	 *
	 * @param name 姓名
	 * @param oldPwd 旧密码
	 * @param newPwd 新密码
	 */
	public void changePwd(String name,String oldPwd,String newPwd);

	 /**
	 * 借书
	 * @param sb 需要借阅的书籍信息
	 * @return 借书成功返回true，借书失败返回false
	 */
	public boolean borrow(SB sb);

	 /**
	 * 还书
	 * @param sb 需要归还的书籍信息
	 * @return 还书成功返回true，还书失败返回false
	 */
	public boolean giveBack(SB sb);
}

/**
 * 接口实现类
 */
public class SBDaoImpl implements SBDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilSB> ou = new ObjectUtilSB>();
        ObjectUtilBook> bookUtil = new ObjectUtilBook>();

        public int add(Book book){
                String sql = "insert into book values(?,?,?,?)";
                return bookUtil.add(sql, book.getName(),book.getAuthor(),book.getPrice(),book.getNum());
        }
        /**
	 * 依据书名查询书籍
         * @param bname 书名
	 * @return 有的话返回书籍对象（唯一），没有的话返回null
	 */
	public Book findByName(String bname){
                // 请补全sql语句
                String sql = "select * from book where name=?";
                Book b = ou.getOne(sql, Book.class, bname);
                return b;
        }

        /**
	 * 查询所有书籍中价钱最贵的书籍名称
	 * @return 返回书籍名称
	 */
	public String queryExpensiveBook(){
                // 请补全sql语句
                String sql = "select * from book where price=(select max(price) from book)";
                Book b = ou.getOne(sql, Book.class);
                return b.getName();
        }

        /**
	 * 依据学生的姓名来删除学生
	 * @param name 学生姓名
	 * @return 存在名字则删除，并返回true；不存在则不删除，并返回false
	 */
	public boolean deleteStudent(String name){
              // 请补全sql语句
              String sql = "delete from student where name=?";
              int a = ou.delete(sql, name);
              if(a>0){
                        return true;
              }else{
                        return false;  
              }
        }

        /**
	 * 根据学生姓名、旧密码、新密码来更新密码
	 * 如果学生姓名和旧密码不正确，则不更新
	 * 如果学生姓名和旧密码正确，则更新
	 *
	 * @param name 姓名
	 * @param oldPwd 旧密码
	 * @param newPwd 新密码
	 */
	public void changePwd(String name,String oldPwd,String newPwd){
                // 1.先判断学生姓名和旧密码是否正确
                // 请补全sql语句
                String sql1 = "select * from student where name=? and pwd=?";
                Student s = ou.getOne(sql1, Student.class, name, oldPwd);

                // 2.姓名和旧密码正确，则更新；姓名和旧密码不正确，则不更新
                if(s!=null){
                        // 请补全sql语句
                        String sql2 = "update student set pwd=? where name=?";
                        ou.update(sql2, newPwd, name);
                }
        }

        /**
	 * 借书
	 * @param sb 需要借阅的书籍信息
	 * @return 借书成功返回true，借书失败返回false
	 */
        public boolean borrow(SB sb) {
                // 1.首先依据要借的书名来获取书籍对象
                Book b = findByName(sb.getBname());
                
                // 2.有书则借书，并返回true；没有书则不借书，并返回false
                if(b!=null&&b.getNum()>0){
                        // 往 sb 表中插入相关信息：学生姓名，书籍名称，借书时间。自增id和还书时间不用插入。
                        // 请补全sql语句
                        String sql1 = "insert into sb(sname,bname,begintime) values(?,?,?)";
                        ou.add(sql1,sb.getSname(),sb.getBname(),DateUtil.convertFromDateToString(sb.getBeginTime()));
                        // 更新 book 表中对应书籍的数量减1
                        // 请补全sql语句
                        String sql2 = "update book set num=num-1 where name=?";
                        ou.update(sql2, sb.getBname());
                        return true;
                }else{
                        return false;
                }
        }

        /**
	 * 还书
	 * @param sb 需要归还的书籍信息
	 * @return 还书成功返回true，还书失败返回false
	 */
	public boolean giveBack(SB sb){
                //1.首先查询某人是否在某个时间借阅了某书，但是还没有归还
                // 请补全sql语句
                String sql = "select * from sb where sname=? and bname=? and begintime=? and endtime is null";
                String btime = DateUtil.convertFromDateToString(sb.getBeginTime());
                SB f = ou.getOne(sql, SB.class, sb.getSname(),sb.getBname(), btime);

                //2.借了则归还，并返回true；没有借则不用归还，并返回false
                if(f!=null){
                        // 根据借书人、借书名称、借书时间来更新 sb 表中的还书时间为当前时间
                        // 请补全sql语句
                        String sql1 = "update sb set endtime=? where sname=? and bname=? and begintime=?";
                        ou.update(sql1, DateUtil.convertFromDateToString(new Date()),sb.getSname(),sb.getBname(),DateUtil.convertFromDateToString(sb.getBeginTime()));
                        // 更新 book 表中对应书籍的数量加1
                        // 请补全sql语句
                        String sql2 = "update book set num=num+1 where name=?";
                        ou.update(sql2, sb.getBname());
                        return true;
                }else{
                        return false;
                }
        }
}

/**
 *处理日期的工具类
 */
public class DateUtil {
	private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	/**
	 * 使用全局变量： sdf，将字符串转换为java.util.Date类型并返回
	 * 注意，不能声明任何形式的异常抛出，否则测试用例无法通过
	 * @param stringDate
	 * @return
	 */
	public static Date convertFromStringToDate(String stringDate) {
		// 补全代码：
		Date date = null;
		try {
			date = sdf.parse(stringDate);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}
	
	/**
	 * 使用全局变量： sdf，将日期转换成字符串
	 * @param date 需要被转换的日期
	 * @return 转换之后的字符串形式的日期
	 */
	public static String convertFromDateToString(Date date) {
		return sdf.format(date);
	}
}

1+X 中级实操考试（id：3352）

public interface SSDao {
	/**
	 * 依据职工姓名查询职工
	 * @param name 职工姓名
	 * @return 有的话返回职工对象，没有的话返回null
	 */
	public Staff queryStaff(String name);

	/**
	 * 查询某位职工某年某月的工资
	 * @param name 职工姓名
	 * @param year 年份
	 * @param month 月份
	 * @return 返回工资
	 */
	public int querySalary(String name,int year,int month);

	/**
	 * 查询工龄最高的职工
	 * @return 返回工龄最高的职工对象
	 */
	public Staff queryMaxSage();

	/**
	 * 查询某位职工的最高工资
	 * @param name 职工姓名
	 * @return 返回该职工的最高工资
	 */
	public int queryMaxSalary(String name);

	/**
	 * 使所有职工的年龄加1
	 */
	public void updateAge();
}

/**
 * 接口实现类
 */
public class SSDaoImpl implements SSDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilStaff> staffUtil = new ObjectUtilStaff>();
        ObjectUtilSalary> salaryUtil = new ObjectUtilSalary>();

        /**
	 * 依据职工姓名查询职工
	 * @param name 职工姓名
	 * @return 有的话返回职工对象，没有的话返回null
	 */
	public Staff queryStaff(String name){
                // 请补全sql语句
                String sql = "select * from staff where name=?";
                Staff b = staffUtil.getOne(sql, Staff.class, name);
                return b;
        }

        /**
	 * 查询某位职工某年某月的工资
	 * @param name 职工姓名
	 * @param year 年份
	 * @param month 月份
	 * @return 返回工资
	 */
	public int querySalary(String name,int year,int month){
                // 请补全sql语句
                String sql = "select sa.* from staff st,salary sa where st.id=sa.id and st.name=? and sa.year=? and sa.month=?";
                Salary sa = salaryUtil.getOne(sql, Salary.class, name, year, month);
                return sa.getNum();
        }

        /**
	 * 查询工龄最高的职工
	 * @return 返回工龄最高的职工对象
	 */
	public Staff queryMaxSage(){
                // 请补全sql语句
                String sql = "select * from staff order by sage desc limit 1";
                Staff st = staffUtil.getOne(sql, Staff.class);
                return st;
        }

	/**
	 * 查询某位职工的最高工资
	 * @param name 职工姓名
	 * @return 返回该职工的最高工资
	 */
	public int queryMaxSalary(String name){
                // 请补全sql语句
                String sql = "select sa.* from staff st,salary sa where st.id=sa.id and st.name=? order by num desc limit 1";
                Salary s = salaryUtil.getOne(sql, Salary.class, name);
                return s.getNum();
        }

        /**
	 * 使所有职工的年龄加1
	 */
	public void updateAge(){
               // 请补全sql语句
               String sql = "update staff set age=age+1";
               int i = staffUtil.update(sql);
        }
}

1+X 中级实操考试（id：3411）

public interface SSDao {
	/**
	 * 依据学生考号查询学生信息
	 * @param id 学生考号
	 * @return 有的话返回学生对象，没有的话返回null
	 */
	public Info queryInfo(String id);

	/**
	 * 依据学生考号查询学生成绩，返回4门成绩之和
	 * @param id 学生考号
	 * @return 返回4门成绩之和
	 */
	public int querySum(String id);

	/**
	 * 依据学生姓名查询学生成绩，返回4门成绩之和
	 * @param name 学生姓名
	 * @return 返回4门成绩之和
	 */
	public int querySumByName(String name);

	/**
	 * 查询4门成绩之和的最大值
	 * @return 返回最大值
	 */
	public int queryMaxSum();

	/**
	 * 依据姓名更新年龄
	 * @return name 姓名
	 * @return age 年龄
	 */
	public void updateAge(String name,int age);
}

/**
 * 接口实现类
 */
public class SSDaoImpl implements SSDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilInfo> infoUtil = new ObjectUtilInfo>();
        ObjectUtilScore> scoreUtil = new ObjectUtilScore>();

        /**
	 * 依据学生考号查询学生信息
	 * @param id 学生考号
	 * @return 有的话返回学生对象，没有的话返回null
	 */
	public Info queryInfo(String id){
                // 请补全sql语句
                String sql = "select * from info where id=?";
                Info i = infoUtil.getOne(sql, Info.class, id);
                return i;
        }

        /**
	 * 依据学生考号查询学生成绩，返回4门成绩之和
	 * @param id 学生考号
	 * @return 返回4门成绩之和
	 */
	public int querySum(String id){
                // 请补全sql语句
                String sql = "select * from score where id=?";
                Score s = scoreUtil.getOne(sql, Score.class, id);
                int sum = s.getChinese() + s.getMaths() + s.getEnglish() + s.getComposite();
                return sum;
        }

        /**
	 * 依据学生姓名查询学生成绩，返回4门成绩之和
	 * @param name 学生姓名
	 * @return 返回4门成绩之和
	 */
	public int querySumByName(String name){
                // 请补全sql语句
                String sql = "select s.* from info i,score s where i.id=s.id and i.name=?";
                Score s = scoreUtil.getOne(sql, Score.class, name);
                int sum = s.getChinese() + s.getMaths() + s.getEnglish() + s.getComposite();
                return sum;
        }

	/**
	 * 查询4门成绩之和的最大值
	 * @return 返回最大值
	 */
	public int queryMaxSum(){
                // 请补全sql语句
                String sql = "select * from score order by chinese+maths+english+composite desc limit 1";
                Score s = scoreUtil.getOne(sql, Score.class);
                int sum = s.getChinese() + s.getMaths() + s.getEnglish() + s.getComposite();
                return sum;
        }

        /**
	 * 依据姓名更新年龄
	 * @return name 姓名
	 * @return age 年龄
	 */
	public void updateAge(String name,int age){
               // 请补全sql语句
               String sql = "update info set age=? where name=?";
               int i = infoUtil.update(sql,age,name);
        }
}

1+X 中级实操考试（id：3475）

public interface SSDao {
	/**
	 * 依据客户卡号查询客户资金
	 * @param id 客户卡号
	 * @return 有的话返回金额，没有的话返回0
	 */
	public double queryNum(String id);

	/**
	 * 依据客户姓名查询客户资金
	 * @param name 客户姓名
	 * @return 有的话返回金额，没有的话返回0
	 */
	public double queryNum2(String name);

	/**
	 * 查询有多少客户是信用卡客户(credit=true表示为信用卡用户)
	 * @return 返回人数
	 */
	public int queryCredit();

	/**
	 * 查询资金最大的人
	 * @return 返回姓名
	 */
	public String queryName();

	/**
	 * 查询客户姓名中含有某个字母s的人数
	 * @param s 某个字母
	 * @return 返回人数
	 */
	public int querySum(String s);
}

/**
 * 接口实现类
 */
public class SSDaoImpl implements SSDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilInfo> infoUtil = new ObjectUtilInfo>();
        ObjectUtilAccount> accountUtil = new ObjectUtilAccount>();

        /**
	 * 依据客户卡号查询客户资金
	 * @param id 客户卡号
	 * @return 有的话返回金额，没有的话返回0
	 */
	public double queryNum(String id){
                // 请补全sql语句
                String sql = "select * from account where id=?";
                Account a = accountUtil.getOne(sql, Account.class, id);
                if(a!=null){
                        return a.getNum();
                }else{
                        return 0;
                }
        }

        /**
	 * 依据客户姓名查询客户资金
	 * @param name 客户姓名
	 * @return 有的话返回金额，没有的话返回0
	 */
	public double queryNum2(String name){
                // 请补全sql语句
                String sql = "select * from account where id=(select id from info where name=?)";
                Account a = accountUtil.getOne(sql, Account.class, name);
                if(a!=null){
                        return a.getNum();
                }else{
                        return 0;
                }
        }

        /**
	 * 查询有多少客户是信用卡客户(credit=true表示为信用卡用户)
	 * @return 返回人数
	 */
	public int queryCredit(){
                String sql = "select * from account where credit=true";
                ListAccount> li = accountUtil.getList(sql, Account.class);
                // 请修改以下语句
                int num = li.size();
                return num;
        }

	/**
	 * 查询资金最大的人
	 * @return 返回姓名
	 */
	public String queryName(){
                // 请补全sql语句
                String sql = "select * from info where id=(select id from account order by num desc limit 1)";
                Info i = infoUtil.getOne(sql, Info.class);
                return i.getName();
        }

        /**
	 * 查询客户姓名中含有某个字母s的人数
	 * @param s 某个字母
	 * @return 返回人数
	 */
	public int querySum(String s){
               // 请补全sql语句
               String sql = "select * from info where name like '%"+s+"%'";
               ListInfo> li = infoUtil.getList(sql, Info.class);
               int num = li.size();
               return num;
        }
}

1+X 中级实操考试（id：3587）

public interface SSDao {
	/**
	 * 依据客户卡号查询客户资金
	 * @param id 客户卡号
	 * @return 有的话返回金额，没有的话返回0
	 */
	public double queryNum(String id);

	/**
	 * 依据客户姓名查询客户资金
	 * @param name 客户姓名
	 * @return 有的话返回金额，没有的话返回0
	 */
	public double queryNum2(String name);

	/**
	 * 查询有多少客户是贷款客户(credit=true表示为贷款用户)
	 * @return 返回人数
	 */
	public int queryCredit();

	/**
	 * 查询资金最大的人
	 * @return 返回姓名
	 */
	public String queryName();

	/**
	 * 查询客户姓名中含有某个字母s的人数
	 * @param s 某个字母
	 * @return 返回人数
	 */
	public int querySum(String s);
}

package org.lanqiao.daoimpl;

import org.lanqiao.bean.Info;

import java.util.List;

import org.lanqiao.bean.Account;
import org.lanqiao.dao.SSDao;
import org.lanqiao.db.ObjectUtil;

/**
 * 接口实现类
 */
public class SSDaoImpl implements SSDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilInfo> infoUtil = new ObjectUtilInfo>();
        ObjectUtilAccount> accountUtil = new ObjectUtilAccount>();

        /**
	 * 依据客户卡号查询客户资金
	 * @param id 客户卡号
	 * @return 有的话返回金额，没有的话返回0
	 */
	public double queryNum(String id){
                // 请补全sql语句
                String sql = "select * from account where id=?";
                Account a = accountUtil.getOne(sql, Account.class, id);
                if(a!=null){
                        return a.getNum();
                }else{
                        return 0;
                }
        }

        /**
	 * 依据客户姓名查询客户资金
	 * @param name 客户姓名
	 * @return 有的话返回金额，没有的话返回0
	 */
	public double queryNum2(String name){
                // 请补全sql语句
                String sql = "select * from account where id=(select id from info where name=?)";
                Account a = accountUtil.getOne(sql, Account.class, name);
                if(a!=null){
                        return a.getNum();
                }else{
                        return 0;
                }
        }

        /**
	 * 查询有多少客户是贷款客户(credit=true表示为贷款用户)
	 * @return 返回人数
	 */
	public int queryCredit(){
                String sql = "select * from account where credit=true";
                ListAccount> li = accountUtil.getList(sql, Account.class);
                // 请修改以下语句
                int num = li.size();
                return num;
        }

	/**
	 * 查询资金最大的人
	 * @return 返回姓名
	 */
	public String queryName(){
                // 请补全sql语句
                String sql = "select * from info where id=(select id from account order by num desc limit 1)";
                Info i = infoUtil.getOne(sql, Info.class);
                return i.getName();
        }

        /**
	 * 查询客户姓名中含有某个字母s的人数
	 * @param s 某个字母
	 * @return 返回人数
	 */
	public int querySum(String s){
               // 请补全sql语句
               String sql = "select * from info where name like '%"+s+"%'";
               ListInfo> li = infoUtil.getList(sql, Info.class);
               int num = li.size();
               return num;
        }
}

1+X 中级实操考试（id：3609）

public interface SSDao {
	/**
	 * 依据员工姓名查询员工信息
	 * @param name 员工姓名
	 * @return 有的话返回对象，没有的话返回null
	 */
	public Info queryByName(String name);

	/**
	 * 依据员工姓名和绩效日期查询绩效分
	 * @param name 员工姓名
	 * @param time 绩效日期
	 * @return 有的话返回绩效分，没有的话返回0
	 */
	public int queryScore(String name, String time);

	/**
	 * 查询绩效分最高的员工姓名
	 * @return 返回员工姓名
	 */
	public String queryMaxScore();

	/**
	 * 查询平均绩效分最高的员工姓名
	 * @return 返回姓名
	 */
	public String queryMaxAvg();

	/**
	 * 查询员工绩效分最高分与最低分差值最大的员工姓名
	 * @return 返回姓名
	 */
	public String queryMaxMin();
}

package org.lanqiao.daoimpl;

import java.util.List;

import org.lanqiao.bean.Account;
import org.lanqiao.bean.Info;
import org.lanqiao.dao.SSDao;
import org.lanqiao.db.ObjectUtil;

/**
 * 接口实现类
 */
public class SSDaoImpl implements SSDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilInfo> infoUtil = new ObjectUtilInfo>();
        ObjectUtilAccount> accountUtil = new ObjectUtilAccount>();

        /**
	 * 依据员工姓名查询员工信息
	 * @param name 员工姓名
	 * @return 有的话返回对象，没有的话返回null
	 */
	public Info queryByName(String name){
                // 请补全sql语句
                String sql = "select * from info where name=?";
                Info i = infoUtil.getOne(sql, Info.class, name); 
                return i;
        }

        /**
	 * 依据员工姓名和绩效日期查询绩效分
	 * @param name 员工姓名
	 * @param time 绩效日期
	 * @return 有的话返回绩效分，没有的话返回0
	 */
	public int queryScore(String name, String time){
                // 请补全sql语句
                String sql = "select * from account where name=? and time=?";
                Account i = accountUtil.getOne(sql, Account.class, name, time); 
                if(i==null){
                        return 0;
                }else{
                        return i.getScore();
                }
        }

        /**
	 * 查询绩效分最高的员工姓名
	 * @return 返回员工姓名
	 */
	public String queryMaxScore(){
                // 请补全sql语句
                String sql = "select * from account order by score desc limit 1";
                Account i = accountUtil.getOne(sql, Account.class); 
                return i.getName();
        }

	/**
	 * 查询平均绩效分最高的员工姓名
	 * @return 返回姓名
	 */
	public String queryMaxAvg() {
                // 请补全sql语句
                String sql = "select * from account where name=(select name from account group by name order by avg(score) desc limit 1)";
                Account i = accountUtil.getOne(sql, Account.class); 
                return i.getName();
        }

        /**
	 * 查询员工绩效分最高分与最低分差值最大的员工姓名
	 * @return 返回姓名
	 */
	public String queryMaxMin() {
                // 请补全sql语句
                String sql = "select * from account where name=(select name from account group by name order by max(score)-min(score) desc limit 1)";
                Account i = accountUtil.getOne(sql, Account.class); 
                return i.getName();
        }
}

1+X 中级实操考试（id：3621）

public interface SSDao {
	/**
	 * 依据员工姓名查询员工信息
	 * @param name 员工姓名
	 * @return 有的话返回对象，没有的话返回null
	 */
	public Info queryByName(String name);

	/**
	 * 依据员工姓名查询评级等级
	 * @param name 员工姓名
	 * @return 有的话返评级等级，没有的话返回null
	 */
	public String queryLevel(String name);

	/**
	 * 依据以下规则，检查员工评级等级是否正确
     * 90
	public Boolean checkLevel(String name);

	/**
	 * 依据以下规则，更新所有的评级等级
	 * 90
	public void updateLevel();

	/**
	 * 查询每个评级等级对应有多少人
	 * @param level 评级等级
	 * @return 返回人数
	 */
	public int queryNum(String level);
}

package org.lanqiao.daoimpl;

import java.util.List;

import org.lanqiao.bean.Account;
import org.lanqiao.bean.Info;
import org.lanqiao.dao.SSDao;
import org.lanqiao.db.ObjectUtil;

/**
 * 接口实现类
 */
public class SSDaoImpl implements SSDao{
        /*
         * ObjectUtil工具类提供的方法能实现对数据库的CRUD操作
         * */
        ObjectUtilInfo> infoUtil = new ObjectUtilInfo>();
        ObjectUtilAccount> accountUtil = new ObjectUtilAccount>();

        /**
	 * 依据员工姓名查询员工信息
	 * @param name 员工姓名
	 * @return 有的话返回对象，没有的话返回null
	 */
	public Info queryByName(String name){
                // 请补全sql语句
                String sql = "select * from info where name=?";
                Info i = infoUtil.getOne(sql, Info.class, name); 
                return i;
        }

        /**
	 * 依据员工姓名查询评级等级
	 * @param name 员工姓名
	 * @return 有的话返评级等级，没有的话返回null
	 */
	public String queryLevel(String name) {
                // 请补全sql语句
                String sql = "select * from account where name=?";
                Account i = accountUtil.getOne(sql, Account.class, name); 
                if(i==null){
                        return null;
                }
                return i.getLevel();
        }

        /**
	 * 依据以下规则，检查员工评级等级是否正确
         * 90
	public Boolean checkLevel(String name) {
                String sql = "select * from account where name=?";
                Account i = accountUtil.getOne(sql, Account.class, name); 
                int score = i.getScore();
                String level = i.getLevel();
                // 请补全代码实现该功能
                if(level.equals("A") && score>=90 && score100){
                        return true;
                }else if(level.equals("B") && score>=80 && score89){
                        return true;
                }else if(level.equals("C") && score>=70 && score79){
                        return true;
                }else if(level.equals("D") && score>=60 && score69){
                        return true;
                }else if(level.equals("E") && score>=0 && score59){
                        return true;
                }
                return false;
        }

	/**
	 * 依据以下规则，更新所有的评级等级
	 * 90
	public void updateLevel() {
                // 请补全sql语句
                String sql = "update account set level=case when score>=90 and score=80 and score=70 and score=60 and score=0 and score;
                accountUtil.update(sql); 
        }

        /**
	 * 查询每个评级等级对应有多少人
	 * @param level 评级等级
	 * @return 返回人数
	 */
	public int queryNum(String level) {
                // 请补全sql语句
                String sql = "select * from account where level=?";
                ListAccount> li = accountUtil.getList(sql, Account.class, level); 
                return li.size();
        }
}

1+X 中级实操考试（id：3713）

public interface SSDao {
	/**
	 * 依据员工姓名查询员工信息
	 * @param name 员工姓名
	 * @return 有的话返回对象，没有的话返回null
	 */
	public Info queryByName(String name);

	/**
	 * 依据员工性别查询人数
	 * @param sex 员工性别
	 * @return 返回人数
	 */
	public int queryNum(String sex);
	
	/**
	 * 查看员工考勤是否正常
	 * 规则如下：
	 * 全天至少工作9个小时
	 * 
	 * 需求：
	 * 员工考勤正常的话，返回true，考勤异常的话，返回false
	 *
	 * @param name 员工姓名
	 * @param date 考勤日期，如：2023-03-10
	 */
	public Boolean check(String name,String date);

	/**
	 * 依据员工姓名查询其哪天上班时间最早
	 * @param sex 员工性别
	 * @return 返回最早的上班时间
	 */
	public String queryTime(String name);

	/**
	 * 更新所有人的年龄，男人加1，女人加2
	 */
	public void updateAge();
}

/**
 * 接口实现类
 */
public class SSDaoImpl implements SSDao{
    /**
	 * 依据员工姓名查询员工信息
	 * @param name 员工姓名
	 * @return 有的话返回对象，没有的话返回null
	 */
	public Info queryByName(String name){
        // 请补全sql代码
        String sql = "select * from info where name=?";
        Info info = JDBCUtil.getSingleResult(sql, Info.class, name);
        return info;
    }

    /**
	 * 依据员工性别查询人数
	 * @param sex 员工性别
	 * @return 返回人数
	 */
	public int queryNum(String sex) {
        // 请补全sql语句
        String sql = "select * from info where sex=?";
        ListInfo> list = JDBCUtil.getResult(sql, Info.class, sex); 
        return list.size();
    }

    /**
     * 查看员工考勤是否正常
     * 规则如下：
     * 全天至少工作9个小时
     * 
     * 需求：
     * 员工考勤正常的话，返回true，考勤异常的话，返回false
     *
     * @param name 员工姓名
     * @param date 考勤日期，如：2023-03-10
     */
	public Boolean check(String name,String date) {
        String sql = "select * from account where name=? and substr(begintime,1,10)=?";
        Account a = JDBCUtil.getSingleResult(sql, Account.class, name, date);
        boolean flag = false;
        SimpleDateFormat dfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date begintime = null;
        Date endtime = null;
        // 请补全代码实现该功能
        try {
            begintime = dfs.parse(a.getBegintime());
            endtime = dfs.parse(a.getEndtime());
            double between = (endtime.getTime()-begintime.getTime())*1.0/(1000*3600);
            if(between>=9){
                flag = true;
            }else{
                flag = false;
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return flag;
    }

    /**
	 * 依据员工姓名查询其哪天上班时间最早
	 * @param sex 员工性别
	 * @return 返回最早的上班时间
	 */
	public String queryTime(String name) {
        // 请补全sql语句
        String sql = "select * from account where name=? order by substr(begintime,12) limit 1";
        Account a = JDBCUtil.getSingleResult(sql, Account.class, name); 
        return a.getBegintime();
    }

	/**
	 * 更新所有人的年龄，男人加1，女人加2
	 */
	public void updateAge() {
        // 请补全sql语句
        String sql = "update info set age=case when sex='男' then age+1 else age+2 end";
        JDBCUtil.executeSql(sql); 
    }
}

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

相关推荐: 如何在2023年开启React项目

在这里，我想给你一个新的React项目入门的简要概述。我想反思一下优点和缺点，反思一下作为一个开发者所需要的技术水平，反思一下作为一个React开发者，每个启动项目都能为你提供哪些功能。最后，你将了解到针对不同需求的3种解决方案。 免责声明：从个人开发者的角度…