Java SE基础篇总结

一、基础语法部分

1.基础环境搭建部分

		1.1JDK环境配置
			（1）官网下载1.8【居多】
			（2）安装JDK并配置"环境变量"			
		1.2IDE配置:eclipse
		1.3几个概念
			（1）JDK：开发环境
			（2）JRE：运行环境
			（3）JVM：虚拟机

2.变量

		2.1变量：存储运行时数据
		2.2声明变量
			(1)声明并初始化：int i = 10;
			(2)先声明后初始化：int i;  i=10;
			(3)声明多个：int i=10, i2;
		2.3变量的命名
			(1)可以使用的符号:$、_、英文字母、数字
			(2)不可以以数字开头
			(3)驼峰命名：
				a.大驼峰[每个单词的首字母大写]：类名
				b.小驼峰[除第一个单词，每个单词的首字母大写]：变量名、方法名
				c.包名：全小写
		2.4变量的使用注意事项:变量必须"声明"并"初始化"后才能使用  

3.八大基本类型[byte\short\int\long\float\double\boolean\char]

		整型数据
		3.1byte：-128~127
		3.2short：-30000~30000
		3.3int
			(1)-21亿~21亿
			(2)数字的直接量是int类型的
		3.4long
			(1)long l = 1000L;   
			(2)时间戳
		浮点型数据
		3.5float
			(1)float f = 100.1F;
			(2)小数精确度的问题
		3.6double
			(1)直降量是double类型的
			(2)小数精度的问题
		3.7boolean：true|false
		3.8char
			(1)声明：char c = 'x';
			(2)0~60000+
		3.9使用的注意事项
			(1)由小到大转型：byte->short|char->int->long->float->double; 比如：long l = 1000; 
			(2)由大到小转型：强转;  比如：long l = 1000L;  int i = (int)l;
				a.强转溢出
				b.精度缺失
			(3)int类型的数据可以直接赋值给byte、short、char，但是不能超过范围
			(4)浮点型计算时不能精确的表示1/10，进行小数精确计算时不能使用浮点数据，应该使用BigDecimal
			(5)在数据运算的时候，会默认转换成范围较大的类型  int i = (int)(0.5 + 10 + ...);

4.算数运算符[+、-、、\、=、+=、-=、=、=、%、++、–]

		4.1%：取模
		4.2+=、-=、*=、\=
			(1)i+=5; ---> i = i+5;
			(2)中间不能有空格
		4.3++、--
			(1)在前：++a,先加后赋值 	int a = 10; int b = ++a;  b->11
			(2)在后：a++,先赋值后加		int a = 10; int b = a++;  b->10

5.比较运算符[>>===<=<]

		5.1三目运算符：条件? "结果1":"结果2";

6.逻辑运算符[&&&|||!]

		6.1短路&&:与运算只要有一个为false，那么结果为false，所以当第一个条件为false时，后面是不需要执行的
		6.2短路||:或预算只要有一个为true，那么结果就是true，所以当第一个条件为true时，后面是不需要执行的

7.流程控制

		7.1顺序结构[默认]
		7.2分支结构
			7.2.1if
			7.2.1switch-case
				(1)击穿问题：在case结束后没有使用break，程序会一直往下执行，直到碰到break或者程序执行结束。
		7.3循环结构
			7.3.1 do-while
			7.3.2 while
			7.3.2 for
				(1)for(;;)-->死循环
				(2)定义循环：形如Outer:for(int i=0; i<10; i++){} 

8.数组

	8.1数组是对象
	8.2数组的定义 
						(1)int[] i = new int[5]; // 定义
						(2)int[] i = new int[]{1,2,3}; // 定义并初始化 
						(3)int[] i = {1,2,3}; // 直接量 
	8.3数组默认值的问题 基本类型 
						(1)整型数组：默认值是0 
						(2)浮点型数组：默认值是0.0 
						(3)char类型数组：空 
						(4)boolean类型数组:false 引用类型 
						(5)引用类型数组：null 
	8.4数组的方法 (1)数组访问：数组[index]---->可能产生数组下标越界 
							(2)数组的遍历 
							(3)数组的排序、交换、复制等 
	8.5Arrays类[数组的工具类] 
							(1)数组的排序 
							(2)数组的复制

