java开发工作三年你应该掌握的知识(持续更新)

一、java基础知识

1、java中常用的类有哪些？

Scanner、system、String、Integer、Arrays、Boolean、Math、Double、Character、Calendar、Random、BigIngteger、Arraylist、hashMap、Thread、Date、Iterator

2、java中常用的包有哪些？

Lang、IO、sql、util、awt、net、

3、Object类中常用的哪些方法？

toString、equels、hashCode、getClass、wait、notify、clone

4、String类中常用的方法？

Equels、charAt、indexOf、valueOf、substring、splid、toUpperCase、toLowerCase

Trim、replace、contains、compareTo、length

6、jdk（开发工具包）包括jre jre是运行环境，jvm是java虚拟机（.class文件在这里被识别通过虚拟机与操作系统解释执行） tomcat是web服务器，使得CLASS文件可以显示到网页或者提供后台运行 tomcat只是一种java应用服务器,所以它其中一定内置了JDK,用来编译运行java程序。

7、java中常见的异常？

Nullporint,illeaglearugment,outofindexof,classNoFound,airthmetic
Illeagleaccess(非法访问)，SqlException，NumberFormat，JspException
IOException
error是由于系统错误，程序员无法解决的，如：内存空间不足，Java编译器不去检查他们
Exception类表示程序可以处理的异常，可以捕获且可能恢复
RuntimeException是由于程序代码问题，一般不try Catch 比如 NullPoint，outOfBound，numberFormat等异常
IOException （受检查的异常）这类异常必须try Catch，否则编译不通过
，这并不是代码的问题，而是应用程序外部出现的错误

8、动态代理是通过反射机制实现的 Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载

9、反射提高了程序的灵活性和扩展性，降低耦合性，提高自适应能力。它允许程序创建和控制任何类的对象，无需提前硬编码目标类；
1、性能问题。
Java反射机制中包含了一些动态类型，所以Java虚拟机不能够对这些动态代码进行优化。因此，反射操作的效率要比正常操作效率低很多。
2、安全限制。
使用反射通常需要程序的运行没有安全方面的限制。如果一个程序对安全性提出要求，则最好不要使用反射。
3、程序健壮性。
反射允许代码执行一些通常不被允许的操作，所以使用反射有可能会导致意想不到的后果。

