javaSE基础重点知识点解析

---

---

前言

以下是本篇文章正文内容，如有表达不全的问题还请指出，本文中插入的图片部分由网上下载，如涉及版权问题联系我删除！！！！，持续更新中！！！！

---

1、重载和重写

重载	同一个类	方法名相同，参数不同，返回值可以不同
重写	子类继承父类	方法名相同，参数相同，返回值相同

2、匿名对象

没有名字的对象，eg：new Phone().sendEmail();适用于只用一次的场景。

3、可变个数形参的方法

public void show（string…strs）{ } 个数不限

4、MVC设计模式

视图层V—>控制层C---->数据模型层M
降低程序耦合性

5、java.lang.Object类

所有类都直接或间接继承Object类，继承它所有的功能。

6、自动装箱、自动拆箱

自动装箱	基本类型转包装类	int n = 10; Integer m = n;
自动拆箱	包装类转基本类	int n = 10; Integer m = n; int j = m;

自动装箱：
Integet m = new Integer(10);
Integet n = new Integer(10);
if (m == n) 是不等的

Integet m = Integet.valueOf(10);
Integet n = Integet.valueOf(10);
if (m.equals(n) ) 相等

自动拆箱：
Integer i = new Integer(10);
int j = i.intValue();
int j = i;

7、static、final关键字

final	最终类，修饰方法	不能被继承，不能被子类重写
static	静态的 ，修饰属性、方法、代码块、内部类	类创建的所有对象都共享同一个静态变量，如下图