9.类[对于某一类事物的抽象]

		9.1定义类：[访问修饰符] class 类名 {}
		9.2使用类：类名 变量名 = new 类名();

10.属性[对于特征的抽象，又叫做成员变量]

		10.1定义：[访问修饰符] 类型 变量名;
		10.2默认值的问题
			基本类型
			(1)整型数组：默认值是0
			(2)浮点型数组：默认值是0.0
			(3)char类型数组：空
			(4)boolean类型数组:false
			引用类型
			(5)引用类型数组：null
		10.3辨别一下成员变量和局部变量[代码块中定义的变量]
			(1)成员变量可以不初始化就使用，局部变量只能初始化后再使用
			(2)作用范围不同，成员变量在整个类中的方法都可使用，局部变量只能在定义它的大括号中使用
			(3)参数是局部变量

11.方法[对于行为的抽象]

		11.1定义：[访问修饰符] 返回值 方法名(参数列表) {  方法体  }
		11.2方法签名：方法名和参数列表共同组成了签名，同一个类中不能存在方法签名相同两个方法
		11.3重载:在"同一个类"中，"方法名相同"，"签名不同"的两个方法，叫做重载。
		11.4重写
			(1)定义：在父子类中，"签名相同"，返回值相同的两个方法，叫做重写。
			(2)子类中重写的方法访问修饰符的范围必须要比父类的范围大或者一样。
		11.5重写和重载的辨析
			(1)重载是同一个类，重写是不同类
			(2)重载只是方法名相同，重写除了签名相同以外还有返回值也要相同			

12.构造方法[创建对象时初始化用的]

		12.1定义：[访问修饰符] 类名(参数列表) { 方法体 }
		12.2this：指代当前对象
		12.3构造方法的执行：必定会调用父类的构造方法，默认调用的是无参的，若父类没有无参的，那么需要手动调用有参的
		12.4super：指代父类

13.代码块[一般用作初始化成员变量的]

		13.1定义：{}
		13.2调用时机：每次创建对象的时候都会调用

14.static关键字

		14.1属性
			(1)定义：[访问修饰符] static 类型 变量名; 
			(2)由static修饰的属性，将从实例的属性提升为类属性
			(3)调用：类名.属性名
		14.2方法
			(1)定义：[访问修饰符] static 返回值 方法名(参数列表) {  方法体  } 
			(2)由static修饰的方法，将从实例的方法提升为类方法
			(3)调用：类名.方法名
		14.3代码块
			(1)定义：static{}
			(2)调用时机：只有在类加载的时候会调用一次
		14.4注意事项：在静态方法中只能访问静态变量

15.final关键字

		15.1类：
			(1)定义：[访问修饰符] final class 类名 {}
			(2)注意事项：类不可被继承
		15.2方法
			(1)定义：[访问修饰符] final 返回值 方法名(参数列表) {  方法体  } 
			(2)注意事项：方法不能够被重写
		15.3成员变量
			(1)定义：[访问修饰符] final 类型 变量名 = new 类型(); 
			(2)注意事项
				a.成员变量必须初始化一次：直接初始化、构造方法初始化
				b.成员变量为引用类型的时候，只要引用的地址不变，引用类型实例里面的值随意改变
				c.同时使用static和final修饰的成员变量，称之为静态常量
		15.4局部变量
			(1)定义：final 类型 变量名 = new 类型(); 
			(2)注意事项
				a.局部变量必须初始化一次：直接初始化、先声明后初始化
				b.局部变量为引用类型的时候，只要引用的地址不变，引用类型实例里面的值随意改变

16.访问修饰符

		16.1访问修饰符：private、默认、protected、public
		16.2修饰：类、方法、成员变量
		16.3成员变量使用private修饰：get和set方法
		16.4封装性：通过修改访问修饰符的权限来限制访问

