Java笔记01

• 当你开口说话的时候，你说的话必须比你的沉默更有价值才行，否则闭嘴！

• 无序列表实心圆与空心圆问题 Ctrl +Shift+] 可打出实心圆 Enter换行或者再敲一个实心圆后按下Tab(缩进)键会变成空心圆

• 解决start.spring.io不能访问 使用阿里云链接替代 阿里云https://start.aliyun.com/ 地址直接替代

• Ctrl+R：查找并替换

• Ctrl+D：复制整行

• Ctrl+B：提示该方法中需要哪些参数

• Ctrl+Alt：同时按住点击鼠标查看实现类

• Ctrl+H：查看类的继承关系

• Ctrl+Alt+T：try catch捕获异常

• Alt：同时复制多行

• iter：加强for循环

• Ctrl+Shift+N：搜索 find in path

• 2、构造方法

  构造方法是为了创建对象用的，在创建对象的时候调用构造方法，构造方法的真正执行是在创建对象的时候使用。
  构造方法：用了方法的重载，方法名相同，方法参数类型不同，与方法的返回值无关。
  

• 可变形参只能出现在形参列表中的最后一个位置，且形参列表中只能有一个可变形参，可变形参前面可以有多个普通形参。把可变形参当作数组来用。

• 通过new创建的对象，均是在堆内存中开辟一个地址空间。

• vscode快捷键：查看webpack或xxx版本命令：npm view webpack或xxx versions
  

SQL语句

    SELECT
    	* 
    FROM
    	t_user_position 
    WHERE
    	id = 160 
    	
    	
    SELECT
    	doc.*,p.position
    FROM
    	t_user_position up
    	LEFT JOIN t_disinfect_operate_comment doc ON up.id = doc.user_position_id
    	LEFT JOIN t_position p ON up.position_id=p.position_id
    	
    	
    SELECT
    	doc.*,
    	p.position 
    FROM
    	t_disinfect_operate_comment doc
    	LEFT JOIN t_user_position up ON doc.user_position_id = up.id
    	LEFT JOIN t_position p ON up.position_id = p.position_id


    2022年6月24日 晓欣
    SELECT * FROM `t_disinfect_object`;
        
    select * from t_position t  where id = '32' ;
    
    select count(1) from t_position t ;
    
    select * from t_disinfect_object t where t.postion_id = 32
    
    update t_disinfect_object t set t.postion_id = 32 where id in (52,69,70,71,72,73,74);
    
    select * from t_disinfect_object t where t.id in (52,69,70,71,72,73,74);
    
    SELECT
    	doc.*,
    	p.position 
    FROM
    	t_disinfect_operate_comment doc
    	LEFT JOIN t_user_position up ON doc.user_position_id = up.id
    	LEFT JOIN t_position p ON up.position_id = p.position_id
    WHERE up.id = 2986
    	
    	
    SELECT doc.*, p.position_id, p.position FROM t_disinfect_operate_comment doc LEFT JOIN t_user_position up ON doc.user_position_id = up.id AND up.is_delete = 0 LEFT JOIN t_position p ON up.position_id = p.position_id AND p.is_delete = 0 WHERE doc.is_delete = 0 ORDER BY up.id desc LIMIT 0 , 10
    
    SELECT * FROM t_user_position WHERE id = 2986
   
    ------------------------------
    select * from t_position t  where id = '32' ;
    
    select count(1) from t_position t ;
    
    select * from t_disinfect_object t where t.id in (select disinfect_object_ids from t_position where id = '32');   
    
    update t_disinfect_object set position_id = 32 where id in  (52,69,70,71,72,73,74)
    
    select * from t_disinfect_object t where t.id in (52,69,70,71,72,73,74)

    SELECT
    	m.*,
    	m.id AS m_id,
    	m.user_id AS m_user_id,
    	m.user_position_id AS m_user_position_id,
    	m.photo,
    	m.comment_time AS m_comment_time,
    	m.disinfectant_component,
    	m.is_tostandard_disinfect,
    	m.is_nowdate_disinfect,
    	m.is_paste_label,
    	m.create_user AS m_create_user,
    	m.remark AS m_remark,
    	p.position_id,
    	p.position 
    FROM
    	t_disinfectant_match_comment m
    	LEFT JOIN t_user_position up ON m.user_position_id = up.id 
    	AND up.is_delete = 0
    	LEFT JOIN t_position p ON up.position_id = p.position_id 
    	AND p.is_delete = 0 
    WHERE
    	m.is_delete = 0

1、可变形参

• 可变形参只能出现在形参列表中的最后一个位置，且形参列表中只能有一个可变形参，可变形参前面可以有多个普通形参。把可变形参当作数组来用。
  
  
  

2、构造方法

• 构造方法是为了创建对象用的，在创建对象的时候调用构造方法，构造方法的真正执行是在创建对象的时候使用。

• 构造方法：用了方法的重载，方法名相同，方法参数类型不同，与方法的返回值无关。

3、成员变量和局部变量

4、this关键字

5、spring cloud

1、Map集合的两种遍历方式

Map<k,v>集合的特点：键值对、键唯一、根据键取值、无序（没有索引）。