获取Class对象的三种方式
.class getClass class.forName（“包名.类名”）
.
Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。
Class stuClass = stu1.getClass();//获取Class对象
System.out.println(stuClass.getName());
//第二种方式获取Class对象
Class stuClass2 = Student.class;
System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
//第三种方式获取Class对象
try {
Class stuClass3 = Class.forName(“fanshe.Student”);//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
} catch (ClassNotFoundException e) {
e.printStackTrace();

Class stuClass = Class.forName(“fanshe.Student”)
获取构造 产生一个对象
stuClass.getConstructor().newInstance();/
Object o=obj.getConstructor().newInstance();
//获取变量
obj.getDeclaredField(“name”);
//获取成员方法
Method m=obj.getMethod(“setName”,String.class);
//执行方法 参数为调用的对象（获取有反射），一个是实参
m.invoke(obj, “123”);
java类的加载机制：
加载-验证-准备-解析-初始化
加载过程：
1、通过类名获取二进制字节流
2、将二进制字节流静态数据结构转换为方法区的数据结构
3、在堆中生成一个class对象，对方法区提供这些数据的访问入口。
10、工厂模式:比如 创建一个定长线程池 Excutors.newFixThreadPool

共同的接口 有一个抽象类实现了这个接口，其他普通类继承该抽象类
比较好的是通过反射来做工厂，可以增加扩展性 避免工厂被修改
装饰者模式：//装饰者和被装饰者有共同的超类，装饰者必须将被装饰者作为构造参数，实现功能拓展
比如:用缓冲流来包装普通的输出输入流
单例模式：1、构造私有化
2、定义一个静态变量保存 new实例化的对象
3、提供一个共有静态的方法来返回该静态变量
代理模式：依赖反射来实现动态代理
适配器模式

11、数据库连接池：1、org.apache.commons.dbcp.BasicDataSource
2 、com.alibaba.druid.pool.DruidDataSource"
12、序列化：把Java对象转换为字节序列的过程。 （持久化对象到硬盘上，网络传输对象）　
反序列化：把字节序列恢复为Java对象的过程。
ObjectOutputStream代表对象输出流 writeObject()方法
ObjectInputStream代表对象输入流，readObject()方法
可以包装其他的文件输出流

13、线程池的创建、线程的生命周期、线程的安全？

ThreadPoolExecutor继承AbstractExecutorService实现ExecutorService继承Executor
execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行
　submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，
单一、可缓存、指定大小、周期性执行的
真正线程池的实现是通过ThreadPoolExecutor，ThreadPoolExecutor通过配置不同的参数配置来创建线程池
corePoolSize：核心池的大小 maximumPoolSize：线程池最大线程数，
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止
workQueue:阻塞队列
threadFactory：线程工厂，主要用来创建线程；

newCachedThreadPool 带缓存的线程池 执行很多短期异步的小程序或者负载较轻的服务器

newFixedThreadPool：创建可容纳固定数量线程的线程池

newSingleThreadExecutor:创建只有一个线程的线程池，且线程的存活时间是无限的；

NewScheduledThreadPool:创建一个固定大小的线程池，线程池内线程存活时间无限制，线程池可以支持定时及周期性任务执行

一般需要根据任务的类型来配置线程池大小：
　　如果是CPU密集型任务，就需要尽量压榨CPU，参考值可以设为 NCPU+1
　　如果是IO密集型任务，参考值可以设置为2*NCPU
A:创建一个线程池对象，控制要创建几个线程对象。
B:这种线程池的线程可以执行： 做一个类实现Runnable接口。
C:调用submit（）方法并将实现类作为参数，
D：shutdown（）方法
线程的生命周期：创建线程对象—start（）就绪----run运行----死亡
创建线程对象—start（）就绪—sleep（）—wait（）/notify（）—run运行—死亡
servlet生命周期: init() service() destory()

线程的安全：
同步代码块、同步锁
死锁：多个进程因竞争资源发生死锁 ，这些永远在互相等待的进程称为死锁进程
B:JVM的启动是多线程的，因为它最低有两个线程启动了，主线程和垃圾回收线程。
1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
5）Lock可以提高多个线程进行读操作的效率

14、垃圾回收机制的原理？

垃圾回收机制有多重算法，我了解到jvm的垃圾回收机制是分代回收算法
新生代与年老带

15、callable和runable的区别？

(1)Callable规定的方法是call(),Runnable规定的方法是run().
(2)Callable的任务执行后可返回值（Future对象），可以抛出异常，而Runnable的任务是不能返回值得
(4)callable一般和线程池结合起来
如果你需要任务执行完返回一个特定的结果，那么就实现callable接口 使用submit来提交，如果你不需要返回一个特定的结果，那么最好实现runnable接口使用excute提交

16、syncrhoized和reentranrLock(实现类)比对

1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
5）Lock可以提高多个线程进行读操作的效率

17、synchronized进行同步有四种情况：

第一种：修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
第二种：修饰一个方法：被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
第三种：修饰一个静态的方法：其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
第四种：修饰一个类：其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

18、JVM将内存区域划分为

堆、
申请空间和释放空间，存储的都是对象
栈、
Java栈是Java方法执行的内存模型，变量都在栈中，局部变量
方法区
在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。

19、java包装类有哪些？

Byte、character 、short 、Integer、Float、Double 、long、 Boolean

Java的基本数据类型有8种，分别是：byte（位、1个字节）、short（短整数、2个字节）、int（整数、4个字节）、long（长整数、8个字节）、float（单精度、4个字节）、double（双精、4个字节）、char（字符、2个字节）和boolean（布尔值、1个字节）。
20、String类的特点

1.String类的字符串常量无法修改
2.==是地址比较 equals是值比较
3…直接赋值只会开辟一块堆内存空间，且字符串对象可以保存在对象池中以供下次使用；
采用构造方法会开辟两块堆内存空间，使用intern()方法后可以手工入池。
String.valueOf(int i) 整型转string
Integer.passInt(String i)String 转整型
valueOf() 方法返回指定对象的原始值
toString是以字符串的形式返回

21、重写equals方法的要求：

自反性，传递性，一致性，非空性，对称性
覆写equals方法就必须覆写hashCode方法，hash表中每个对象新创建之后
hashCode值就发生了变化 都是根据存储对象的hashcode值来进行判断是否相同的。

22、什么时候使用接口？什么时候使用抽象类？

通过接口建立行为模型，我有一个驱动接口，只声明我的驱动可以产生驱动的行为
向上转型为多个基类型 为了降低耦合度。增加可扩展性，无需修改以前的代码
自然吸气发动机和涡轮增压发动机接口可以继承驱动接口类,我还可以自然吸气+涡轮增压多重实现，
抽象类用来描述一个虚拟的物体

抽象类：在Java中被abstract关键字修饰的类称为抽象类，被abstract关键字修饰的方法称为抽象方法，抽象方法只有方法的声明，没有方法体。抽象类的特点：

a、抽象类不能被实例化只能被继承；

b、包含抽象方法的一定是抽象类，但是抽象类不一定含有抽象方法；

c、抽象类中的抽象方法的修饰符只能为public或者protected，默认为public；

d、一个子类继承一个抽象类，则子类必须实现父类抽象方法，否则子类也必须定义为抽象类；

e、抽象类可以包含属性、方法、构造方法，但是构造方法不能用于实例化，主要用途是被子类调用。

接口：Java中接口使用interface关键字修饰，特点为:

a、接口可以包含变量、方法；变量被隐士指定为public static final，方法被隐士指定为public abstract（JDK1.8之前）；

b、接口支持多继承，即一个接口可以extends多个接口，间接的解决了Java中类的单继承问题；

c、一个类可以实现多个接口；

23、Java能不能多重继承?

继承不可能，但是 可以通过实现多个接口来达到效果

24.Java创建对象有几种方式?

New （class.forname）newInstance，clone，

25.有没有用过反射机制?反射机制的原理?

public static void main(String[] args) throws Exception{
   
         //1.获取类
         Class c = Class.forName("_12_CustomerService");
         //获取某个特定的方法
         //通过：方法名+形参列表
         Method m = c.getDeclaredMethod("login",String.class,String.class);
         //通过反射机制执行login方法.
         Object o = c.newInstance();
		 Object o =c.getConstractr.newInstance()
         //调用o对象的m方法,传递"admin""123"参数，方法的执行结果是retValue
         Object retValue = m.invoke(o, "admin","123");
         System.out.println(retValue); //true

26、Javabean和json怎么转换?

数字、字符串、布尔、数组、对象
将对象转为JSON同样使用JSONObject.fromObject(obj)方法
如果是一个List,转为JSON时需要使用JSONArray将对象转为JSON数组jsonArray.fromObject();
JSONObject.toBean()将json转为bean
Gson com.google.code.gson toJson fromJson

27.你对JAVA面向对象怎么理解;

我的理解是分类，当我们拿到一个功能需求的时候，可以在java中将其分成很多不同的对象，程序其实就是一大堆对象的组合，对象之间传递消息知道自己要做什么，x00000000000000000000而c偏向面向过程，他会完整的展示一件事物

28.用final修饰的类/方法/

Finnal修饰类 类不能被继承，修饰变量，变量就变成了常量，且只能被赋值一次，修饰方法，方法不能被重写；

29、Java代码怎么调用存储过程

CallableStatement call.set call.registerOut execute()

30.Socket通讯有没有用过
客户端：
1、socket
2、bw=new bufferWriter(new outputStreamWriter(s.getOutputSt))
3、bw.write（line）
服务端
1、server socket
2、Accept()
3、封装 bR=new BReader(new bufreader(ss.getinputSt()))
4、Br.readline
3、Socket通信的步骤
① 创建Socket
② 打开连接到Socket的输入/输出流
③ 按照协议对Socket进行读/写操作
④ 关闭输入输出流、关闭Socket
4、服务器端：
① 创建ServerSocket对象，绑定监听端口
② 通过accept()方法监听客户端请求
③ 连接建立后，通过输入流读取客户端发送的请求信息
④ 通过输出流向客户端发送乡音信息
⑤ 关闭相关资源
.
5、客户端：
.
① 创建Socket对象，指明需要连接的服务器的地址和端口号
② 连接建立后，通过输出流想服务器端发送请求信息
③ 通过输入流获取服务器响应的信息
④ 关闭响应资源

31.多线程是怎么使用的<