17.继承[Java中继承是单继承的]

		17.1定义：[访问修饰符] class 类名 extends 类名 { }
		17.2继承：继承的是非private修饰的成员变量和方法
		17.3重写
		17.4构造方法的调用
		17.5super关键字

18.接口

		18.1定义：[访问修饰符] interface 接口名 {} 
		18.2接口的内容
			1.8之前
			(1)静态常量
			(2)抽象方法
			1.8之后
			(3)方法的默认实现[有利于接口的升级]
			(4)静态方法
		18.3使用：[访问修饰符] class 类名 implements 接口1, 接口2, 接口3{}

19.抽象

		19.1关键字：abstract
		19.2abstract关键字可以修饰：方法和类
		19.3修饰方法：[访问修饰符] abstract 返回值 方法名(参数列表);
		19.4修饰类：[访问修饰符] abstract class 类名 {}
		19.5注意事项：
			(1)抽象方法和抽象类不能够使用final关键字修饰
			(2)抽象方法所在的类必定是抽象类，抽象类所含有的方法不一定都是抽象方法，甚至可以没有抽象方法
			(3)一个类继承自抽象类，那么这个类必须重写抽象类的所有抽象方法，或者这个类本就是抽象类

20.多态

		20.1多态的定义：一个对象表现为具有多种身份
		20.2多态的使用：父类[extends、implements]的引用指向子类的对象
		20.3注意事项：
			(1)多态在方法调用的时候看等号右边，是谁调用谁的
			(2)多态在除方法调用的时候看等号左边，是谁调用谁的
			(3)注意强转：instanceof			

二、JavaSE部分【API部分】

1.Object

		1.1Object是所有类的直接或间接父类
		1.2toString：syso(对象)，默认输出的是该对象的内存地址，必要时需要重写
		1.3equals：进行实例比较，默认比较的是内存地址，必要的时候需要重写

2.String

		2.1String是final类：不能够被继承
		2.2JDK1.8String存放数据的是final修饰的char[]：String是不能被修改的
		2.3使用String
			(1)创建
				a.直接量的形式 --> String对象会直接进入常量池，形式复用
				b.new的形式 --> new的对象会在堆中创建，不能够复用
			(2)常用方法[拼接、截取、查找]
		2.4StringBuffer(线程安全)、StringBuilder(线程不安全)、StringJoiner
			(1)出现的原因：String不能变，所以再做拼接或者删除时会浪费资源，这样就出现了上面三个类
			(2)使用：普通拼接：StringBuffer，特殊拼接：如2018-01-02使用StringJoiner

3.时间

		JDK1.8前
		3.1Date
		3.2SimpleDateFormat
			(1)格式化的年(y)月(M)日(d)时(H/h)分(m)秒(s)是怎么表示的
			(2)时间与String转换
		3.3Calendar[时间的计算]
			(1)获取Calendar实例
			(2)获取时间：获取年月日时分秒
			(3)计算时间：
				a.add：计算不确定的日期
				b.set：计算确定的日期
		JDK1.8后
		3.4LocalDate：2020-08-26
			(1)获取LocalDate的实例
			(2)获取时间：获取年月日
			(3)计算时间：
				计算不确定的日期
				a.plus
				b.minus
				计算确定的日期
				c.set
		3.5LocalTime：15:45:00
			(1)获取LocalTime的实例
			(2)获取时间：获取时分秒
			(3)计算时间：
				计算不确定的日期
				a.plus
				b.minus
				计算确定的日期
				c.set
		3.6LocalDateTime：2020-08-26 15:45:00
			(1)获取LocalDateTime的实例
			(2)获取时间：获取年月日时分秒
			(3)计算时间：
				计算不确定的日期
				a.plus
				b.minus
				计算确定的日期
				c.set
		3.7ChronoUnit[单位]、ChronoField[字段]、TemporalAdjusters[日期调整工具]
		3.7DateTimeFormat：
			(1)格式化的年(y)月(M)日(d)时(H/h)分(m)秒(s)是怎么表示的
			(2)获取DateTimeFormat实例

