java知识点概要

1.Java语言的跨平台性 原理

2.Java的两个核心机制 JVM GC

3.JVM的运行原理(Java程序的执行流程)

4.JDK、JVM、JRE之间的关系

5.成员变量和局部变量(作用域不同)

1.定义的位置不一样
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中
2.作用范围不一样
局部变量：只有方法当中才可以使用，出了方法就不能再用了
成员变量：整个类都可以通用
3.默认值不一样
局部变量：没有默认值，如果要想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
4.内存的位置不一样
局部变量：位于栈内存
成员变量：位于堆内存

6.基本数据类型和引用类型(String、类、接口、数组)

7.流程控制语句

if else switch while dowhile for

8.数组（集合）

9.排序(冒泡排序、选择排序、快速排序)

10.作用域(类和局部)

12.面向对象

类
对象
访问修饰符

13.Java的内存结构(栈、堆、方法区)

14.面向对象的三大特性 封装、继承、多态

15.继承

–优点：提升了代码的复用性
–缺点：由于继承会有多层继承关系，层级结构非常复杂，会提高了他们之间的依赖性。

16.this和super

1.当创建子类对象时，会调用父类的空参构造器 super()
–super可以通过子类构造器调用父类的构造器，可以初始化父类的成员属性。
2.super可以调用父类的非私有方法。
3.super和this同时存在的时候，一定先使用super调用父类的构造器，初始化服了的成员属性，再使用this关键字初始化子类的成员属性。
4.所有的子类默认都会调用父类的空参构造器

–this:当前对象（子类对象）
–super：代表的是父类对象

17.方法重载overload和方法重写override的区别

①.方法重载要求在同一个类中
②.方法重写要求必须存在继承关系（子类和父类 is-a）
③.方法重载要求方法名相同、形参列表不同（类型和数量不同）和返回值类型没有关系
④.方法重写要求方法名相同、形参列表相同、返回值类型相同

18.多态

1.多态的理解
①.同一个动作作用于不同的对象产生的不同行为
②.多态就是一个对象的多种表现形式

2.多态的优点：
①.降低了程序之间的耦合度
②.提高了程序的可扩展性

3.多态的类型
①.编译时多态：静态的 方法重载（在编译期间，调用相同的方法名根据不同的形参列表来区分）
②.运行时多态：动态的 只有在运行期间才能确定使用的对象类型，才能确定变量的引用指向的是哪个实例

4.多态的必要条件
①.继承:存在继承关系的子类和父类
②.方法重写：子类重新定义父类的方法（方法的覆盖）
③.向上转型：父类的引用指向子类的实例，Person p = new Man();

5.多态的体现方式
①.基于继承的体现方式
②.基于接口的体现方式

对象的多态：
1.将父类的引用指向子类的实例
2.在编译时调用父类的方法，在执行时调用子类的方法
3.编译时看左边，运行时看右边

19.抽象类

抽象类和接口的不同？

20.接口

接口的优点 概念

21.equals()方法和==区别

1.针对基本数据类型 ==是比较数值是否相等
2.针对引用数据类型 ==是比较引用地址是否相等
3.equals方法是object类的方法 它的底层实现是使用== 比较地址值
4.所有的类都可以重写equals()方法

22.final关键字

1.final修饰的类不能被继承
2.final修饰成员属性是常量(不能重新赋值)
常量的命名规则：全部大写 如果有多个单词组成 中间使用下划线隔开
常量是存储在常量池中
3.final修饰的方法不能被重写

23.StringBuffer和StringBuilder

StringBuffer
①.支持可变长度
②.可以修改字符串
③.线程安全的
④.效率低

StringBuilder
①.线程不安全
②.效率高

24.线程安全

一个资源在可以被多个线程中对象访问的时候，不会出现任何冲突，这种情况就是线程安全。
造成线程不安全的因素：存在多个线程同时修改一个共享资源。

25.包装类

包装类本质是一个对象，装箱时先在堆中new一个对象，再将基本数据类型的值赋给该对象的value

