JavaSe总结
第一章、初识java
一、java简介
1.java发展历程
2.java平台划分:javase、javaee、javame
3.java的特点:跨平台,开源,垃圾回收
二、JDK和JRE介绍和安装
1.jdk是什么? Java 语言的软件开发工具包
2.jre是什么? java运行环境
三、java代码编译执行过程
1.编写源代码(.java)---->2.编译源代码(.class二进制字节码文件):javac 原文件名(含扩展名)----->3.运行二进制字节码文件:java 文件名(不加扩展名)
四、Java代码编写规则
五、注释:不进行编译
1.单行注释://
2.多行注释:/多行注释/
3.docs文档注释
/**
*docs文档注释
*/
六、转移符号:
\n 换行
\t tab键
\ 输出\
七、开发工具IDEA
project 可以作为单独的一个工程
project可以作为一个空间
module:模块
八、变量的使用
- 变量的作用:保存临时数据
- 声明的语法:数据类型 变量名 [= 初始值];
- 变量使用的要求:先声明—>赋值—>使用
- 变量命名要求:不能使用关键字,数字、字母、下划线、$ 但是数字不能开头
-
总则:见名知意
九、java中基础数据类型
四类八种:
*byte–>short–>int–>long–>float—>double
-
1.数值型 :整型的数值型常量当成int,浮点型的数值常量当成double
-
整型数:
-
byte:一个字节(8位):-128 ~ 127 -2^7 ~ 2^7-1
-
短整型short:两个字节(16位):-32768~32767 -2^15 ~ 2^15-1
-
整型 int :四个字节(32位): -2^31 ~ 2^31-1
-
长整型 long:八个字节(64位) -2^63 ~ 2^63-1
-
注意事项:要在取值的后面添加一个L(大小写不区分)
-
浮点型数:
-
单精度浮点型:float:四个字节(32位)
-
注意事项:必须在取值的后面加F/f
-
双精度浮点型:double:八个字节(64位)
-
备注:如果进行工程算数运算,不能直接使用double/float,精度不够
第二章、数据类型
一、数据类型
四类八种:
-
- *byte–>short–>int–>long–>float—>double
-
-
- 1.数值型 :整型的数值型常量当成int,浮点型的数值常量当成double
-
-
-
- 整型数:
-
-
-
-
byte:一个字节(8位):-128 ~ 127 -2^7 ~ 2^7-1
-
-
-
-
- 短整型short:两个字节(16位):-32768~32767 -2^15 ~ 2^15-1
-
-
-
- 整型 int :四个字节(32位): -2^31 ~ 2^31-1
-
-
-
- 长整型 long:八个字节(64位) -2^63 ~ 2^63-1
-
-
-
-
注意事项:要在取值的后面添加一个L(大小写不区分)
-
-
-
-
- 浮点型数:
-
-
-
- 单精度浮点型:float:四个字节(32位)
-
-
-
-
注意事项:必须在取值的后面加F/f
-
-
-
-
- 双精度浮点型:double:八个字节(64位)
-
-
-
- 备注:如果进行工程算数运算,不能直接使用double/float,精度不够
-
-
-
- 2.字符型:
-
- char — 两个字节 0~65535 0~2^16-1
-
- 三种取值:第一种: char c = ‘a’; 单引号引起来,只能放一个字符
-
-
第二种: 取字符的ASCII. 0~65535
-
-
第三种:unicode表达方式 '\u0000' ~ '\uffff' 0~9,abcdef
-
-
- 3.布尔型
-
boolean :只能true/false
-
- 4.字符串:String
*/
- 4.字符串:String
二、数据类型转换
数据类型转换:
- 1.隐式转换:数值型:将范围小的数值向大范围的变量中存储时,发生隐式转换
- byte -->short —>int —>long —>float–>double
- 2.强制转换:数值型:将范围大的数值向小范围的变量中存储时,必须手动转换
*byte <–short <—int <—long <—float<–double - 数据类型 变量 = (转换的类型)值
- 备注:强制转换可能会丢失精度
- 3.非数值型的 char String
*1)char 与数值型的转换 - 隐式转换 char—>int —>long —>float–>double
- 强转char<—int <—long <—float<–double
-
- String—数值之间的转换
- String—>数值
- 包装类.parseXXX() :字符串必须能转成数值
- 数值----->String
三、基础数据类型的包装类
基础数据类型的包装类:
*
- byte short int long float double char boolean
- 包装类
- Byte Short Integer Long Float Double Character Boolean
装箱和拆箱
四、数据交换
开辟一个临时存储空间
五、Random随机数的使用
步骤:1.import java.util.Random;
2. Random ran = new Random();
3. ran.nextInt(n) 0~n-1
六、运算符
1.算数运算符
2.关系运算符
3.逻辑运算符
- 位运算符
第三章、条件判断和循环
一、条件结构
1.基本条件结构:
if(条件){
}
else{
}
2.嵌套条件结构:
3.多重条件结构
if()
{
}else if(){
}else if(){
}
…
else{
}
4.三目运算符
表达式?表达式1:表达式2
5.switch条件结构
如果{}中只有一条语句,{}可以省略
注意:条件一定要找正确、准确
二、循环结构
1.循环的结构
2.while(条件)
{
}
3.do{循环体}while(条件);
4.for(初始化;条件判断;变量更新){
循环体
}
5.循环的控制:break—退出循环 continue-----跳过本次循环
第四章、循环的嵌套
一、嵌套循环
1.使用嵌套循环解决现实问题:比如打印图形、规律的计算…
2.控制循环:break—退出当前循环, 退出多层循环需要在循环上面设置标记,格式: 标记名:
退出时使用: break 标记名
二、方法的封装
1.方法的作用:提高代码的复用性、提高代码可读性、提高代码可维护性
2.方法的语法: public 返回值类型 方法名(参数列表){方法体}
3.详细介绍:public void 方法名(){}
4.带返回值的方法:
要求:1)一定要使用return关键字返回一个值
2)只能返回一个值
3)返回值的类型必须与声明的类型一致
4)return后面不能有代码
5.带参数的方法:
声明语法:(参数类型 参数名,参数类型 参数名)
调用要求:传入的实际参数的个数、顺序、数据类型必须与声明的形参一致
第五章、正则表达式
字符
x 字符 x。举例:‘a’表示字符a
\ 反斜线字符。
\n 新行(换行)符 (’\u000A’)
\r 回车符 (’\u000D’)
字符类
[abc] a、b 或 c(简单类)
[^abc] 任何字符,除了 a、b 或 c(否定)
[a-zA-Z] a到 z 或 A到 Z,两头的字母包括在内(范围)
[0-9] 0到9的字符都包括
预定义字符类
. 任何字符。我的就是.字符本身,怎么表示呢? .
\d 数字:[0-9]
\D 非数字:[\d]/[0-9]
\w 单词字符:[a-zA-Z_0-9]
\W 非字符[^\w]
边界匹配器
^ 行的开头
$ 行的结尾
\b 单词边界, 就是不是单词字符的地方。
Greedy 数量词
X? X,一次或一次也没有
X* X,零次或多次
X+ X,一次或多次
X{n} X,恰好 n 次
X{n,} X,至少 n 次
X{n,m} X,至少 n 次,但是不超过 m 次
运算符
XY X后跟 Y
X|Y X 或 Y
(X) X,作为捕获组
String类中的三个基本操作使用正则:
匹配:matches()
切割: split()
替换: replaceAll()
第六章、数组
一、数组的特点
1.长度不可变
2.同一种数据类型
二、数组的创建方式
1.动态创建: int[] arr = new int[len];
能分成两句
2.静态创建: int[] arr = new int[]{10,43,21};
能分成两句
3.静态创建: int[] arr = {3,4,5};
不能分为两句
三、操作数组元素
使用索引(下标):取值0~length-1
语法: arr[index]
如果下标越界,抛出异常:ArrayIndexOutOfBoundsException
四、使用数组解决问题
1.找最值:找最大或者最小值
2.排序:
*1)冒泡排序1: 每两个相邻元素进行比较:
*2)冒泡排序2: i位置的元素与后面的每一个元素进行比较
*3)选择排序:每次都找最小值,与i位置交换
4)插入排序:将元素与前面排序好的元素进行比较(从后向前比),找到合适的位置,以此向后移动,再将该位置上的插入该元素
五、数组中存储引用数据类型数据(数组中存储对象)
面向对象思想:类—模板
对象
注意空指针的问题
第七章、面向对象高级
*一、多态:
1.什么是多态:在不同的环境表现出不同的功能
2.构成多态:存在继承或者接口的条件下,父类变量(接口变量) 接收一个子类实例(实现类的实例)
调用的是重写的方法
3.多态的使用场景:封装属性时,方法传入参数时,设计方法返回值时都可以考虑多态
4.多态的好处:提高代码的可扩展性、维护性、灵活性、复用性,降低成本
二、引用类型的数据转换
1.向上转型----自动转,将子类的对象转为父类的类型
2.向下转型----强制转换,将父类的一个变量转为某个具体子类的类型(可能会出现转换异常:ClassCastException)
到底是否能转成功,决定于new 出来的对象到底是什么类型
3.instanceof关键字:对象 instanceof 类型 :判断对象是不是该类型的实例,true—是,false—不是
三、接口
1.接口的定义语法:public interface 接口名{}
2.接口的特点:
1.方法不能有实现,只能是方法的定义
-
2.方法必须是public abstract,都可以不写,默认就是public abstract
-
3.接口中也可以定义属性:必须是public static final,默认也是
-
4.接口不能被实例化
-
5.接口可以实现多继承。一个类可以实现多个接口.public class SubClass extends Base implements A,B,C{}
-
一个接口可以继承多个接口 public interface A extends 接口1,接口2{}
四、static关键字:
1.作用:修饰属性和方法
2.细则:
修饰属性:静态的属性:类的属性,类所拥有的,或者所有对象所共有的,存储在常量池中的.当出现类名时,该静态的属性就会被初始化,静态的属性通过类名调用
普通的属性:对象的属性,每个对象自己拥有的,存储在堆中的,通过对象名调用
修饰方法:使用类名调用
static 方法中能不能使用普通属性,普通方法:不能用:因为该方法在看到类名时即可调用,但是此时属性还未声明出来。
普通方法中能不能使用static的属性:肯定可以使用
- static修饰方法的使用场景:一般工具类中都使用static
//包名:全部小写
类名/接口名:首字母大写
属性名、变量名、方法名 驼峰命名方式
第八章、抽象类-static-异常-final-Log4j
public static final abstract 修饰符
一、final关键字
1.修饰类:该类不能被继承
2.修饰方法:该方法不能被重写
3.修饰属性:该属性是常量
二、补充static
初始化整个顺序,先执行父类的static的属性和static代码段,
再执行子类的static的属性和static代码段
再执行父类的普通属性,普通的代码段,构造方法
再执行子类的普通属性,普通的代码段,构造方法
三、抽象类
1.语法:public abstract class 类名{}
2.特点:
类的特点:能写方法的具体实现,能被继承,继承的子类一定要实现父类中抽象的方法,或者继续声明自己的是抽象的类,该方法是抽象的方法,最终一定要实现.
接口特点:可以有方法的定义,不能被实例化
3.抽象类的好处:
四、异常
1.什么是异常
2.异常的解决的途径:两种:捕获异常和抛出异常
3.捕获异常:try
catch
finally
4.抛出异常:throw 异常对象
throws 写在方法最后的
5.自定义异常:语法
6.继承中重写方法抛出的异常不能多于原方法中的异常类型
五、日志:log4j
1.使用步骤:
分四步骤:第一步:引入jar文件
第二步:添加配置文件
第三步:创建一个日志对象
第四步:调用相应的方法
2.日志的级别:
debug–>info---->warn–>error—>fatal
3.日志的配置文件要能看懂,会修改
4.使用场景:后续项目中锻炼
六、断言(了解即可)
1.掌握基本语法:
基本语法:assert 表达式
//基本语法:assert 表达式:表达式为false时执行的代码
2.环境默认不开启断言,所以需要手动配置:
Edit Configurations修改 VM Options中写入-ea
取消断言:-da
3.开发中一般用不到断言,一般在测试的工具中会大量应用断言,尤其单元测试
第九章、集合
一、掌握集合在JDK中的结构(见PPT中的图):说明继承关系,存储结构特点
Collection:单个存储对象的集合父接口
—List:有序的,可重复的 :判断的equals方法
----ArrayList:数组型集合,地址连续的,查询效率高,增删效率低
----LikedList:链表式的,地址不连续,前一个元素存储下一个元素的引用。查询效率低,增删效率高
–Set:无序的,不可重复的
----HashSet:判断equals和hashcode
基础数据类型可以通过equals()进行直接比较,如果是比较对象,则需要手动重新equals()方法,map集合比较key,还需另外再重写hashcode
二、各个集合中常用的方法:(参考API,将上课讲的例子,全手写一遍)
三、集合的遍历方式
List集合:三种:普通for,增强for,迭代器
Set集合:两种: 增强for,迭代器
Map集合:三种:获取keySet,获取values,获取entry
foreach增强循环(jdk1.8)
备注:迭代器使用时的注意事项需要掌握,增强for也是使用迭代器,所以注意事项
第十章、线程
一、线程和进程的概念
1.进程:正在运行的一个应用程序:多个进程共享cpu
2.线程:组成进程的最小的单元,单一运行的顺序流:多个线程共享进程分配的cpu
二、创建的线程的两种
1.extends Thread类:当前就是线程类
2.implements Runnable接口:当前类是线程类的target
3.implements Callable接口:带返回值
*不同实现方式的区别
三、线程的生命周期:五个阶段
新建阶段、就绪阶段、运行阶段、阻塞阶段、死亡阶段
每个阶段的特点:互相转换的条件
四、线程中常见的方法:
1.start():启动线程的方法
2.stop():摒弃的方法,可能导致数据不安全
3.suspend():摒弃的方法,可能导致死锁
4.resume():摒弃的方法.
5.join():阻塞主线程,插队的子线程执行完毕后,主线程才能执行
6.yield():让位:只给优先级高的线程让位,将运行的线程进入就绪状态
7.sleep(millsecond):可以用在任何地方
8.wait():等待
sleep()和wait()区别:
–拥有对象不同:wait是任何对象的方法,sleep是Thread的方法
wait可以释放对象锁,sleep保留对象锁
wait可以是任意对象来调用,sleep只能线程调用
wait可以通过notify随时唤醒,sleep只能等待设定时间结束后自然唤醒,否则将引发异常
wait必须在同步方法或同步块中进行调用,sleep可以在任意位置调用
五、线程同步问题:
1.什么是线程安全问题?多条线程同时访问一个资源,所产生的数据不一致的问题
2.如何保证线程安全?
第一种方式:
使用同步锁:synchronized:
synchronized :修饰代码段 :语法:synchronized(对象-同步监视器){被锁的代码段}
-
同步监视器只能是引用类型的。多条线程锁的是同一个对象
-
修饰方法:语法 public synchronized void method(){}
-
同步的方法,对该方法进行锁定,并且调用当前方法的对象
第二种方式:
使用Lock锁:ReentrantLock类
区别:1.synchronized 关键字,jdk提供的。ReentrantLock类
2.synchronized 可以修饰代码段,也可以修饰方法。但是ReentrantLock只能用于代码段
3.如果资源竞争不太激烈时,效率没太大差别,如果资源竞争非常激烈时,ReentrantLock比synchronized 高很多。
4.synchronized 运行完代码段自动解锁,但是lock锁必须手动调用unlock()方法,有可能造成死锁:才要把unlock()写在finally中
5.synchronized阻塞其他线程的,但是lock可以使用tryLock()尝试获取锁,不一定非要阻塞。
第三种方式:
ThreadLocal:以空间换取时间
六、wait和notify进行协作或者通信
1.wait只能有notify唤醒,并且调用wait和notify的对象必须是同一个。
第十一章、IO流
一、I/O流分类
1.按输入输出的方向:(站在程序的角度)
输入流:将数据读取到程序中
输出流:将程序中的数据写入到文件或者其他地方
2.按处理的单位来分:
字节流:以一个字节为基本处理单位
字符流:以一个字符为基本处理单位(一个字符是两个字节)
3.按流是否进行装饰:
节点流:直接对文件系统或者其他系统进行处理的。
处理流:如果对流进行了装饰(包装),这种流成为处理流
二、基础类
字节型: InputStream OutputStream 抽象的类
字符型: Reader Writer
三、常见的字节型的流:可以处理任何类型的文件
1.FileInputStream FileOutputStream 字节型节点流—直接对文件进行处理
2.BufferedInputStream
3.DataInputStream DataOutputStream
4.ObjectInputStream ObjectOutputStream
四、常见的字符流:只能处理纯字符型文件
1.对文件进行处理的字符流:节点流
FileReader FileWriter
2.缓冲区的
BufferedReader BufferedWriter
3.转换流
InputStreamReader OutputStreamWriter
第十二章、泛型-内部类-反射
(1)泛型
定义泛型:接口、类:
接口中或者类中的所有方法都可以使用该泛型了方法
添加,修改,删除
- add(Car) delete(int id) modify(Car )
- add(User)
- add(Type)
- add(Brand)
public interface BaseDao {
void add(T t);
void modify(T t);
void delete(int id);
List<T> findAll();
//查找单个对象
T findById(int id);
}
定义方法上的泛型
public static T create(Class clazz) throws IllegalAccessException, InstantiationException {
return clazz.newInstance();
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
User user = Demo01.create(User.class);
Car car = Demo01.create(Car.class);
System.out.println(car);
}
(2)内部类(匿名内部类,方法内部类,静态内部类)
在外部类中创建内部类对象。想使用内部类,调用内部类的方法;内部类同样可以调用外部类的属性方法。但如果在其他地方调用,如果要使用内部类,则必须先创建外部类紧接着创建内部类才行。
(3)反射
创建方法:有3种方式:
第一种:Class.forName():传入类的完整包名+类型
例如: Class clazz =(Class) Class.forName(“cn.igeek.泛型.Car”);
第二种:类名.class
例如:Class clazz =Car.class;
第三种:类对象.getClass()
例如: Class clazz =new Car().getClass();
常见排序(快速排序、冒泡、选择、插入)
package cn.sort;
import java.util.Arrays;
public class SortDemo {
//冒泡排序:两种
//选择排序:找最小值
//插入排序:
//快速排序:
public static void main(String[] args) {
int[] arr = {10,4,23,56,1,0,33};
quickSort(arr, 0, arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int[] arr,int low,int high)
{
//一定是low<high
if(low>high)
{
return;
}
//先找基准值
int value = arr[low];//j先动
int i=low;
int j = high;
int temp;
while(i<j)
{
//j先向左移动
while(arr[j]>=value &&j>i )//
{
j--;
}
//i向右移动
while(arr[i]<=value && j>i)
{
i++;
}
//j位置与i位置的值互换
if(j>i)
{
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
//程序已经达到i=j相遇了
//将基准值与该位置的元素互换
arr[low] = arr[i];
arr[i] = value;
//i或者j位置的左侧递归
quickSort(arr,low,i-1);
//i或者j位置的右侧递归
quickSort(arr, i+1, high);
}
}