JavaSE总结

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
    */

二、数据类型转换
数据类型转换:

• 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
• 2. 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.逻辑运算符

4. 位运算符

第三章、条件判断和循环

一、条件结构
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的属性:肯定可以使用

3. 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);

}

}