public class TestShowMsg {

    public static void main(String[] args) {

        ShowMsg sm = new ShowMsg();
        Generic3<Integer> g = new Generic3<>();
        sm.showFlag(g); // null 这里null 是因为这时候Generic3的对象没有任何值为空
        g.setFlag(20); // 为Generic3中的flag赋值20
        sm.showFlag(g); // 20 将Generic3对象g传入
       /*
        Generic3<Number> g2 = new Generic3<>();
        sm.showFlag(g2);
        g.getFlag(50);
        sm.showFlag(g);
        这里都报错的原因是泛型只确定了你要使用的类型或者类型识别，不考虑继承关系，只看类型！！
*/

        System.out.println("=============================================");
        Generic3<Integer> g2 = new Generic3<>();
        sm.showFlag(g2); 
        g2.setFlag(30); 
        sm.showFlag(g2); 
        Generic3<Number> g3 = new Generic3<>();
        sm.showFlag2(g3); // 因为showFlag2(Generic3<?> generic3)的参数泛型是? 任意类型 所以这里不会报错
        g3.setFlag(50);
        sm.showFlag2(g3);


    }
}
class ShowMsg{
    public void showFlag(Generic3<Integer> generic3){  // 这里传入的参数是Generic3对象 泛型类型定义为Integer
        System.out.println(generic3.getFlag());
    }

    // ? 无界通配符
    public void showFlag2(Generic3<?> generic3){  // 不能确定传入的是什么类型时 泛型类型定义为? 任意类型都可以
        System.out.println(generic3.getFlag());
    }
}

class Generic3<T>{
    private T flag;

    public T getFlag() {
        return flag;
    }

    public void setFlag(T flag) {
        this.flag = flag;
    }
}

老师，我这样理解对吗？

然后还有两个问题：

1、为什么传入参数Generic3<T> generic会报错？  我创建的泛型类是Generic3<T>，T不是表示简单的JAVA类么，

为什么传参时不可以使用？

public void showFlag(Generic3<T> generic3){  
    System.out.println(generic3.getFlag());
}

2、T是简单JAVA类 ?是任意类型 那这里用?作为传入参数的泛型，会不会出现超出T表示的范围？

public void showFlag2(Generic3<?> generic3){  
        System.out.println(generic3.getFlag());
    }

public class Test {
    public static void main(String[] args) {
        Generic2 g = new Generic2();
        g.setName("lili");
        g.setName(123);
        String name = g.getName("lili"); // 报错
        Object name1 = g.getName("lili"); // 没有报错

        Integer flag = Generic2.getFlag(222);
        Generic2.setFlag("dd");
    }
}

class Generic2<N>{

    // 非静态方法
    public<T> void setName(T name){
        System.out.println(name);
    }
    public<T> T getName(T name){
        return name;
    }

    // 静态方法
    public static <T> void setFlag(T flag){
        System.out.println(flag);
    }
    public static <T> T getFlag(T flag){
        return flag;
    }

}

报错：

java: 不兼容的类型: java.lang.Object无法转换为java.lang.String

老师，如果类和方法都定义了泛型，类是<N>，方法是<T> 

String name = g.getName("lili"); // 报错

1、为什么这句会报错，如果把String name改成Object name就不会报错。把类改成Generic2<T>，方法和类都是T，但还是报错，这是为什么？看报错的内容觉得能明白，但是想把原因写出来记笔记，又不知道该怎么写

2、静态方法的泛型和类的泛型没有关系是么？

String s = "one" + 'on';  为什么会报错呀老师

关于实例化TreeSet

Set<String> set = new TreeSet< >

前面为什么使用Set，而不是用TreeSet,

我是否可以理解为：

因为Set接口下的TreeSet， HashSet没有自己独有的方法，所以这里用Set？

像List接口中，若使用ArrayList中独有的方法，则必须用

ArrayList<String>= New ArrayList< >?

另外，这里Set和TreeSet是否是一种继承关系，前面写TreeSet，即

TreeSet<String> set = new TreeSet<>

也不会报错？

谢谢

启动了tomcat 后正常输入账号密码，点击登录没有反应。

老师，这里为什么报错了呢？return那个地方？

老师这种操作最早是在哪节课讲的，意思是把第一个实例出来的对象作为第二个的实参吗，我有点懵。能解释下流程吗

老师，如果全外连接，是否需要保证两个连接的投影列都是一致的，我尝试了添加投影列，发现要保证数量一样多，但是不同列的时候只会显示左边的列，还有什么要注意的吗

(select e.last_name,d.department_name,e.dept_id from employees e LEFT OUTER JOIN departments d on e.dept_id = d.department_id) union (select e.last_name,d.department_name，d.location_id from employees e RIGHT OUTER JOIN departments d on e.dept_id = d.department_id)

报这个错误

No suitable driver found for jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8

不能连上数据库

这节课听得很迷糊，如果本地仓库和远程仓库都修改了同样的部分，是按哪个合并的？

老师，对于等值连接，有两种等效的操作。使用表1表2笛卡尔乘积，后接一个where；和在表1后使用INNER JOIN表2 ；请问两者的执行效率是相同的吗？因为直观的理解，假设表的大小为一万，总感觉第一种方法是先得到了一个一亿条的表，再用where条件进行筛选返回最终数据。

2021.6.29  SpringBoot的版本已经到了2.5.2     我百度了一下说

  数据校验的依赖不自动导入了  老师讲解的是2.2版本 所以希望可以添加一个视频给后面的学生提示一下版本的差异~~~

老师，只能用case也太不灵活了吧，如果想对区间操作（如对学生的成绩score根据区间返回优、良、中、差），该怎么操作呢? 用if也不方便，需要括号套括号（如下），要是有if……else if这样的写法就好了。

select *,

if (score >= 90, "优秀",

if (score >= 80, "良好",

if (score >= 60, "一般", "差")

 )) as '评价'

from students;

老师 a  变量 和  for便利循环那些 他们到底怎么样运行的？我怎么看不出便利循环在干嘛

A01= time.time() #起始位置

a=""

for i in range(0,1000000):

    a+="sxt"

A02=time.time() #

print("运行时间:"+str(A02-A01))