// 第一种遍历方式：获取Map集合中所有的键，存储到Set集合中。
Set<Integer> set = map.keySet();  // 键集
for(Integer key : set){
    String value = map.get(key);  // 通过键获取值
    System.out.println(key + ":" + value);
}
// 迭代器遍历：获取set集合的迭代器对象
Iterator<Integer> iterator = set.iterator();
while(iterator.hasNext()){
    Integer key = iterator.next();
    String value = map.get(key);
    System.out.println(key + ":" + value);
}

// 第二种遍历方式：获取Map集合中所有的键值对对象的集合（Set集合）。
Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
for(Map.Entry<Integer,String> entry : entrySet){
    Integer key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + ":" + value);
}

2、List集合嵌套Map集合

// Map<String String> map = new LinkedHashMap<>();  // Map集合的有序遍历
Map<String String> map = new HashMap<>();  // 父父new子
map.put("第一顺位","宸宸");
map.put("第二顺位","雨宸");

List<Map<String String>> list = new ArrayList<>();
list.add(map);
for(Map<String String> map : list){  // 快捷键 增强for.for  100.fori
    Set<String> set = map.keySet();
    for(String key : set){
        System.out.println(key + ":" + map.get(key));
    }
}

3、Set集合：HashSet

// Set集合无序（没有索引，没有get()和set()方法）、不可重复，通过迭代器遍历
Set<String> set = new HashSet<>();
// 迭代器遍历
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
    System.out.println(iterator.next());
}

// 普通for循环无法遍历，因没有索引
// 增强for循环可以遍历
for(String s : set){
    System.out.println(s);
}

// List集合有序可重复

4、字符串的常用方法

// concat()方法：将指定的字符串连接到该字符串的末尾，拼接
String s = "qa,zw,sx";
System.out.println(s.concat("宸宸"));
// indexOf()方法：返回指定子字符串第一次出现在该字符串内的索引
System.out.println(s.indexOf("a"));
// substring(beginIndex)方法：返回一个子字符串，从beginIndex开始截取
System.out.println(s.substring(3));
System.out.println(s.contains("a"));
System.out.println(s.replace("a","z"));
System.out.println(s.toUpperCase());
// trim()方法：去除收尾空格
System.out.println(s.trim());
// split()方法：根据给定的内容，切割字符串，返回字符串数组
String[] strs = s.split(",");
for(String str : strs){
    System.out.println(str);
}
// equals判断字符串内容是否相同，严格区分大小写
System.out.println(str1.equals(str2));
// equalsIgnoreCase判断字符串内容是否相同，忽略大小写
System.out.println(str1.equalsIgnoreCase(str2));

5、Iterator迭代器遍历集合

6、List-LinkedList集合方法

7、Calender日历类

8、多态：父父new子

• 编译看左边，运行结果看右边

多态：父父new子（向上转型）Percent p = new Children();
对于成员方法：编译看左边，运行结果（子类的）看右边。
对于成员变量：编译运行都看左边。也就是成员变量没有多态特性。
静态方法和变量：编译运行都看左边，同成员变量一样。

// 多态：父类引用指向子类对象
Animal animal = new Cat();

子类的同名的 类变量、静态方法、静态变量 不会覆盖父类。 调用p的这些属性找的是父类的属性
子类同名的类方法覆盖父类。 调用p的方法找的是子类的方法。
调用p的属性(变量或方法)会检查父类Percent是否存在此属性，如果不存在（只有子类有）或者父类属性用private修饰则编译不通过。

9、final关键字

10、抽象类

• 抽象方法一定要存在于抽象类中，（抽象类中也可以写普通方法），一定要让子类去重写抽象方法的。
• 抽象类中的抽象方法要全部被重写。

11、方法的重载与重写

• 不管是子类的有参构造还是无参构造都会隐性的访问父类的无参构造，若没有无参构造则访问父类的有参构造。

Son son = new Son(); // new Son()相当于访问类Son()的无参构造

• 构造方法的访问规则：父类的构造方法是被private关键字修饰的，则不能被继承。（private私有的，只能在当前类中生效的私有方法，出了当前类需要使用get/set方法）
• 私有成员变量的访问规则：子类只能继承，但是子类不能使用父类的私有成员变量（因为访问不到父类的私有成员变量）。private int age = 17;
• 普通成员变量访问规则：先在子类中找，如果找到就使用子类的，找不到就继续去父类中找。

12、this关键字

• this指当前对象的引用（看作当前对象）；super指父类对象的引用（看作父类对象）。

• 非静态方法可以调用静态方法，但静态方法不能调用非静态方法。（因静态方法先加载到内存中）。注意：静态方法中不能出现this关键字。

13、RestTemplate服务模板

14、Eureka服务注册与发现

15、Ribbon负载均衡

16、Hystrix服务熔断

17、Zuul路由网关

18、SpringCloud config配置

19、ElasticSearch

20、Restful风格操作

21、Vue的MVVM模型

22、计算属性computed

23、Node.js淘宝镜像

24、常见Dos命令

25、RabbitMQ核心组成部分

26、跨域

27、ES6

• let和const

• 模板字符串

• 箭头函数

• 对象简写

• 对象解构

• 传播操作符…

• 数组map

• 数组reduce

28、Docker

29、Java基础

30、自定义注解

31、Java反射机制

32、网络编程