26.装箱和拆箱

装箱：基本数据类型—>对应包装类(int —> Integer)
拆箱：包装类—>对应的基本数据类型(Integer —> int)

27.随机类

28.集合

遍历集合：

• 1.使用迭代器Iterator实现
• 2.使用增强for循环
• 3.使用for循环
• 4.将集合转化为数组(toArray),再进行遍历

29.主要接口Collection Map

30.List 和Set接口

List
1.List接口是Collection接口的子接口
2.List它是有序的集合，存储元素和取出元素顺序是一致的(存abc 取abc)
3.有索引，包含了一些带索引的方法(底层实现是使用数组，它是一个可变数组)
4.允许存储重复的元素
5.List接口的主要实现类：ArrayList

Set
1.Set接口是继承于Collection
2.Set堆中存储的数据是无序的(不代表乱序)
3.Set中存储的数据是不可重复的：当Set中添加相同的元素，只能添加一个元素。
4.添加进Set中的元素一定要重写equals和hashCode方法

31.ArrayList和LinkedList

1. ArrayList的实现是基于数组来实现的，LinkedList的基于双向链表来实现。
2. 对于随机访问，ArrayList优于LinkedList。
3. 对于插入和删除操作，LinkedList优于ArrayList
4. LinkedList比ArrayList更占内存。

32.ArrayList和Vector

33.HashSet和LinkedHashSet

6.HashSet
①.HashSet是Set接口的主要实现类。
②.HashSet是采用哈希算法存储集合的元素，因此有很多存取和查询性能(底层数据结构是哈希表)
哈希表：综合数组和链表的优点（一个链表的数组）
③.HashSet不能保证元素的排列数据，顺序和添加的顺序不一致
④.内部存储机制：HashSet集合判断两个元素的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode值也相等。确保元素的唯一性。
⑤.为什么不使用数组而使用HashSet?
1).HashSet通过哈希值确定存储位置，可以自由的增加长度，并根据哈希值访问元素，不能挨个遍历索引去访问

7.LinkedHashSet
①.LinkedHashSet是HashSet的一个子类
②.LinkedHashSet是用链表维护元素的顺序
③.输出集合元素时元素顺序和添加顺序一致的

34.Set的存储机制

35.Map

存放的数据是键值对(key-value)数据
①.key：Map中的键 它是不能重复，底层实现是采用Set
②.value:Map中的值 可以重复，底层实现是采用Collection(List)
③.Map实际上是提供了一个Entry内部类里封装key-value

Map的遍历

• 1.Map中的key是使用Set存储,不可重复
• 2.Map中的value使用Collection来存放，可以重复
• 3.一个键值对（key-value）,就是一个Entry,Entry是使用Set来存放，也是不可重复。
• 4.当向Map中添加元素时，会调用key所在类的equals()方法，判断两个key是否相同，如果相同，则添加后面的元素

36.HashMap和LinkedHashMap

Hashmap 是一个最常用的Map,它根据键的HashCode值存储数据,根据键可以直接获取它的值，具有很快的访问速度，遍历时，取得数据的顺序是完全随机的。

LinkedHashMap 是HashMap的一个子类，保存了记录的插入顺序，在遍历LinkedHashMap时，先得到的记录肯定是先插入的，在遍历的时候会比HashMap慢

37.泛型

1.泛型是JDK1.5出现的安全机制
2.避免了强制类型转化
3.限制了数据类型，保护了数据类型的安全
4.将运行期间引发的异常转到了编译期间。

38.函数式编程

39.Lambda

40.异常的体系结构 Throwable

41.Exception

42.如何处理异常 try-catch-finally throws throw+异常对象

43.throws和throw的区别

throw：程序员手动处理异常
throws：在方法后面声明抛出异常

44.多线程

45.进程和线程的区别

进程：
是系统进行资源分配和调度的基本单位

线程：
是进程的一条执行路径，一个进程至少有一个线程，进程中的多个线程共享进程的资源

