1.部署环境
(1). 准备jdk1.8
(2). 配置环境变量
(3). 测试是否配置成功
java -version
补充：打印出java 1.8即可
C:\Users\Administrator>java -version
java version "1.8.0_191"
Java(TM) SE Runtime Environment (build 1.8.0_191-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.191-b12, mixed mode)
2.基础知识
(1）.标识符
a). 命名规则：驼峰命名法（单个单词首字母大写，方法、参数、变量名小写），不可以用数字开头，严格区分大小写，不可以使用关键词命名。
(2）.数据类型
a). 基本数据类型
⒈.byte
2.short
3.char
4.int
5.long
6.float
7.double
8.boolean
(3）. 基本数据类型的转换
A：大范围---->小范围的转换需要加强制转换符
(4）. 变量
1.局部变量
1）. 作用在定义的方法内中
2）. 声明在方法内中
2.全局变量
1）. 作用在整个类中
2）. 声明在方法外类中
(5）. 运算符
1.算数运算符
A：+ 、 - 、 * 、 / 、 % 、 ++ 、 –
1.赋值运算符
A：= 、 += 、 -= 、 *= 、 /= 、 %=
2.关系运算符
A：> 、 < 、 >= 、 <= 、 == 、 !=
3.逻辑运算符
A：&& 、|| 、！
4.三元运算符
A：a>b ? c : d
(6）. 流程控制语句
1.if
2.switch
3.while
4.do-while
(7）. 循环语句
1.for
2.foreach
补充：break; （跳出当前循环）continue（直接执行下一次循环）
(8）. 重载和重写
A： 重载主要是区别在参数个数，参数顺序，其他保持一致；
B： 重写是子类和父类方法名返回值参数值完全相同，就实现了重写。
(9）. 方法
1. 减少重复代码，提高代码的复用性。
2. 格式： [修饰符] 返回值类型 方法名 （[形参列表]）{ //逻辑代码 [return 返回值] }
(9）. 递归
1. 自己调用自己，当满足自己设定的跳出循环条件而终止递归。
3.面向对象
(1). 面向对象和面向过程
A：面向对象主要是将注意力集中到一个整体上（例如洗衣机洗衣服）
B：面向过程主要是将注意力集中到一个过程中 （洗衣服的流程）
(2). 类和对象
A：类是一个比较抽象化的概念，包含方法，成员变量
B：对象是一个类的实例，对象可以通过 new [类名] 关键词创建， 一个类可以创建多个对象
(3). 构造方法
A：是通过创建对象的过程中被自动调用的（无参构造方法）
B：构造方法可以被重载
(4). 关键字
1. static
A. 在同一类下，如果用来修饰一个成员变量（不是私有属性），可以直接通过类.属性名 获取
B. 非静态的，可以通过对象名.属性名 对象名.方法名获取
C. 不可以修饰类和构造方法
D. 整个区域中共享的数据
E. 可用作静态代码块（只执行一次）
2. this 关键字
A. 构造函数中，使用this.属性名用于区分形参和全局变量的参数值
B. this.方法名（）的方法调用
3. super
A. super指代父类对象
B. super调用父类的构造方法
C. super调用必须放在第一行
4. final
A. 可以用作修饰全局变量静态常量,并且不可更改
B. 可以修饰方法，不能被重写
C. 可以修饰类，不能被继承
D. 使用final关键词定义常量
E. 静态常量值 参数名必须全部大写
(5). 面向对象三大特征
1. 封装
A. 将属性私有化，提高安全性
2. 继承
A. 提高代码的复用性，减少重复代码
B. 子类可以继承父类的方法（私有属性方法除外）
C. 单继承模式，一个子类只能有一个父
D. 一个类继承最顶端叫做基类或者超类，所有的超类叫做object
3. 多态
A. 编译时多态：重载，向上转型
B. 运行时多态：在运行过程中察觉的多态，向下转型
C. 父类的对象可以指向子类的实例，调用的是子类重写父类的实体方法
D. 向上转型： 父类的引用指向子类的实例
1. 优点：减少重复代码，提高代码的复用性
2. 缺点：父类的引用无法调用子类特有的属性和方法
3. 解决：向下转型
E. 向下转型：子类的引用指向父类的实例
1. 优点：可以使用子类的所有功能
2. 缺点：风险高，容易发生类型转换异常（ClassCastException）
3. 解决：instanceof 关键词判断即可
(6). abstract 抽象类
1. 抽取共同功能，提高代码复用性
2. 格式： abstract class 类型()
3. 抽象方法格式： abstract 返回值类型 方法名(形参)
4. 包含抽象类方法的类一定是抽象类
5. 抽象类不一定全是抽象方法
6. 抽象类不能被创建成对象
(7). interface 接口
1. 规范代码，提高可扩展性
2. 所有方法都是抽象方法，不写的话是默认加上的
3. 接口可以多实现
4. 只有全局常量和抽象方法
(8). 内部类
1. 创建： A a = new A(); B b = a.new B(); || B b = new A().new B();
2. 使用外部类属性，外部类.属性调用
4.JAVA常用类
(1). 一维数组
1. 排序： Array.sort();
2. 查找： Array.binarySearch();
3. 打印： Arrays.toString();
4. 复制： Arrays.copyof();
(2). Integer 常用API
1. intValue(); 将Integer转成int
2. parseInt(); 将Integer转成int
3. toString(); 将int类型数据转成String字符串
4. compareTo(); 比较大小，大返回整数，小于返回负数，相等返回0
5. Integer.valueOf(); 将int转成integer类型对象
(3). String 常用API
1. equals() 比较内容
2. equalsIgnoreCase() 忽略大小写比较是否相同
3. contains() 是否包含参数字符串
4. indexOf("/") 第一次出现
5. substring(param.lastIndexOf("/")+1);截取指定位置
6. replace(‘a’, ‘b’) 替换指定字符串，替换所有的
7. toUpperCase() 全部转为大写
8. toLowerCase() 全部转成小写
9. trim() 去掉字符串前后的空格，中间的去不掉
10. charAt(); 字符串截取出指定的下标开始
(4). StringBuffer 常用API
1. append(“abckjc”); 追加
2. insert(2, “mmm”); 插入
3. delete(2, 4); 删除，参数1是起始下标，参数2是结束下标，左闭右开
4. reverse(); 逆顺反转
补充：String StringBuffer StringBuilder 区别
1. String ：长度不可变，
2. StringBuffer： 长度可变，线程安全，速度慢
3. StringBuilder：长度可变，线程不安全，速度快
(5). Charcter 常用API
1. isLetter('a'); 判断是否为字母
2. .isLetter('a'); 判断是否为小写字母
3. isUpperCase('A'); 判断是否为大写字母
4. toLowerCase('D'); 将大写字母转成小写字母 如果本身是小写字母 则转换完还是小写字母
5. toUpperCase('f'); 将字母专程为大写字母
(6). 时间常用API
1. Date() 类 getTime()；得到毫秒
2. SimpleDataFormate（yyyy-MM-dd HH:mm:ss） 类 format() 返回按格式解析的String类型的值
3. Calendar 接口常用：
1 get(Calendar.YEAR); //年
2 get(Calendar.MONTH);// 默认是当前月份减一 从0开始的
3 get(Calendar.DAY_OF_MONTH); //日
4 get(Calendar.DAY_OF_WEEK);
5 Calendar calendar = Calendar.getInstance(); //获得实例
6 Date date = calendar.getTime();
5.异常类
- 捕获异常：try-catch-finally捕获异常，保证程序流程的运行
- 自定义异常 继承RuntimeEx
6.集合
(1). Collection
1. 添加元素：
add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。
2. 删除元素：
remove(Objectobj);
clear();//清空集合
3. 判断元素：
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4. 获取个数：
size();
(2). List （元素是有序并且可重复的）
1. ArrayList
1. 增：add() ; addAll(0,list2)
2. 获取： get(index)
3. 修改：set()
2. LinkedList（用的比较少，归纳一下API）
1. 增： offFirst(); offLast();
2. 获取: peekFirst(); peekLast();
3. 删除：pollFirst(); pollLast();
4. 压栈：push();
5. 弹栈：pop();
6. 逆序输出：linkedList.descendingIterator()
(3). Set（元素是无序并且不重复的）
1. 添加： add()
2. 删除：remove();
3. 遍历：set keySet();
1. foreach ： for (String str: set)
2. 迭代： Iterator iterator = set.iterator();
(4). Map（键值对的形式）
-
添加：put(k,v)
-
删除：remove(k)
-
判断：
-
constainKey(k)// 找键
-
containsValue(value)//判断值是否存在
-
isEmpty();//判断是否为空
获取
-
size(); //获取集合的长度
-
get(k) 通过键获取值
-
-
遍历：set entrySet（）
```java
1.foreach：for(Map.Entry<String, String> entry : set){
String mapKey = entry.getKey();
String mapValue = entry.getValue();
System.out.println(mapKey+":"+mapValue);
}
```
2.常规遍历： keySet() values()
3.迭代：
```java
Iterator<Entry<String, String>> iterator =set.iterator();
while (iterator3.hasNext()) {
Entry<String, String> kEntry=iterator .next();
System.out.println(kEntry);
}
```
7.Java I/O
(1). file类
1. 常用API
1. exists() 判断文件是否存在
2. delete() 删除文件
3. isFile() 是否是文件
4. isDirectory() 是否是目录
5. getPath() 路径
6. getName() 名称
7. length() 文件大小，无法判断目录和文件夹
8. createNewFile() 创建文件
9. mkdir() 创建一层文件夹
10. mkdirs() 创建多层文件夹
11. File(String path) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例
12. File(String path,String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
13. File(File file,String child)
14. list() 返回一个字符数组，这些字符串目录中的文件和目录。
15. list(FileNameFilter) 返回一个字符串数组，这些字符串指满足指定过滤器的文件和目录。
(2). 流类
1. 字符流
A：字节流：InputStream 、 OutputStream
B：字符流：Reader 、 Writer
2. 缓冲流
A：字节流：BufferedInoutStream BufferedOutputStream
B：字符流：BufferedReader 、 BufferedWriter
3. 转换流
A：字节转字符： InputStreamReader 继承自Reader （String接收数据，返回值！=null）
B：字符转字节： OutputStreamWriter 继承自Wriiter
C：demo:
BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(new FileInputStream( new File("E:\ceshi.wmv"))));
BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("E:\aa\demo\ceshi.wmv"))));
String string=null;
while((string=bufferedReader.readLine())!=null){
bufferedWriter.write(string);
}
bufferedWriter.flush();
//关闭流
4. 对象流
5. 打印流
PrintStream 字节打印流 可以new可以通过System.out得到
6. 内存流
7.随机读写流（在线程中使用较多）
8.Java 多线程
1.线程
A：线程没有独立的空间，多个线程是竞争关系，抢占CPU资源
B：线程的创建：
1. 继承Thread
2. 重写run方法
3. 启动线程
4. Thread.currentThread().getName() 获取当前线程的名字
补充创建方法二：
1)、实现Runnable接口
2)、重写run方法
3)、创建线程对象，将共享对象添加到里面去
4)、启动线程
C：生命周期：新建 – 就绪 – 运行 – 阻塞 – 死亡
- 进程
A：进程是应用程序，至少包含一条线程。
B：进程有独立的空间，崩溃不会影响其他程序。 - 线程调度
A：join() 插队，阻塞指定的线程等到另一个线程完成以后再继续执行
B：sleep();需要设置睡眠时间
C：yield();礼让，当执行到这个方法时，会让出cpu时间，立马变成可执行状态 - 打断线程的终止方式
A：stop() 方法 ，会执行不到特定代码
B：interrupt()，只能中断正在休眠的线程，通过抛异常的方法中断线程的终止。
9.Java 网络编程
(1). 参考模型
1. tcp/ip协议 （tcp 、udp 、ip）
1. tcp特点：面向连接，数据安全可靠，效率低，传输数据大小无限制。
2. upd特点：面向无连接，数据安全不可靠，效率高，数据大小不超过64kb
3. IP：
1. getLocalHost()， 返回值是InetAddress，得到本机的主机名和地址
2. getByName(ip), 返回值是InetAddress，有参数，可以写ip，网址，得到指定的主机
3. getHostAddress() 得到主机的地址
4. getHostName() 得到指定的主机名
4. tcp:
1. Socket服务器中获得输入输出流
2. 转换流呈现字符的方式展示给聊天端和服务器端
5. udp特点：面向无连接，支持一对一，一对多，多对多的交互通信
10.Java 反射
(1). 反射机制
1. 反射是将类中的属性，方法，构造方法等解剖成一个个小的对象，并且能够调用。
2. 在一个类中，可以创建另一个类的对象，调用其属性和方法
3. Class class=Class.forName(包名.类名)，每一个类都有唯一的一个类对象，这个类对象可以的得到类中的所有信息。
4. API使用：
1. getConstructor(null); 得到无参构造方法，返回Constructor
2. getConstructors(); 得到所有构造方法，返回Constructor[]数组
3. getMethod(); 得到普通的方法，返回Method，指定方法名
4. getMethod("eat", null); 无参、无返回值、非私有的方法。
5. getMethod("play", String.class); 有参、无返回值。非私有方法。参数一，方法名。参数二，参数类型.class
6. getMethods(); 得到子类和父类所有普通的方法，返回Method[]数组
7. getDeclaredMethods(); 得到自己类的所有方法，包括私有的，返回Method[]
8. getFields(); 得到public所有属性，返回Field[]
9. getDeclareFields(); 得到所有属性，包括私有的，返回Field[]
5. 反射提高了程序的灵活性和扩展性，降低了耦合性，提高了自适应能力
6. 反射会带来性能问题以及代码维护问题。
11.Java 日期类
(1). Calendar
1.常用API
1.calendar Calendar.getInstance() //获取实例
2.calendar.get(属性类)
3.calendar.set(year, month, date, hourOfDay, minute, second )
例如：
Calendar calendar = Calendar.getInstance();
// 如果想设置为某个日期，例如 2018-02-15 23:59:59 （设置过程中月份需要 - 1）
calendar.set(2018, 1, 15, 23, 59, 59);
4.Date calendar.getTime() //获取时间 Sat May 08 10:31:21 CST 2021
5.Date calendar.add(属性类 , value)
例如：
Calendar calendar = Calendar.getInstance();
calendar.setTime(calendar.getTime()); //当前日期
calendar.add(Calendar.YEAR,1);
System.out.println(calendar.getTime());
*************控制台打印*************
Sun May 08 10:34:03 CST 2022
补充：添加方法会将不存在的日期视为最后一天
calendar.set(2021,0,31);
System.out.println(calendar.getTime()); 1.31
calendar.add(Calendar.MONTH,1);
System.out.println(calendar.getTime());2.28
*************打印************
Sun Jan 31 10:38:52 CST 2021
Sun Feb 28 10:38:52 CST 2021
总结：
1.add计算方法，在calendar.add(Calendar.MONTH,1);（计算月份）过程中，如果当前时间是3月31日， 增加一个月之后，则会变成4月30日。
2.追溯到几日前，几月前，几年前，在使用add方法时，传递负值即可。
------------------------------------------------------------------------------
6.calendar.getMaximum(Calendar.HOUR_OF_DAY) // 23 获取最大的属性值
7.calendar.getMinimum(Calendar.DATE) // 1 获取最小的属性值
8.获取本周时间段
举例：2021-5-8 11:30
Calendar calendar = Calendar.getInstance();
calendar.setFirstDayOfWeek(Calendar.MONDAY); //设置这周第一天是从星期一开始的
calendar.set(Calendar.DAY_OF_WEEK,Calendar.SUNDAY); //设置周日
String endTime = calendar.getTime().toString();
calendar.set(Calendar.DAY_OF_WEEK,Calendar.MONDAY); // 设置周一
String startTime = calendar.getTime().toString();
System.out.println("开始："+startTime+"结束："+endTime);
***********打印**************
开始：Mon May 03 11:30:39 CST 2021 结束：Sun May 09 11:30:39 CST 2021
9.calendar.getActualMaximum（Calendar.DAY_OF_MONTH）// 获取本月最后一天
2.属性类 （2021-5-8 10:45）
Calendar.YEAR // 2021
Calendar.MONTH // 4 月份取值需要+1 设置需要-1
Calendar.DATE // 8 日期
Calendar.HOUR // 10 几点 12小时制度
Calendar.HOUR_OF_DAY // 10 24小时制度
Calendar.DAY_OF_MONTH // 8 当天
Calendar.MINUTE // 45
Calendar.SECOND // 11
Calendar.WEEK_OF_MONTH // 2 本月第几周
Calendar.WEEK_OF_YEAR // 19 本年第几周
Calendar.DAY_OF_WEEK) -1 // 6 本周第几天
*******总结********
1）常用属性
Calendar.YEAR 、Calendar.MONTH 、Calendar.DAY_OF_MONTH、 Calendar.HOUR_OF_DAY 、Calendar.MINUTE、 Calendar.SECOND
2) 对于月份的设置需要注意，设置的时候需要-1 ， 获取的时候需要+1
3）对于周的某一天设置也需要 - 1
(2). jdk8 Local类库
1.LocalDate
1.LocalDate LocalDate.now() //返回当前年月日 2021-05-08
补充：设有全局 LocalDate today = LocalDate.now();
1).getYear() int //获取年
2).getMonth() Month //获取月份（英文）
3).getMonthValue() int //获取月份（值）
4).getDayOfMonth() int //获取当月第几号
5).getDayOfWeek() DayOfWeek //获取当前周几（英文）
System.out.println("今天日期：" + today);
//获取年年，月，日，周几
System.out.println("现在是哪年:"+today.getYear()); // 2021
System.out.println("现在是哪月:"+today.getMonth()); // MAY
System.out.println("现在是哪月(数字):"+today.getMonthValue()); // 5
System.out.println("现在是几号:"+today.getDayOfMonth()); // 8
System.out.println("现在是周几:"+today.getDayOfWeek()); // SATURDAY
*************打印**************
今天日期：2021-05-08
现在是哪年:2021
现在是哪月:MAY
现在是哪月(数字):5
现在是⼏号:8
现在是周⼏:SATURDAY
6).plusYears() LocalDate //加减年份
补充：加减年份之后，在不重新赋值的情况下，值是不会被改变的
LocalDate changeDate = today.plusYears(-1); //赋值给一个变量
System.out.println("加后是哪年年:"+changeDate.getYear());
System.out.println("旧的是哪年年:"+today.getYear());
**********************************
加后是哪年年:2020
旧的是哪年年:2021
7).withYear() LocalDate //修改年份
8).minusYears() LocalDate //当前对象减去指定的年的年数
时间比较：
9).compareTo() int//当前对象减去指定的年的年数返回值
10).isBefore() LocalDate //比较当前对象日期是否在other对象之前
11).isAfter() LocalDate //比较当前对象日期是否在other对象之后
TemporalAdjusters提供的API
12).with() LocalDate //通过TemporalAdjusters参数获取各种特殊的日期
1.TemporalAdjusters.firstDayOfMonth() // 本月第一天
2.TemporalAdjusters.firstDayOfYear() //本年第一天
3.TemporalAdjusters.firstDayOfNextMonth()// 下个月第一天
4.TemporalAdjusters.firstDayOfNextYear() //本年第一天
5.TemporalAdjusters.lastDayOfMonth() //本月最后一天
6.TemporalAdjusters.lastDayOfYear() //本年最后一天
7.TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY) //日期范围内第一个周一
8.TemporalAdjusters.lastInMonth(DayOfWeek.MONDAY) // 日期范围内最后一个周一
LocalDate f1 = today.with(TemporalAdjusters.firstDayOfMonth()); // 本月第一天
LocalDate f2 = today.with(TemporalAdjusters.firstDayOfYear()); //本年第一天
LocalDate f3 = today.with(TemporalAdjusters.firstDayOfNextMonth()); // 下个月第一天
LocalDate f4 = today.with(TemporalAdjusters.firstDayOfNextYear());//本年第一天
LocalDate f5 = today.with(TemporalAdjusters.lastDayOfMonth()); //本月最后一天
LocalDate f6 = today.with(TemporalAdjusters.lastDayOfYear()); //本年最后一天
LocalDate f7 = today.with(TemporalAdjusters.firstInMonth(DayOfWeek.MONDAY)); //日期范围内第一个周一
LocalDate f8 = today.with(TemporalAdjusters.lastInMonth(DayOfWeek.MONDAY));// 日期范围内最后一个周一
System.out.println(f1); // 2021-05-01
System.out.println(f2); // 2021-01-01
System.out.println(f3); // 2021-06-01
System.out.println(f4); // 2022-01-01
System.out.println(f5); // 2021-05-31
System.out.println(f6); // 2021-12-31
System.out.println(f7); // 2021-05-03
System.out.println(f8); // 2021-05-31
2.LocalDate LocalDate.of(int year, int month, int dayOfMonth) //设置时间
2.LocalTime
1).从区别上来说，LocalTime和LocalDate几乎相同，只不过LocalTime是表示的时分秒。
2).常用API
1.withNano(0) //去掉毫秒值
2.withHour(0) //设置时分秒为0
3.of() //构造时间
4.parse() //构造时间
构造时间
//获取当前时间 含有毫秒值 15:55:00.702
LocalTime now = LocalTime.now();
//获取当前时间 去掉毫秒值 15:55
LocalTime now1 = LocalTime.now().withNano(0);
//00:55:00.702 提供了把时分秒都设为0的方法
LocalTime now2 = LocalTime.now().withHour(0);
//构造时间 00:20:55
LocalTime time1 = LocalTime.of(0,20,55);
//构造时间 05:43:22
LocalTime time2 = LocalTime.parse("05:43:22");
3.LocalDateTime
1).从区别上来说，整合了LocalDate+LocalTime 用于完整的展示年月日时分秒，可以实现精准运算。
2).常用API同上
4.DateTimeFormatter
1).与SimpleDateFormat 相比 ， 线程更安全
2).常用API
1.ofPattern() //装载解析格式 yyyyMMdd
2.format() //传入时间对象 进行解析
举例
LocalDateTime localDate = LocalDateTime.now();
DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
System.out.println(format);
//String 类型转成LocalDateTime
String str = "2021/11/12 15:33:36";
LocalDateTime parse = LocalDateTime.parse(str,format);
System.out.println(parse); //2021-11-12T15:33:36
//LocalDateTime转字符串
String format1 = localDate.format(format);
System.out.println(format1); // 2021/05/08 16:21:00
//LocalDateTime转LocalDate
LocalDate localDate1 = localDate.toLocalDate();
System.out.println(localDate1); //2021-05-08
5.ZonedDateTime
1).所有原理都同上
举例：
//获取当前时区
ZonedDateTime now2 = ZonedDateTime.now();
System.out.println(now2); // 2021-05-08T16:25:42.610+08:00[Asia/Shanghai]
//解析时区为字符串
ZonedDateTime now = ZonedDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yy HH:mm:ss");
String strDate = now.format(formatter); //05/08/21 16:27:07
//时区计算 +1 天
now = now.plusDays(1);//当前日期 加上1天
String strDate2 = now.format(formatter);
System.out.println(strDate2);//05/09/21 16:27:07
8530
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