class Test {public static void main(String[] args) {// 创建第一个 Student 对象，并赋值Student s1 = new Student();s1.name = "小明";s1.country = "中国";// 创建第二个 Student 对象Student s2 = new Student();System.out.println(s1);System.out.println(s2);}
}class Student {//非静态属性public String name;//静态属性public static String country;//无参构造public Student() {}//toString 方法@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +"country='" + country + '\'' +'}';}
}

输出
Student{name='小明’country=‘中国’}
Student{name='null’country=‘中国’}

8、程序、进程、线程

程序	静态代码	/
进程	正在运行的程序	比如启动杀毒软件
线程	程序内部一条执行路径	杀毒软件可以同时进行电脑体检、清理、杀毒说明支持多线程；java.exe进程包括main主线程、gc线程、异常处理线程，异常会影响主线程

9、并行、并发

并行	多个人同时做不同事
并发	多个人同时做同一件事，比如秒杀

10 、何时需要多线程

• 同时执行两个或多个任务
• 有需要等待的任务：用户输入、文件读写、网络操作、搜索等
• 需要一些后台运行的程序

实现方法	实现过程
继承Thread类	1、创建子类，继承Thread类 2、重写run() 3、创建子类对象 4、对象.start()
实现Runnable方法	1、创建实现Runnable方法的类 2、实现run()方法 3、创建Thread对象，将类作参数传过去 4、Thread.start(); 好处： 1、继承Thread类：如果本身就继承的有其他父类，就没办法继承Thread类了，有局限性，通常都会选Runnable方法； 2、实现的方式更适合来处理多个线程共享数据的情况
实现Callable接口	1、创建一个实现Callable的实现类 2、实现call方法，将此线程需要执行的操作声明在call()中 3、创建FutureTask的对象，将类作参数传过去 4、创建Thread对象，Thread(FutureTask的对象).start() 5、get()获取Callable中call方法的返回值 好处： 1、call()可以有返回值、可抛异常供外部捕获，而run()没有； 2、Callable接口支持泛型：implements Callable< Integer >通过指定泛型，call()方法的返回值就会有类型
使用线程池	1、提供指定线程数量的线程池 2、执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象 3、关闭连接池 好处： 1、便于线程管理 ，提高响应速度， 2、重复利用线程池中线程，不需要每次都创建，降低资源消耗

// 继承Thread类
// 主线程public class thread_test{public static void main(String[] args){ThreadTest1 threadTest1 = new ThreadTest1();ThreadTest2 threadTest2 = new ThreadTest2();threadTest1.start();threadTest2.start();System.out.println("3333");}
}
// 子线程1
class ThreadTest1 extends Thread {@Overridepublic void run() {System.out.println("11111");}
}
// 子线程2
class ThreadTest2 extends Thread {@Overridepublic void run() {System.out.println("2222");}
}

输出
3333
2222
11111

// 实现Runnable方法
public class runnable_test {public static void main(String[] args){Thread thread = new Thread(new RunnableTest());thread.start();}
}class RunnableTest implements Runnable{@Overridepublic void run() {System.out.println("111111");}
}

// 实现Callable接口
//1.创建一个实现Callable的实现类
class NumThread implements Callable {//2.实现call方法，将此线程需要执行的操作声明在call()中@Overridepublic Object call() throws Exception {return "11111";}
}
class callable_test {public static void main(String[] args) {//3.创建FutureTask的对象，将类作参数传过去FutureTask futureTask = new FutureTask(new NumThread());//4.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()new Thread(futureTask).start();try {//5.get()获取Callable中call方法的返回值Object ss = futureTask.get();System.out.println(ss);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}
}

public class Executor_test {public static void main(String[] args) {// 1. 提供指定线程数量的线程池ExecutorService service = Executors.newFixedThreadPool(5);ThreadPoolExecutor threadPool = (ThreadPoolExecutor) service;// 设置线程池的属性threadPool.setCorePoolSize(15); // 核心池的大小threadPool.setMaximumPoolSize(20); // 最大线程数
//        threadPool.setKeepAliveTime(); // 线程没任务时最多保持多长时间后会终止// 2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象threadPool.execute(new executorTest1()); //execute: Runnable接口threadPool.execute(new executorTest2());try {//submit: Callable接口,需要用get获取返回值，顺便捕捉异常Future<Integer> i = threadPool.submit(new executorTest3());System.out.println(i.get());} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();};// 3.关闭连接池service.shutdown();}
}class executorTest1 implements Runnable {@Overridepublic void run() {System.out.println("1111");}
}class executorTest2 implements Runnable {@Overridepublic void run() {System.out.println("222");}
}class executorTest3 implements Callable<Integer> {@Overridepublic Integer call() throws Exception {return 10;}
}

关于线程的方法：

run()	被重写的方法
start()	启动线程，调用当前线程run()
getName()、setName()	得到、设置线程名字
yield()	释放当前cpu的执行权
currentThread()	返回当前线程
join()	在线程a中调用线程b.join()，让线程a等待线程b执行结束之后再运行，等待时线程a进入阻塞状态
sleep(Long millitime)	睡眠指定毫秒，睡眠时程阻塞状态
stop()	结束线程
isAlive()	是否启动
getPriority()、setPriority())	优先级
notify()、notifyAll())	唤醒一个正在等待的线程

线程生命周期

11、线程调度

同优先级先进先出
高优先级的线程会抢占cpu

12、线程安全怎么解决

像两个人同时在同一账户取钱，可能会发生线程安全问题
解决：同步机制
1、同步机代码块
2、同步方法
同步是一种高开销的操作，因此应该尽量减少同步的内容，通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可

同步机代码块	synchronized(同步监视器){ //需要同步的代码 }
同步方法	public synchronized void save(){}
特殊域变量(volatile)	public synchronized void save(){}
lock() : 获得锁	Lock lock = new ReentrantLock(); lock.lock(); Lock是接口，要手动解锁unclock
ThreadLocal	解决多线程中相同变量的访问冲突问题

synchronized	但是容易造成资源的浪费，是一种重量锁
volatile	轻量锁，锁住的是变量，不会阻塞线程，只能保证可见性，不保证原子性

synchronized	中途不能控制
lock	可控制、释放锁，非公平锁

同步机代码块 说明：
1.操作共享数据的代码，即为需要同步的代码 -->不能包含多了代码也不能包含少了。
2.共享数据：多个线程共同操作的变量。比如ticket就是共享数据
3.同步监视器,俗称：锁。任何一个类的对象都可以充当锁
要求：多个线程必须共用同一把锁（同一个对象）
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器

// synchronized同步代码块
public class synchronized_test {public static void main(String[] args) {// 创建三个不同线程对象ThreadTest threadTest = new ThreadTest();Thread thread1 = new Thread(threadTest);Thread thread2 = new Thread(threadTest);Thread thread3 = new Thread(threadTest);thread1.start();thread2.start();thread3.start();}
}class ThreadTest implements Runnable {private Integer num = 50;@Overridepublic void run() {while (true) {//this代表的唯一的当前对象,将共享操作synchronizedsynchronized (this) { if (num > 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + ":" + num);num--;} else break;}}}
}

13、String不可变与String拼接

参考https://blog.csdn.net/weixin_38004638/article/details/115012897

14、toCharArry():String转换为char[]

15、getBytes():String转换为byte[]

16、String、StringBuffer、StringBuilder区别

String	不可变	/	/	操作少量数据
StringBuffer	可变,初始容量16，扩容机制都是"旧容量*2+2"	线程安全synchronized	效率低	适合多线程，并发量小，
StringBuilder	可变,初始容量16	线程不安全	高	速度快，一般都是单线程，用这个好点，线程安全问题可以通过ThreadLocal解决，可用于高并发

扩容机制：

17、枚举列出一组确定的常量的类

比如星期类、季节类、性别类

自定义类实现枚举：

1. 将构造器私有化，目的是防止被new出对象
2. 去掉 setXxxx() 方法，防止属性被修改
3. 在Season内部，直接创建固定对象
4. 对外暴露对象(通过为对象添加 public static final 修饰符)

public class Demo03 {public static void main(String[] args) {System.out.println(Season.AUTUMN);System.out.println(Season.SUMMER);}
}
class Season{private String name;private String desc;//定义了四个对象//加final是为了使引用不能被修改public static final Season SPRING = new Season("春天", "温暖");public static final Season WINTER = new Season("冬天", "寒冷");public static final Season SUMMER = new Season("夏天", "炎热");public static final Season AUTUMN = new Season("秋天", "凉爽");private Season(String name, String desc) {this.name = name;this.desc = desc;}
​public String getName() {return name;}public String getDesc() {return desc;}@Overridepublic String toString() {return "Season{" +"name='" + name + '\'' +", desc='" + desc + '\'' +'}';}
}

输出：
Season{name=‘秋天’, desc=‘凉爽’}
Season{name=‘夏天’, desc=‘炎热’}

使用enum关键字实现枚举：

1. 使用 enum 关键字代替 class
2. 常量对象名(实参列表)
3. public static final Season2 SPRING = new Season2(“春天”, “温暖”); 等价于 SPRING(“春天”, “温暖”);
4. 如果有多个对象，需要使用 ，间隔
5. 如果使用 enum 关键字来实现枚举，要求将定义的常量对象写在最前面

public class Demo04 {public static void main(String[] args) {System.out.println(Season2.SPRING);System.out.println(Season2.SUMMER);}
}
enum  Season2{SPRING("春天", "温暖"),WINTER("夏天", "炎热"),SUMMER("夏天", "炎热"),AUTUMN("秋天", "凉爽");
​private String name;private String desc;
​private Season2(String name, String desc) {this.name = name;this.desc = desc;}public String getName() {return name;}public String getDesc() {return desc;}@Overridepublic String toString() {return "Season{" +"name='" + name + '\'' +", desc='" + desc + '\'' +'}';}
}

18、java注解

自定义注解实现拦截器和日志打印功能参考
https://editor.csdn.net/md/?articleId=126342182

@deprecated	修饰的类、方法已过时
@SuppressWarnings	抑制编译器警告
@Repeatable	可重复注解

其他注解参考https://blog.csdn.net/qq_45807943/article/details/116980851

19、AOP与IOC

AOP：面向切面编程，缩写：Aspect-oriented Programming
IOC：控制反转，一个容器
DI：依赖注入，是控制反转的实现。依赖什么对象就注入什么对象。可以通过setter方法注入（设值注入）、构造器注入和接口注入三种方式来实现

反转：不能主动去获取外部资源，而是被动等待 IoC/DI 容器给它注入它所需要的资源。
为什么要反转：解耦

参考https://baijiahao.baidu.com/s?id=1677252147318999232&wfr=spider&for=pc

setter注入对象：

构造器注入：

除了上面的手动注入，还可以通过主动装配与注解注入：

@Resource：java的注解，默认以byName的方式去匹配与属性名相同的bean的id，如果没有找到就会以byType的方式查找，如果byType查找到多个的话，使用@Qualifier注解（spring注解）指定某个具体名称的bean

@Autowired：spring注解，默认是以byType的方式去匹配与属性名相同的bean的id，如果没有找到，就通过byName的方式去查找

@Inject

参考https://blog.csdn.net/shangliangren/article/details/123932809

20、java集合（Collection和Map）

集合体系	结构
Collection接口	单列集合，存储一个一个的数据
Map接口	双列集合，存储key-value一对一对的数据

6在这里插入图片描述
PressOn链接https://www.processon.com/view/link/5e61cb68e4b0a967bb396f06

Collection接口方法

retainAll()	两个数组交集
stream()()	流	jdk8新方法
parallelStream()	并行流	jdk8新特性
spliterator()()	并行流分割器	jdk8新特性
removeIf()	如果满足就lambda方式移除元素	jdk8新特性

List接口方法

subList(0, 1)	截取集合中的部分元素
sort()	排序
listIterator()	迭代器

ArryList接口方法

clone()	克隆
ensureCapacity(N)	预先设置list的大小,自动扩容1.5倍
trimToSize()	将动态数组中的容量调整为数组中的元素个数，减少数据空间

ArrayList有三种初始化方法：
1、初始化一种指定集合大小的空ArrayList;
2、初始化一个空的ArrayList;
3、初始化一个含有指定元素的ArrayLsit。

LinkedList接口方法

addFirst()/addLast()	头部插入特定元素
descendingIterator()	按相反的顺序迭代
element()/getFirst()/peek()	返回第一个元素
element()/getFirst()	返回第一个元素
indexOf()	查找指定元素从前往后第一次出现的索引
offer()	向链表末尾添加元素
poll()	删除并返回第一个元素
pop()	弹出一个元素
push()	压入元素
poll() ()	删除并返回第一个元素
pop()	弹出一个元素

Map接口方法

compute()	对 hashMap 中指定 key 的值进行重新计算
containsKey()	包含key
containsValue()	包含value
entrySet()	返回 hashMap 中所有映射项的集合
keySet()	返回 hashMap 中所有 key 组成的集合
merge()	合并
replace ()	替换

其他方法参考https://www.runoob.com/java/java-arraylist.html

数组转换为集合：Arrays.asList(数组名)
集合转换为数组：list.toArray();

21、collection和collections的区别

collection：集合；
Collections：是一个工具类，它包含了很多静态方法，不能被实例化，比如排序方法： Collections. sort(list)等。

Collections.addAll(单值类型集合,元素1,元素2,元素3);Collections.sort(list集合);Collections.sort(list集合,比较器对象)Collections.reverse(list集合); // 降序排序让线程不安全的变成安全的:
Collections.synchronizedList(list集合);
Collections.synchornizedSet(set集合);
Collections.synchronizedSortedSet(sortedSet集合);
Collections.sycchronizedCollection(collection集合);

22、IO流体系与序列化

1、文本文件（.txt，.java ，.c ，.cpp），使用字符流
2、非文本文件（.jpg，.mp3，.doc，.ppt），用字节流。

版权声明：下面关于序列化的知识点由CSDN博主「Be a good programmer」的原创文章，遵循 CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xiaoxinxin123456789/article/details/83545946

序列化：（从内存中的数据传到硬盘中）
1、序列化能把堆内存中的对象的声明周期延长，做持久化操作，当下次再需要这个对象的时候，我们不用new了，直接从硬盘中读取就可以了（存储到硬盘上的是一个文件，不需要我们再去解析了，如果用记事本打开解析会出现乱码，解析要用特定的方式，不用我们管，我们只能需要读取）

MyBatis 的二级缓存，实际上就是将数据放进了硬盘文件中去了。

2、在搞web开发的时候一些类就需要实现序列化接口，因为服务器就会对你的对象进行临时本地存储，他怕服务器崩了的以后，你的会话都消失了，所以存储在硬盘上，你重新启动服务器会恢复之前的会话，回复对象，你之前运行的东西还会在。

序列化API：
1、java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

2、java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

3、只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为。

4、而仅实现Serializable接口的类可以 采用默认的序列化方式 。

对象序列化步骤：

1、创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
2、通过对象输出流的writeObject()方法写对象。

对象反序列化步骤：

1、创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
2、通过对象输入流的readObject()方法读取对象。

// 对象序列化Employee e = new Employee();e.name = "Reyan Ali";e.address = "Phokka Kuan, Ambehta Peer";e.SSN = 11122333;e.number = 101;try{FileOutputStream fileOut =new FileOutputStream("D:/学习文件/百度网盘下载资料/employee.ser");// 1、创建对象输出流，它可包装一个文件输出流ObjectOutputStream out = new ObjectOutputStream(fileOut);// 调用writeObject()方法将创建好的Employee对象写入流中out.writeObject(e);// 关闭各种流out.close();fileOut.close();System.out.printf("Serialized data is saved in /tmp/employee.ser");}catch(IOException i){i.printStackTrace();}

// 反序列化Employee e = null;try{FileInputStream fileIn = new FileInputStream("D:/学习文件/百度网盘下载资料/employee.ser");// 1、创建对象输入流，它可包装一个文件输入流ObjectInputStream in = new ObjectInputStream(fileIn);// 2、用readObject()方法读取流中的对象出来e = (Employee) in.readObject();// 关闭各种流in.close();fileIn.close();}catch(IOException i){i.printStackTrace();return;}catch(ClassNotFoundException c){System.out.println("Employee class not found");c.printStackTrace();return;}System.out.println("Deserialized Employee...");System.out.println("Name: " + e.name);System.out.println("Address: " + e.address);System.out.println("SSN: " + e.SSN);System.out.println("Number: " + e.number);

23、java8、9、10、11新特性

24、设计模式分类

25、数据结构

数据结构参考：https://zhuanlan.zhihu.com/p/337183238

26、反射

27、数据源分类

原生态：JDBC
封装：dbcp,c3p0,druid

Spring 推荐使用dbcp；
Hibernate 推荐使用c3p0和proxool

28、idea查找快捷鍵、继承关系快捷键

搜索类、文件：双shift、ctrl+shift+n
查看类继承关系：列表: ctrl+H；​ 图示: ctrl+alt+shift+U

29、数据库事务

• 事务：数据库操作
• 这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行。如果任何一个SQL操作失败，那么整个操作就都失败，所有操作都会回滚到操作前状态，或者是上一个节点
• 用 Connection 对象控制

关于事务，举个例子：
例如以银行转账为例，从原账户扣除金额，以及向目标账户添加金额，这两个阶段的操作，被视为一个完整的逻辑过程，不可拆分。
简单的说，要么全部成功，要么全部失败！这个过程被称为一个事务，具有 ACID 四个特点！

事务的特性：ACID
1、原子性（Atomicity）：
事务是一个完整的操作。事务的各步操作是不可分的（原子的）；要么都执行，要么都不执行。
2、一致性（Consistency）：
当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状态。
3、隔离性（Isolation）：
对数据进行修改的所有并发事务是彼此隔离的，这表明事务必须是独立的，它不应以任何方式依赖 于或影响其他事务。
4、持久性(Durability)：
事务完成后，它对数据库的修改被永久保持，事务日志能够保持事务的持久性。

并发操作的几个问题：

（1）脏读：A操作a数据，还未提交，B又来操作它并提交了（A读的是脏数据）；
（2）不可重复读：A读取一个记录后，B立马修改了这条数据，A再读就变了，（update操作）
（3）幻读：A读取了某个范围的数据，B在此范围内插入一条数据，A再次读取，结果不一样（insert操作）

隔离级别：
（1）Serializable (串行化)：可避免脏读、不可重复读、幻读的发生。
（2）Repeatable read (可重复读)：可避免脏读、不可重复读的发生。默认。
（3）Read committed (读已提交)：可避免脏读的发生。
（4）Read uncommitted (读未提交)：最低级别，任何情况都无法保证。

30、活锁、死锁

类型	例子	必要条件	解决办法
死锁	迎面而来两个或多个汽车，互不谦让，一直堵着路口，导致交通瘫痪，很粗鲁	互斥、竞争占有、不可抢占、循环等待	重启应用，或破坏4大条件中一条即可
活锁	两个独木桥上相遇的人，互相谦让让对方先走，很绅士	可能自行解开，死锁则不能	两者等待一个随机的时间再执行
饥饿	一个年轻人在独木桥这头，对面是一个老人，让他先过桥，没想到后面还有一堆老人，只能一直等他们全部过桥，绅士过头了	一个可运行的进程尽管能继续执行，但被调度器无限期地忽视	通过先来先服务等资源分配策略来避免

参考例子https://blog.csdn.net/ZW547138858/article/details/83269342
参考代码https://blog.csdn.net/weixin_42740530/article/details/105844160

31.公平锁、非公平锁

公平锁	先等待先获取锁
非公平锁	先等待也不一定先获取锁

32.乐观锁、悲观锁|排它锁、共享锁、读锁写锁

类型	概念		例子
乐观锁	认为数据一般不会发生冲突，用户提交时再判断，有冲突就返一些错误信息给用户自己处理	读多写少	给表加一个版本号或时间戳，版本号相等就更新，否则拒绝操作	性能差
悲观锁	总认为会发生并发冲突，在整个数据处理过程中，需要将数据锁定	写多读少	通常依靠数据库提供的锁机制实现，比如mysql的排他锁，select … for update来实现，先上锁然后再处理数据的保守策略 （Synchronized、行锁表锁读锁写锁等）	安全，效率低

共享锁	读锁	可同时读
排它锁	写锁	不能与其他锁并存

mysql中的行级锁是基于索引的，如果sql没有走索引，那将使用表级锁把整张表锁住

参考https://m.php.cn/article/480427.html
参考https://blog.csdn.net/weixin_39900180/article/details/111689465

33.堆、栈

类别	内存分配	大小	分配效率
堆	系统释放回收，可能内存泄漏	虚拟空间很灵活	new分配，慢
栈	编译器自动分配和释放	win系统2M	自动分配，快

34.get、post

get	url后带参数以？拼接，用作获取数据
post	参数无限制，放http请求包中，用作提交数据

34.forward、redirect

forward	服务器跳转，浏览器地址不变，转发是带着转发前的请求参数。 服务器forward到jsp
redirect	浏览器跳转，浏览器地址变了，是新情求 一个jsp到另一个jsp

35.hashcode和equals

• equals相同，hashcode一定相同
• equals不相同，hashcode能同/不同
• hashcode相同，equals可能同/不同
• hashcode不相同，equals一定不同

36.isonp跨域

37.spring-boot特点

1. 约定大于配置
   1. 默认读取properties/yml文件
   2. 嵌入式servlet容器，应用无需打开war包
   3. starters自动依赖与版本控制
   4. DevTools将文件更改自动部署到服务器并重启
2. 自动配置原理
   1. SpringBootApplicaton
   2. EnablrAutoConfiguration
3. 继承mybatis过程
   1. 添加mybatis的starter maven依赖
   2. 在mybatis接口中，添加@Mapper注解
   3. Application.yml配置数据源
4. 核心注解
   1. SpringBootApplication启动类注解
5. 内置tomcat
6. 日志框架
7. 热部署

38.cookie、session

---

总结

以上就是今天要讲的内容，本文仅仅简单介绍了javaSE基础重点知识点的总结，有描述错误的地方请指出，感谢观看。

javaSE基础重点知识点总结 持续更新相关推荐

1. 前端(js/css/html)那些小的知识点，持续更新......

   前端(js/css/html)那些小的知识点,持续更新...... 1.行内元素与块级元素有哪些及区别? 块级元素和行内元素的区别是,块级元素会占一行显示,而行内元素可以在一行并排显示.通过样式控制, ...

2. PHP —— 一份前端开发工程师够用的PHP知识点（持续更新）

   PHP -- 一份前端开发工程师够用的PHP知识点(持续更新) <工欲善其事,必先利其器> 本文只是记录本小菜鸡在工作中遇到的知识点,欢迎大家随时补充! 一.初识 PHP 首先,PHP 它 ...

3. Ios-视频直播-知识点汇总-持续更新

   最近公司要求做视频直播,之前工作几年,视频一直都是弱项,没怎么接触过,现在正好有机会深入的去了解一下,记录一些遇到的坑和需要用到的东西. ~公司要求,用HLS协议,要求可以播放m3u8格式的,当时一听 ...

4. 关于js的一些常用小知识点（持续更新）

   关于js的一些常用小知识点 1.获取页面中所有选中的CheckBox复选框的值 2.js获取网页URL中所带的参数 3.js模拟点击button 4.前端传入后台list,后台是不能接收List的,就 ...

5. 中间件安全知识点记录-持续更新

   这是一个关于中间件安全的系列文章,后期会持续更新: 一.首先,抛出中间件的概念 所谓中间件,就是位于操作系统和应用软件之间的一个软件层,它向各种应用软件提供服务,使不同的应用进程能在屏蔽掉平台差异的情 ...

6. 计算机网络基础+重点知识点

   计算机网络重点知识点 1.在数据链路层使用MAC地址标识一台主机,在IP层用IP地址标识一台主机.注:由于前面表明了MAC地址,所以这里不可以写主机号. 2.数据交换技术包括电路交换.报文交换.分组交 ...

7. C及C++中的一些基础知识点（持续更新）

   一.标识符命名: 标识符指的是函数名,变量名 1.只能包含数字.字母以及下划线,不能包含其他特殊字符 2.只能以字母或下划线开头 3.不能以系统已有的关键字重名 二.常见类型的字节占用空间: 可以使用 ...

8. Hadoop大数据基础知识点总结--持续更新

   什么是大数据 数据量很大的数据就是大数据 数据集的大小已经远远超过了现有传统的技术方案(数据库)或工具可以处理能力的数据 大数据的特点 海量化数据量大 TB ---> PB 多样化数据类型复杂多 ...

9. python课程知识点总结（循环结构~列表）（0基础学习，后持续更新）

   五.循环结构 1.内置函数 range函数 range的三种创建方式 只有一个参数(小括号中只给了一个数) r=range(10) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ,默 ...

最新文章

1. R语言使用randomForest包构建随机森林模型的步骤和流程、随机森林算法包括抽样样本（观察）和变量来创建大量的决策树（多个树，构成了森林，而且通过样本抽样和变量抽样，让多个树尽量不同）
2. 删除表中存在多条相同记录的方法
3. testNg自动化，读取excel的数据
4. deepin linux桌面设置,在Deepin Linux桌面创建快捷方式
5. Delphi 控制摄像头
6. 【做题记录】[NOIP2016 普及组] 魔法阵
7. JavaScript中带有示例的Math.PI属性
8. 导航无限级菜单 java,Element NavMenu 无限级菜单
9. Linux netfilter源码分析(7)
10. php mysql销售_计算用于销售应用程序的php / mysql中的损益（每日，每月和每年）...
11. 写表单验证等页面的总结
12. 锐界机器人_每72秒就有一辆锐界驶下生产线
13. Nacos集群（一）节点启动初始化源码解析
14. java班级学生列表_java学生班级管理系统+源代码+截图.doc
15. Java与网络调试助手TCP通信
16. 新能源车牌识别算法，助力车牌识别核心升级
17. 如何批量等比例缩放图片尺寸？
18. joycon手柄拆解_任天堂switch手柄怎么拆解图文教程 教你如何拆joycon
19. PM00-愿景, 战略和项目
20. python时间复杂度和空间复杂度是指,时间复杂度与空间复杂度

热门文章

1. Word2019修改背景色失效的解决方法
2. 读完这本书打通了“数据化运营”的任督二脉
3. 万兴剪刀手去水印教程_万兴神剪手怎么去水印教程_赶快收藏吧
4. 【STM32】时钟系统RCC
5. 【B站】Java自学精选视频，Java全套资源奉上，收藏起来慢慢学
6. 贷还是不贷：如何用 Python 和机器学习帮你决策？
7. 问题描述：宏代码导致无法打开文件
8. 【对称加密与非对称加密】-- 概念、图示、优缺点
9. h5调起QQ客服的坑（PC端、移动端）
10. c语言数据类型int的用法,C语言基本数据类型:整型(int)用法详解|C语言学习