4.包装类

		4.1作用：将基本类型和对象进行互转
		4.2八个包装类：除了Integer、Character，其他都是原基本类型首字母大写
		4.3包装类的方法：
			(1)将数字类型的字符串解析成数字
			(2)包装类：intValue....
		4.4BigInteger(了解)、BigDecimal
			(1)运算方法：加减乘除、保留小数
			(2)与数字类型的相互转换方法：注意溢出

5.异常

		5.1异常的分类
			(1)Error:没有办法，只能终止程序运行
			(2)Exception:可以控制，处理后可以正常运行
				a.受检性异常：编写时需要处理
				b.运行时异常：编译时没有问题，运行时可能会出现问题
		5.2异常的类继承
		5.3处理异常
			(1)抛出异常：throws
			(2)捕获异常：try-catch-finally的形式
				a.多catch块的情况捕获异常应该是先小后大
		5.4自定义异常

6.集合

		6.1LinkedList
			(1)底层基于链表的实现
			(2)有序的集合
			(3)优缺点：存储快、查找慢
			(4)常见操作：增删改查遍历
		6.2ArrayList
			(1)底层基于数组的实现
			(2)有序的集合
			(3)优缺点：存储慢、查找快
			(4)常见操作：增删改查遍历
		6.3Set
			(1)底层就是一个Map
			(2)无序且不重复的集合
			(3)特点：存储不相同的数据
			(4)常见操作：增删遍历
		6.4Map
			(1)底层是数组加链表的实现
			(2)存储的是键值对
			(3)常见操作：增删改查遍历

7.IO流

		7.1File类
			(1)File类是对于文件和文件夹的抽象
			(2)相对路径和绝对路径
			(3)分隔符
			(4)增删改查
		7.2RandomAccessFile
			(1)可以访问文件任意位置
			(2)指针的概念、读写文件对于指针的影响
			(3)在文件中间插入文本的案例
		7.3IO流
			(1)输入输出流
			(2)字节和字符流
			(3)字节的根流：InputStream、OutputStream
			(4)字符的根流：Reader、Writer
			(5)读写：实现复制案例

8.线程

		8.1基本概念
			(1)进程与线程
			(2)CPU时间片轮转机制
			(3)并行和并发
		8.2如何创建线程
			(1)继承Thread类
			(2)实现Runnable接口
		8.3线程的常用方法	
			(1)start
			(2)interrupt/stop
			(3)sleep
			(4)yeild
			(5)join
			(6)线程优先级
			(7)守护线程
		8.4线程安全
			(1)sycn关键字的使用
			(2)volatile关键字
		8.5等待通知机制
		8.6线程的声明周期

9.网络编程

		9.1UDP[寄信]
			(1)概念和特点
			(2)DatagramSocket、DatagramPacket
		9.2TCP
			(1)概念和特点
			(2)三次握手和四次挥手
			(3)Socket、ServerSocket

10.解析XML

		10.1XML的定义：可拓展标记语言
		10.2使用XML
			(1)XML语法
			(2)某些字符转义
		10.3命名空间：xmlns
			(1)自定义命名空间: xmlns:xxx="xxxxxxxxxxxxxxxxxxxx"
			(2)默认命名空间: xmlns="xxxxxxxxxxxxxxxxxxxxxxxxxx"
		10.4约束
			(1)dtd
			(2)xsd
		10.5解析XML
			(1)SAX:边读边解析
			(2)DOM
			(3)JDOM
			(4)DOM4J:除了SAX其他的都是一次性将XML加载到内存中
				a.添加DOM4J的jar包
				b.创建解析器
				c.解析：从根标签一层一层往下解析的
		10.6xpath：xpath表达式

11.反射

		11.1获取Class对象三种形式
		11.2获取方法
			(1)反射调用方法
			(2)私有方法怎么调用
		11.3获取属性
			(1)反射获取属性
			(2)私有属性怎么获取
		11.4获取注解
		11.5获取构造方法
			(1)如何使用构造创建对象

12.注解

		12.1定义注解
		12.2两个元注解：@Target、@Retation
		12.3使用：结合反射一起使用