46.多线程的概念

47.线程的两种调度方式

48.并行和并发

并发：
①.一个处理器同时处理多个任务(一个人同时去吃三个馒头)
②.通过cpu算法调度，让用户看上去是同时进行，实际上不是真正的同时，并发强调在一个时间段同时执行
而一个时间段是有多个单位时间组成，所以说并发的多个任务在单位时间内不一定在同时进行

并行：
①.多个处理器同时处理多个不同的任务（三个人同时吃一个馒头）
②.多个处理器或者多台机器同时执行一段处理逻辑，是真正的同时

49.共享资源 锁

50.线程安全

51.线程的生命周期

新建(New) -- 就绪(Runnable) -- 运行(Running) -- 阻塞(Blocked) -- 死亡(Dead)

①.新建状态：当程序创建好一个线程后，该线程就处于新建状态，此时JVM为其分配内存。
②.就绪状态：当线程对象调用start()方法后，该线程就处于就绪状态，等待cpu调度运行
③.运行状态：已经开始执行run()方法的线程执行体，该线程处于运行状态，cpu已经调度执行
④.阻塞状态：当运行状态的线程失去所占资源后，就进入阻塞状态
– 当线程调用sleep()方法时主动放弃CPU资源
– 线程想要获取同步监视器的时候，此监视器正被其他线程所持有。
– 线程在等待某个通知(notify)
⑤.死亡状态：线程在run()方法执行结束进入死亡状态。此外如果线程执行了interrupt(),(stop 已弃用)那么也会进入死亡状态。
那么也会计入死亡状态

52.线程通信

①.wait():令当前线程挂起并放弃cpu的控制权，使别的线程可以访问并修改共享资源。(等待)
②.notify():唤醒正在排队等待同步资源的线程。(单个线程)
③.notifyAll():唤醒正在排队等候资源的所有线程。(所有线程)
– 注意问题：
①.以上三个线程通信方法都不属于Thread类，是属于Object类，每个对象都拥有以上三个方法
因为每个对象都有锁，锁是每个对象的基础
②.当需要调用以上方法的时候，一定要对共享资源进行加锁，如果不加锁，则会引发IllegalMonitorStatteException异常
③.当想要调用wait()方法进行线程等待的时候，必须要取得这个锁对象的控制权(对象监视器)，一般是放到synchronized(obj)代码块中
④.调用wait()方法是释放了对象的锁，否则其他线程是无法获得锁

53.多线程的实现方式(重点)

继承
实现步骤：
①.创建一个子类继承于Thread类
②.重写run()方法
③.创建字类对象
④.启动线程使用start()方法

实现
步骤：
①.创建一个实现Runnable接口的类
②.重写Runnable接口中的run()方法
③.创建一个Runnable接口实现类的对象
④.将子类对象作为形参传递给Thread类的构造器
⑤.调用start()方法 启动线程

54.线程的同步机制

同步方法
同步代码块

55.start方法和run()区别？

start()方法被用来启动新创建的线程，它的内部调用了run()方法，这和直接调用run()方法的效果不一样，
当你调用run()方法的时候，只会在原来的线程中调用，没有新的线程启动。而start()方法才会启动新的线程。

56.生产者和消费者模式？

57.死锁 ()

58.IO流

59.输入和输出流的区别 字节流和字符流 节点流和处理流

60.Java序列化和反序列化

61.什么是反射？反射的原理？

在运行期间动态获取类的所有信息。

62.反射的优点?

63.Class类

64.得到Class对象的几种方式?

65.Java设计模式

单例模式
工厂模式(简单工厂、工厂方法、抽象工厂)

66.代理模式

静态代理
动态代理

67.网络编程

TCP UDP
HTTP协议
Socket编程

68.Java创建对象的几种方式?

1.new
2.clone（）
3.反射
4.反序列化

69.Spring依赖注入

注入方式主要有三种：构造方法注入，setter注入，基于注解的注入。