JavaSE知识点总结
2022-10-17 11:27:11 14 举报AI智能生成
coco博
作者其他创作
大纲/内容
概述：JavaSE，Java platform standard edtion(Java平台标准版)
JavaEE Java platform enterprise edtion(Java平台企业版)
JVM：Java虚拟机（内置垃圾回收机制，自动完成空间管理）
JRE：Java运行环境（包含JVM，和解释器）
JDK：Java开发环境（包含JRE，类库，编译器、调试工具）
概述与环境搭建
计算机内存的一块存储空间
数据类型
变量名
值
组成
先声名，后赋值
声明并赋值
多个同类型变量同时声明并赋值
声明方式
变量
1个字节
-2^7~2^7-1
byte
2个字节
-2^15~2^15-1
short
4字节
int
8字节
long
整数
float
double
小数
boolean
布尔
char
字符
基本数据类型
String
字符串
数组
对象
引用 数据类型
两种类型兼容，目标类型大于原类型
两种类型兼容，目标类型小于原类型
自动类型转换
整数长度完整，数据完整
整数长度不够，数据截断
小数转换整数，数据截断
字符整数互转，数据完整
boolean不可与任何类型转换
强制类型转换
类型转换
数字 间的常规类型提升
字符串发的特殊类型提升
类型提升
+-*、++--
算数运算符
= += -=*=、=
赋值运算符
<><=>===!=
关系运算符
&&||!
逻辑运算符
布尔表达式 ？结果1:结果2
三元运算符
运算符
引入工具包：import java.util.Scanner;
声明Scanner input=new Scanner(System.in);
int a=input.nextInt();//控制台输入的值付给a
String str =input.next();
char car=input.next().charAt(0);
控制台录入
语言基础
基本if选择结构
if else 选择结构
多重if选择结构
嵌套if选择结构
选择结构
比较引用类型值是否相等
“是”.equals(\"是\")；
.equals()方法
获取一个随机数
3： 0，1，2
.random(int值)；
byte short int char string(jdk7)
case 值不可相同
default: (最后)
追加break；
switch
分支 结构
函数内部的变量
从定义行到所在代码快结束
重合范围内不可重名
局部变量
选择结构与分支结构
特点：首次有入口条件，先判断后执行，适用于循环次数明确的的条件
while(boolean){}
先执行后判断，适用于循环次数不明确
do{}while(boolean)
while循环
首次有入口条件，先判断，再执行
for（;;）{}
for循环
终止，跳出，switch分支语句，以及循环结构
扩展：outer：循环体 break outer; 跳出指定循环
break
结束本次进入下一次循环
contiune
在一个循环中完整嵌套另一个循环
嵌套循环结构
循环结构
概念：实现特定功能的一段代码，可以反复使用。
定义语法：public static void 函数名（形式参数）{函数主体 }
自己调用自己（递归）
函数调用：函数名称（实际参数）；
形参与实参：函数定义中是形参，函数调用中为形参赋值为实参。
返回值类型：基本数据类型，引用数据类型，void
return value;返回值类型应该与函数定义的返回值一致（兼容）
return;void 函数中，直接结束函数。
返回值与返回值类型
函数
概述：一组连续的存储空间，存储一组类型相同的数据
数据类型[] 数组名； 数组名=new 数据类型[长度]；
数据类型[] 数组名=new 数据类型 [长度]；
数组的创建
数组的赋值
普通for循环遍历
增强for循环遍历---for（数据类型 变量名：数组名）{System.out.print(变量名)}
增强for循环，专为遍历而存在，解决了数组下标越界异常，//将数组的每个元素赋值给变量
数组的遍历
创建一个新数组，将原来数组上的值，用循环逐一复制过来
System.arraycopy(原数组，原数组起始下标，新数组，新数组的起始村存储下标，需要赋值的个数或长度);
引入工具包 import java.util.Arrays;
copyOf(原数组，新长度)；//同时完成对新数组的创建
int[] newnum=java.util.Arrays.copyOf(原数组，新长度)；
数组的扩充
数组的增删改查
public static 数据类型[] 方法名（数据类型[] 形式参数）；
可变长参数 数据类型...形式参数 与数据类型[] 形式参数 等同
可变长参数只能有一个，并且只能在形参列表的最后
数组的参数，返回值
冒泡排序（交换排序）：相邻的两个元素比较大小互换位置。外层：length-1;内层：length-1-i;
选择排序： 固定值与其他值依次比较。外层：length-1；内层：length
jdk排序：Java.util.Array.sort(数组名)；//升序
冒泡、选择、插入、希尔、归并、快速、堆、计数、稳定、
数组的排序
概念一维数组中的一维数组。数组中的元素还是数组。
不规则二维数组int[][] arr =new int[3][];
arr[0]= new int[3];
arr[1]=new int[5];
arr[2]=new int[4];
语法： int[][] 数组名=new int[行数][列数]；
二维数组
一组相同或者类似的对象中抽取出共性的行为和特征
类的定义 public class 类名{}
类；
具有一定的特征和行为
对象的定义 类名 对象名=new 类名（）；
实例变量定义在类的内部，方法的外部。可以不赋值
实例方法的定义 public void 方法名（参数）{可以实现的行为}
实例变量、实例方法
方法名相同，参数列表不同---与访问修饰符和返回值类型无关
方法重载
构造方法与类名完全相同，用来创建对象的方法。
public 类名（）{} 没有返回值
可以进行重载增加参数，为实例变量赋值，重写后无参的构造方法将不在起作用
构造的方法
this.属性名 调用实例属性 /this.方法名（）调用实例方法 可以省略隐式存在
必须在构造方法中，并且只能在首行
this() 调用本类中的其他构造方法
this关键字
面向对象
概念：实例变量和实例方法的访问修饰符设置为 private
public int getAge(){return this.age}
public void setAge(int age){this.age=age;}
仅本类可见，只能通过get\\set 方法访问
外界不可以直接访问private修饰的属性，公开的set和get方法是唯一的途径
封装
概念：类与类之间行为和特征的一种赠与和获得
满足 is a 的关系
class 子类 extend 父类{子类的内容}
子类继承父类以后可以使用父类的方法和属性，也可以定义自己的
一个类只能继承一个父类，但是可以多级继承
当父类和子类不在一个包时， default修饰的属性
夸包继承只能继承protected，和public 修饰的属性和方法
不能继承父类的构造方法和private修饰的方法
返回值类型、方法名、参数列表与父类方法相同
访问修饰符比父类方法更广泛
重写后优先执行重写后的方法
方法的重写
super关键字，当子类的实例成员与父类的实例成员重名时，super区分
super.属性名/super.方法名（）； 调用父类的属性和方法；
super（）；/super（参数）； 调用父类的无参有参的构造方法
子类的构造方法中默认提供super（）；调用父类的无参构造方法
super关键字
继承
概念：父类引用指向子类对象，从而产生多种形态（二者具有直接或间接的继承关系）
父类名 对象名=new 子类名（）；
如果子类中重写的父类的方法，则多态对象调用方法时优先调用子类重写后的方法
向上转型（装箱）
子类名 对象名2=（子类名）对象名；
只有转换回子类的对象类型才能访问子类特有的属性
向下转型（拆箱）
类型向下转型时，转回类型与向上转型子类名不一致
类型转换异常
多态的应用
判断一个向上转型的对象是否与一个子类对象相同
if（多态对象名 instanceof 子类）
根据是否相同返回一个布尔类型的值
instanceof关键字
多态
三大特征
定义方式 public abstract class 类名{实例属性 public abstract void 抽象方法名（）；}
被abstract修饰的类称为抽象类，无法实例化
作用，可以被子类继承，更自然的使用多态
abstract 修饰的类不能new对象，但是可以声明引用
abstract 修饰的方法，只有方法声明，没有方法实现
子类继承抽象类后，必须重写父类中所有的抽象方法，否则子类还是抽象类
abstract（抽象的）
static修饰的类属性和类方法，称为静态~
静态成员是本类所有对象共享的成员
只有一份，其他类不必创建对象，可以通过类名直接访问；本类直接通过方法名访问
静态方法允许直接访问静态成员
静态方法不允许直接访问非静态成员
静态方法中不允许使用this 和super 关键字
静态方法可以继承，不可以重写，没有多态
特点：
创建对象时，触发，在实例属性之后，构造方法之前
动态代码块不存在，编译时将代码块重的内容合并到构造方法中
动态代码块 class 类名 实例变量{ 动态代码 }构造方法
静态代码块加载类时执行，只触发一次
静态代码块 class 类名 静态属性 static{静态代码} 静态方法
局部代码块（放在方法内，缩小变量的使用范围，基本不用）
静态代码块和动态代码块
static（静态的）
可修饰，类，属性，方法
final修饰的类不可以被继承
final修饰的方法不可以被覆盖
实例常量不提供默认值，只能手动赋值
注意：如果要在构造方法中为其赋值，必须要保证所有的构造方法都能正确赋值
局部常量：显示初始化
实例常量：显示初始化、动态代码块、构造方法
静态常量： 显示初始化、静态代码块
final修饰的变量只能被赋值一次
基本类型常量值不可比变、引用类型常量地址不可变
final（最终的）
三个修饰符
概念：特殊的抽象类，类中只能定义公开静态常量属性，和公开抽象方法
定义方式：public interface MyInterface {public static final value； public abstract void 方法名（）；}
“继承”了某个接口的类，称为实现类（重写接口中的抽象方法）
class Impl implement MyInterface{重写接口中的公开抽象方法}
创建实现类
MyInterface myInterface=new 实现类名Impl（）；
myInterface.方法名（）；
创建实现类对象
实现类
可以编译成字节码文件
不可以创建对象
可以作为引用类型
具备object类中所定义的方法
相同点
所有属性为公开静态常量，隐式用public static final修饰
所有方法是公开抽象方法，隐式用 public abstract修饰
没有构造方法，没有静态代码块，动态代码块
不同点
接口与抽象类的区别
接口的定义：接口的定义代表类某种能力，方法的定义代表了能力的具体要求
一个实现类实现多个接口（不同于类的单继承）
class 实现类 implement 接口1，接口2，接口3，{重写1，2，3的抽象方法}
微观接口（能力）
接口声明引用，创建实现类对象，只能调用接口中所定义的方法，不能调用实现类独有的方法
可强转回实现类自身类型，才可以调用实现类独有的方法
实现类在实现接口时，必须实现接口中所有的抽象方法，否则此类还是抽象类
接口规范
通过继承+实现的方式创建是实现子类
只能通过子类名 对象名=new 子类名（）；的方式使用接口方法和此类独有方法
接口实现多态
类与类：单继承
类与接口：1 implements n
接口与接口：1 extends n
接口的关系
宏观接口（标准）
接口回调：先有接口的使用者，后有接口的实现者
接口
类的内部与实例变量和实例方法同级
Outer outer =new Outer();
Outer.Inter=outer.new Inter();
外部类的一个实例部分， 创建内部类对象时依赖外部类对象
内部类可以直接访问外部类的实例属性和方法，诶不破坏封装（类似get()方法）
成员内部类不能创建静态属性方法（成员内部类可以用任何访问修饰符修饰）
成员内部类
类的内部与静态实例变量和静态实例方法同级
Outer.Inter inter=new Outer.Inter();
创建内部类对象不依赖外部类对象，可以直接创建
静态内部类可以创建，静态属性方法
静态内部类不能直接访问外部类的实例属性和方法，可以直接访问静态属性和方法
静态内部类
定义外部类的实例方法和静态实例方法中
类的适用范围也和局部变量一样，从定义行到所在代码块结束（当前方法）（不能使用任何访问修饰符）
局部类访问外部类了当前方法中的局部变量，变量必须用final修饰，因为不能保证变量的生命周期与自身相同
局部内部类、
没有类名的局部内部类，其他特性与局部类相同
继承式匿名内部类 方法{Animal a =new Animal(){实现类};加分号}
扩展拉姆达表达式
接口中只有一个方法（条件）
接口名 对象名=（）->{方法实现}
接口式匿名内部类 方法{Interface a =new interface(){实现类};加分号}
参数式匿名内部类 定义一个接口参数的方法，调用方法时方法{Interface a =new interface(){实现类};加分号}
匿名内部类不能有构造方法暗，一次只能创建一个对象
匿名内部类
内部类：类的内部再定义一个完整的类（为外部类提供功能组件）
.getClass() :返回一个类对象Class class=对象名.getClass();
.getName();
.hashCode() :返回该对象的10进制哈希值 （int类型）
.toString(); :返回类对象名+@+16进制哈希吗值（可以重写覆盖）
.equas(对象)； ：返回一个boolean类型的值（覆盖重写）
object类
int Iinterage
包装类
String s1=\"abc\";
String s2=\"abc\";
相同方式创建对象，相同值，会放到字符串池 ，两个对象同地址
字符串常量池池；
字符串其实就是字符数组
.charAt(int ) 取字符
.contains（str）匹配串
.toCharArray();转化为字符数组
方法
String 长度不可变
StringBuilder 长度可变
string和stringBuilderde 区别
StringBuilder（）
StringBuilder(\"\")
构造方法
append()方法 返回对象自身，所以可以反复使用方法
StringBuilder
String s=str.toString()
builder转换为string
StringBulider str=new StringBuilder(s);带参构造方法
string转换为builder
相互转换
String 类
String类
可变字符串BigDecimal
Date
Calender
SimpleDateFormat
System
常用类
有序，有下标，元素可以重复
查询快、增删慢，jdk1.2版本，执行效率高，线程不安全。
ArrayList（基于数组）
jdk1.0版本执行效率低、线程安全。
Vector（基于数组）
增删快，查询慢
双链表
LinkedList（基于链表）
List（接口）（有序，有下标，元素可以重复）
基于hashCode和equals实现元素不重复(仅重写equals方法不能实现去重)
当哈希吗相同时会用那个equals确认，如果为true则拒绝存入
表面无序，实则以哈希值为序
HashSet
链表实现的 Hashset类，按照链表进行储存，保留了元素的插入顺序
LinkedHashSet
基于排列顺序实现元素不重复
实现了font color=\"#ff0000\
对象类型必须实现Comparable接口，指定排序规则
通过重写compareTo(obj)方法确定是否为相同元素，和排序规则
方法2：通过匿名内部类的方式，实现Comparator接口，并重构font color=\"#a63d3d\" data-darkreader-inline-color=\"\" style=\"--darkreader-inline-color:#a03e3e;\
TreeSet
SortedHashSet(接口)
Set（接口）（无序，无下标，元素不可重复）
Collection（接口）(无序、无下标、元素可以重复)
可以插入重复Key，但value也会被覆盖
被remove的value，再次get时结果会是null
for(String str : 对象名.keySet()){System.out.println(str)}
键：Set<键泛型> s= 对象名.keySet();
for(String str : 对象名.value()){System.out.println(str)}
值：Collection<值泛型> s= 对象名.values();
键+值：Set <font color=\"#ff0000\
键值视图
要求key，和value都是string 类型
不安全，继承了一个不该继承的类font color=\"#ff0000\
只能使用 对象名.setProperties(\"String\")方法和对象名.getProperties(\"String\")方法
子主题
Properties类
Hashtable(线程安全，效率慢，不允许插入null)
HashMap(线程不安全，效率快，允许插入null)
可以对key自动排序，必须实现comparable接口
匿名类
TreeMap
SortedMap(接口)
存储任意键值对（Key-value）
键：无序，无下标，不允许元素重复
值：无序，无下标，允许元素重复
底层实现数组+单向链表
keySet()遍历
entrySet()遍历
遍历方式
Map（映射）（接口）
集合
程序在运行过程中出现的特殊情况
概念
Error硬件、jvm、执行逻辑的错误，不能处理
NullPointerException空指针异常
ArrayIndexOutOfBoundsException数组下标越界异常
Class CastException 类型转换异常
NumberFormatException数字格式化异常
ArithmeticExecption 算数异常
RuntimeException运行时异常、可处理、可不处理
CheckedException检查时异常，必许处理
Exception 程序在运行和配置过程中产生的，可处理
Throwable可抛出的
分类
自动抛出异常： 当程序运行时遇到不规范的代码和结果时
手动抛出 ： throw new 异常类型（\"实际参数\"）
相当于遇到 System.exit(0)，导致程序因异常而终止
产生
按照方法调用链反向传递
传递
try{可能会出现异常的代码}catch{//捕获异常//处理异常}finally{//无论异常是否发生都会执行的代码}
自定义处理（）
e.printStackTrace()
处理异常的三种方式
处理
throws ：声明异常
throw : 抛出异常
声明，抛出异常
异常类 extends Exception(或子类){重写父类的构造方法}
自定义异常
异常
运行的程序被称为进程 线程是轻量级的进程
cpu的基本执行调度单位
JVM就是一个进程，main方法是主线程，通过代码创建多个线程与主线程并行运行
时间片：OS 为每个线程分配的执行时间
堆空间：存储线程所需要使用的对象
存储线程使用的局部变量，每个线程有各自独立的栈
运行数据：
线程的逻辑代码
方法一： extends Thread
方法二： implements Runable
Runnable接口
创建线程
初始
就绪
运行
等待
阻塞
终止
线程状态
同步代码块
同步方法
线程安全
wait()； 等待
notify(); 唤醒
生产者消费者问题
线程通信
基本多线程
Executors(实现类)
ExecuterService(线程池接口)submit(Runnable)submit(Callable)
Executor（顶级接口）execute(Runnable)方法
创建线程池ExecutorService es=Executors.newFixeThreadPool(线程数量)//指定数量线程池newCachedThreadPool()//动态数量的线程池 newSingleThreadExecutor() //单线程池 ExecutorService es = Executors.newScheduledThreadPool(4);// 延时线程池**
线程池
相当于带有返回值的Runnable接口
Future<T> submit(Callable);
Callable接口
异步计算结果
用于接收submit(Callable)的返回值
.get()方法获得future的值//原理future进入无限期等待异步计算结果的完成
Future接口
比synchronized更加高级，显式定义，结构更加灵活
lock();开启锁
unlock();释放锁（处理异常时，写在finally中）
重入锁ReentrantLock：Lock的实现类，与synchornized用相同的排斥锁功能
//创建读写锁对象ReentrantReadWriteLock rw=new ReentrantReadWriteLock();
//创建读锁对象ReadLock readlock= rw.readLock();
//创建写锁对象WriteLock writelock= rw.writeLock();
ReentrantReadWriteLock:读写锁
Lock接口
高级多线程
Collections类方法将一个集合转换成线程安全的集合
CopyOnWriteArrayList
CopyOnWriteArraySet
初始容量默认为16段
通过分段锁确保线程安全
1.8之后采用CAS算法（乐观锁） ----悲观锁：synchornized（compare安定swap 比较交换算法）
ConcurrentHashMap
在JDBC中存储连接对象
ThreadLocal
ConcurrentLinkedQueue底层使用CAS算法，线程安全
ArrayBlockingqueue
LinkedBlockingQueue
BlockingQueue(接口)
Queue（接口）
线程安全的集合
多线程
File file=new File(\"文件路径\")(路径必须存在)
file.creatNewFile();//创建文件
文件类
File dir=new File(\"多级文件夹\")
dir.mkdirs();//创建多级文件夹
文件夹操作
流的概念：内存与存储设备之间传输数据的通道
输入流：从存储设备向内存传输
输出流：从内存向存储设备传输
一次读一个字节
一次读一组字节
FileInputStream字节节点输入流(文件字节输入流)
InputStream
FileOutputStream字节节点输出流
OutputStream
字节流：以字节为单位，能读写所有数据
FileReader字符节点输入流（文件字符输入流）
Reader
FileWriter字符节点输出流（文件字符输出流）
Writer
字符流：以字符为单位，只能读写字符数据
节点流：具有直接传输数据的读写功能
BufferedInputStream（）没啥意义字节过滤输入流
读取文件中存入的Java数据
ObjectInputStream对象过滤输入流
.flush();//刷新缓冲池
.close();//关闭缓冲池，级联刷新
BufferedOutputStream（字节节点流对象）字节过滤输出流
输出Java中的数据类型（将数据写入文件，并非文本）
将一个Object类型写入文件，该类必须实现可序列化接口（Serializable）
ObjectOutputStream（字节节点流对象）对象过滤输出流（序列化）
PrintSteam(.print(97)
字节打印流
BufferedReader（字符节点流对象）字符节点过滤输入流
将文件字节流转换为文件字符流
转换流
BufferedWriter字符节点过滤输出流
PrintWriter (.print(97))
打印流
过滤流（装饰类）：在节点流的基础上增强功能
流的分类
对象必须实现Serializable接口
必须保证类的所有属性都可以序列化
transient修饰的属性为临时属性，不能序列化
静态属性不能序列化
读到文件末尾会抛出EOF异常，不是-1
序列化：从内存中将一个对象写入文件中（反之叫做反序列化）
IO框架
网络编程
反射：通过反射机制获取类对象，并使用类对象的方法，获得类的个方法和属性等
类对象：封装了一个类的全部信息（属性，方法，构造方法等）
通过类的对象： s.getClass();
通过类名： 类名.class；
通过静态方法获取： Class.forName(\"包名.类名\")
获取类对象
类对象.constructors();--全部构造方法
Construct<?> con=类对象.constructor();---获取无参构造方法
类对象.getMethods();-----全部方法
Method method=类对象.getMethod(\"方法名\");------无参方法
类对象.getMethod(\"方法名\"，参数类型.class);------带参方法
实例方法
类对象.getDeclareMethod(\"方法名\")
使用前 method.setAccessible(true)；
获取私有方法
method.invoke(对象)-----无参方法
method.invoke(对象，实参)-----带参方法
使用实例方法（非私有，非静态）
获取类对象的方法
（拆箱，向下转型）构造方法对象.newInstance();
（Student）类对象.newInstance（）；（Student）类对象.newInstance（实参，实参）；
获得一个对象
类对象.getFields();---全部属性
Field field=类对象.getField();----公开属性
类对象.getDeclareField()----私有属性
获取属性
field.set(对象，实参)；---公开
field.setAccessible(true);--可修改的field.set(对象，实参)-----私有属性会破会类的封装行----解决方法（内省技术）
为属性赋值
反射技术
内省：采用反射机制实现对属性进行操作font style=\
PropertyDescriptor pd1=new PropertyDescriptor(\"属性名\
Method method=pd1.getWriteMethod();----获得设置方法（实则调用set方法）
method.invoke(对象，实参)-----赋值操作
内省
开闭原则：扩展开放，修改关闭
通过反射进行工厂模式的设计
工厂设计模式（负责创建对象）
饿汉式：类加载时创建，天生线程安全
懒汉式：使用时创建，线程不安全，加同步
单例设计模式
枚举是一个引用类型，规定了取值范围的数据类型
font color=\"#943e3e\" data-darkreader-inline-color=\"\" style=\"--darkreader-inline-color:#943e3e;\
终止类，继承了Enum抽象类
枚举中的常量时当前类型的静态常量
本质
枚举
一般代替配置文件
常见注解@Override，@Deprecated
定义注解使用@interface关键字---注解中只能包含属性。
注解Annotation
反射
实质：特殊的匿名内部类，语法更简洁允许把一个函数作为方法的参数。
lambda表达式
函数式接口
方法引用
Stream流
新时间API
jdk8新特性
JavaSE知识点总结
0 条评论
回复 删除
下一页
