一、基础知识
！！！！！！！！！！！！！！！！！！！①基本概念！！！！！！！！！！！！！！！！！！！！
（1）java不存在全局变量或全局函数
（2）java代码块初始化顺序：父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、、父类非静态变量、父类非静态代码块、父类构造函数、、子类非静态变量、子类非静态代码块、子类构造函数、、
（3）作用域：private：当前类；default：当前类、同包；protected：当前类、同包、子类；public：所有；
（4）构造函数不能被继承、但可以重载
（5）接口常量值默认使用：public static final ；没有声明任何方法的接口叫做标识接口，比如Cloneable和Serializable；接口里面的方法为抽象方法，其实际是public abstract
（6）处理基本数据类型时，都是采用按值传递，其他类型都是按引用传递
（7）反射机制：得到一个对象所属的类，获取一个类的所有成员变量和方法，最重要作用是在运行时动态地创建类的对象。
（8）在反射机制中，如何获取class：（1）class.forName(“类路径”)；（2）类名.class；（3）实例.getClass()；
（9）创建对象的方式有几种：（1）new实例化一个对象;（2）通过反射机制获取对象来创建；（3）通过clone()创建对象；通过反序列化的方式创建对象；（4）通过反序列化的方式创建对象getClass.getSuperclass().getName()
！！！！！！！！！！！！！！！！！！！！②面向对象技术！！！！！！！！！！！！！！！！！！！！
（1）面向对象和面向过程的区别：把数据和数据操作方法放在一起，作为一个相互依存的整体；面向过程是一种以事件为中心的开发方法，就是自顶向下顺序执行，逐步求精，其程序结构是按功能划分为若干个基本模块
（2）面向对象有哪些特征：抽象、继承、封装、多态
-封装：将对象拥有的属性和动作隐藏起来，只保留特定的方法与外界联系。
-抽象：就是为了继承而存在的，强调所属关系，其设计理念为is-a关系。它强调主要特征。对于一类事物,它的个体有共同的地方,也有不同的地方。我们把它们共同的一部分可以详细描述,但是特别的地方就不能一 一描述了,此时,可以把这部分特别的地方抽象为一个方法。
-继承：从已有的类中派生出新的类称为子类，子类继承父类的数据属性和行为，并能根据自己的需求扩展出新的行为，提高了代码的复用性。
-多态：同一消息根据不同的对象而采用各种不同的行为方法。封装和继承几乎都是为多态而准备的.在执行期间判断引用对象的实际类型，根据其实际的类型调用其相应的方法。
（3）面向对象开发优点：较高的开发效率，保证鲁棒性，保证高可维护性
（4）多态的实现机制：重载、覆盖
（5）java提供了哪两种用于多态的机制：编译时多态（通过方法重载）和运行时多态（通过方法覆盖）。
（6）抽象类与接口类：
<1>抽象类：在实现时，必须包含相同的或者更低的访问级别，abstract不能用来修饰属性，只能extends。如果基本功能在不断改变，那么就需要使用抽象类。
<2>接口：成员变量都是static final，只能implements。如果你想实现多重继承，那么你必须使用接口。
（7）内部类有哪些：
<1>静态内部类：static修饰的类，只能访问外部类中的静态成员和静态方法（包括私有的）。只有静态内部类可以有静态成员
<2>成员内部类：类里面的普通类
<3>局部内部类：方法里面的类
<4>匿名内部类：没类名，必须继承其他类或实现其他接口，一般用于GUI，不能有构造函数，不能定义静态的成员和方法。
（8）this和super的区别：this用来指当前类的对象，super可以访问父类的方法或成员变量，super（）必须为构造函数的第一条语句
（9）为什么static方法不能调用非static方法？
由于静态成员在类加载的时候就会被分配内存，而非静态成员则不会。因此，在一个类的静态成员中去访问其非静态成员会出错，是因为在类的非静态成员不存在的时候，类的静态成员就已经存在了，访问一个内存中不存在的东西当然会出错。
！！！！！！！！！！！！！！！！！！！！③关键字！！！！！！！！！！！！！！！！！！！！！
（1）final、finally、finalize区别：
<1>final ：用于声明属性、方法和类，分别表示属性不可变、方法不可覆盖，类不能派生
<2>finally：异常处理的一部分，这段语句，一定会被执行。return前执行
<3>finalize：是Object类的一个方法，在垃圾回收执行时，会调用被回收对象的finalize（）
（2）assert主要用来保证程序的正确性
（3）static的作用：为某个对象分配单一的存储空间；通过类来直接调用或使用类的属性
（4）volatile：一个类型修饰符，被定义的变量，系统每次用它都是直接从对应内存中提取，而不会利用缓存。
（5）instanceof：一个二元运算符，判断一个对象是否一个类（或接口、抽象类、父类）的实例。
（6）strictfp：精确浮点，用来修饰类。
！！！！！！！！！！！！！！！！！！！！④基本类型与运算！！！！！！！！！！！！！！！！！！！！！
（1） 默认声明的小数是double
（2）数据类型：低精度到高精度：byte<short<char<int<long<float<double
（3）Math中的round为四舍五入，ceil为向上取整，floor为向下取整
！！！！！！！！！！！！！！！！！！！！⑤字符串与数组！！！！！！！！！！！！！！！！！！！！！
（1）“= =”、equals、hashCode有什么区别？
<1>“= =”：对于基本类型数据，判断值是否相等；对于引用类型数据，判断在内存中的存放地址，对栈中的值进行比较的。对于Integer的-128到127之间的数，会进行缓存。
<2>equals：判断对象的内存地址引用是不是同一个地址，Object类提供的一个方法，可以被覆盖。equals与==是等效的。
<3>hashCode:只有在集合中用到，根据对象的地址或者字符串或者数字算出来的唯一的哈希码值，Object类提供的一个方法，可以被覆盖。
（2）String、StringBuffer、StrigBuilder、StringTokenizer
<1>String：不可变类，数据量少的时候用，
<2>StringBuffer:可变类，线程安全，
<3>StrigBuilder:可变类，单线程才可以用，
<4>StringTokenizer：分割单词
！！！！！！！！！！！！！！！！！！！！⑥异常处理！！！！！！！！！！！！！！！！！！！！！
（1）异常处理：所有异常的父类：java.lang.Throwable，异常分为error和exception
<1>error表示在运行期间出现了非常严重的错误，并且该错误是不可恢复的
<2>Exception表示可恢复的异常
（2）运行时异常和普通异常有什么区别：
<1>运行时异常:比较严重，编译器没有强制对其进行捕获并处理，出现异常，若没有处理就交给JVM处理。
<2>检查异常：不会导致程序出错，java编译器强制程序去捕获异常。
！！！！！！！！！！！！！！！！！！！！⑦输入输出流！！！！！！！！！！！！！！！！！！！！！
（1）流可以分为两大类：字节流和字符流。
<1>字节流（1个字节）：包含两个抽象类：InputStream和OutputStream，没用到缓存
<2>字符流（2个字节）：包含两个抽象类：Reader和Writer，用到缓存
（2）JavaSocket是什么？
<1>网络上的两个程序通过一个双向的通信连接实现数据的交换，这个双向链路的一端称为一个socket
<2>Socket分为两类：面向连接的通信协议TCP，面向无连接的通信协议UDP
<3>采用的是阻塞方式
（3）JavaNIO是什么？
<1>采用的是非阻塞方式
<2>在处理大量并发请求的时候，采用JavaNIO更有效率
（4）什么是序列化？
<1>将对象以一连串字符描述的过程，在序列化时不会序列化static变量和transient临时变量
<2>什么情况下用：需要通过网络来发送对象，或对象的状态需要被持久化到数据库或文件中。序列化能实现深复制。
！！！！！！！！！！！！！！！！！！！！⑧java平台与内存管理！！！！！！！！！！！！！！！！！！！！！
（4）java平台主要包含两个模块：JVM和javaAPI
（5）.java文件被javac编译为.class字节码文件，再由JVM执行
（6）什么是GC
<1>主要任务：分配内存、确保被引用对象的内存不被错误回收、回收不再被引用的对象的内存空间
<2>注意点：称为垃圾的对象，只有在下次垃圾回收器运行时才会被回收
<3>可以调用System.gc（）来通知垃圾回收器运行
（7）内存泄漏
<1>主要两种情况：一是堆中申请的空间没有被释放，二是对象已不再使用，但还仍然在内存中保留着
<2>导致的具体原因举例：
-静态集合类
-各种连接
-监听器
-变量不合理的作用域
（8）java中的堆和栈
<1>基本类型变量地址和引用类型变量地址存在栈中；
<2>引用类型变量内存分配在堆上、常量池（例如字符串常量和基本数据类型常量）；
！！！！！！！！！！！！！！！！！！！！⑨容器！！！！！！！！！！！！！！！！！！！！！
（1）Collections框架
Collection 和 Collections的区别：
Collection是集合接口，子接口主要有Set 和List、Map，提供对集合对象进行基本操作的通用接口方法。
Collections是针对集合类的一个包装类，提供了操作集合的工具方法：一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
（2）java 中的 length 属性是针对数组说的,比如说你声明了一个数组,想知道这个数组的长度则用到了 length 这个属性.
java 中的 length() 方法是针对字符串说的,如果想看这个字符串的长度则用到 length() 这个方法.
java 中的 size() 方法是针对泛型集合说的,如果想看这个泛型有多少个元素,就调用此方法来查看!
！！！！！！！！！！！！！！！！！！！！⑩多线程！！！！！！！！！！！！！！！！！！！！！
（1）线程与进程的区别？
<1>线程：执行程序代码的一个执行单元。线程的四种状态：就绪、运行、挂起、结束
<2>进程：一段正在执行的程序。
（2）使用多线程的好处？
<1>减少程序的响应时间
<2>与进程相比，线程的创建和切换开销更小
<3>提高CPU的利用率，因为多CPU和多核计算机本身就具有执行多线程的能力
<4> 复杂进程可以分成多个线程来执行，使程序便于理解和维护
（3）要想实现同步操作，必须要获得线程对象的锁。
（4）如何实现Java多线程？
<1>继承Thread类，重写run()方法，通过Thread的start()方法启动。
<2>实现Runnable接口，实现run()方法，通过Thread的start()方法启动。推荐使用这种方式。
<3>实现Callable接口，重写call()方法，通过ExecutorService的submit(线程)方法启动，返回一个Future<>类，通过future的get （）方法可以监视目标线程调用call()方法的情况，调用了get方法，当前线程会阻塞
<4>实现Callable接口，重写call()方法，通过 new Thread(FutureTask)获得的一个Thread的start()方法启动。
（5）多线程实现同步的方法有哪些？
<1>sysnchronized：但是它是以很大的系统开销作为代价的。两种同步方法：利用同步代码块，利用同步方法
<2>wait()和notify()：线程可以调用wait()方法释放对象锁，进入等待状态。可以调用notify()和notifyAll()通知其他正在等待的线程去获得锁。
<3>Lock接口、它的实现类ReentrantLock（重入锁）、它的方法如下：
-lock()：阻塞方式。拿到锁，就返回；没拿到锁，就等待直到拿到锁。会忽略interrupt()方法
-tryLock()：非阻塞方式。拿到锁，就返回true；没拿到，就返回false。
-tryLock(long timeout，TimeUnit unit)：拿到锁，就返回true；否则等待unit时间，在等待过程中，如果拿到锁，就返回true，如果等待超时，返回false
-lockInterruptibly()：拿了锁，立即返回；没拿到锁，进入休眠状态，直到获得锁，或者当前线程被别的线程中断。
（6）sleep()与wait()有什么区别
<1>sleep()：进入阻塞状态，时间一到，线程会自动苏醒，恢复到可运行状态，等cpu调度。sleep并不会释放锁。必须捕获异常。容易死锁。
<2>wait()：用于线程间的通信，直到其他线程调用notify(）才会醒来。wait会释放锁。必须放在同步控制方法或者同步语句块中。
（7）sleep()和yield()两个的区别?
<1>sleep()：给其他线程机会的时候，不考虑线程的优先级。sleep()后会转入阻塞状态。
<2>yield()：给其他线程机会的时候，考虑线程的优先级，yield()后会转入可运行状态。
（8）终止线程的方法有哪些？
<1>stop()：释放所有资源。
<2>suspend()：容不会释放锁，易发生死锁。
<3>让线程结束进入Dead状态：设置一个flag来控制循环是否执行。适用于线程运行状态。
<4>用interrupt()来打破阻塞，结束进程
（9）synchronized与lock有什么异同？
<1>用法不一样。synchronized是交给jvm托管的，lock是通过代码实现的。
<2>性能不一样。在竞争不激烈的时候，synchronized性能好于ReentrantLock。竞争激烈的时候，synchronized性能急速下降，ReentrantLock性能不变。
<3>锁机制不一样。synchronized获得多个锁，必须以相反顺序释放，是自动解锁的，不会因为出了异常而导致锁没有被释放。Lock需要手动释放，必须在finally块中释放。
（10）什么是守护线程？
守护线程一般具有较低的优先级。可以JVM提供，也可以用户在调用start(）方法前调用setDaemon(true)。所有非守护线程终止，即使存在守护线程，进程运行终止
（11）join（）方法的作用是什么？
让调用该方法的线程a在执行完run(）方法后，再执行a.join(t)；后面的代码语句。只等待t时间，若线程a还没run完也继续走后面的代码语句。
！！！！！！！！！！！！！！！！！！！！⑪数据库操作！！！！！！！！！！！！！！！！！！！！！
（1）如何通过JDBC访问数据库
<1>加载JDBC驱动器 String driver=“com.mysql.jdbc.Driver”
<2>加载JDBC驱动 Class.forName(driver)
<3>建立数据库连接，取得Connection对象 Connection con=DriverManager.getConnection(url,user,password)
<4>建立Statement对象或是PreparedStatement对象
Statement stmt=con.createStatement();
<5>执行SQL语句 ResultSet st=stmt.excute(“sql语句”)
<6>访问结果集
<7>关闭各对象
（2）JDBC有哪些事务隔离级别？
<1>TRANSACTION_NONE JDB不支持事务
<2>TRANSACTION_READ_UNCOMMITTED未提交读：允许读“脏”数据，不可重复读、虚读
<3>TRANSACTION_READ_COMMITTED已提交读：允许不可重复读、虚读
<4>TRANSACTION_REPEATABLE_READ可重复读：允许虚读
<5>TRANSACTION_SERIALIZABLE可序列化：都不允许
-读“脏”数据：事务a改了数但还没提交，事务b读了数，事务a回滚了
-不可重复读：事务a查询数据，事务b去更新了，事务a又查了一次发现数据值变了
-虚读：事务a查询数据，事务b增删了几条数据，事务a又查了一次发现数据量变了
（3）设置隔离级别的方法
通过Connection对象的conn.setTransactionLevel（）方法来设置隔离级别。
（4）Class.forName的作用是什么？
任何类只有被装在到jvm上才能运行。Class.forName()就是把类加载到jvm中
（5）Statement、PreparedStatement、CallableStatement有什么区别？
<1>Statement继承自Wrapper、PreparedStatement继承自Statement、CallableStatement继承自PreparedStatement。
<2>Statement接口提供了执行语句和获取结果的基本方法；
PreparedStatement接口添加了处理 IN 参数的方法；
CallableStatement接口添加了处理 OUT 参数的方法。
<3>a.Statement:
普通的不带参的查询SQL；支持批量更新,批量删除;
b.PreparedStatement:
可变参数的SQL,编译一次,执行多次,效率高;
安全性好，有效防止Sql注入等问题;
支持批量更新,批量删除;
c.CallableStatement:
继承自PreparedStatement,支持带参数的SQL操作;
为所有的RDBMS提供了一种标准形式调用存储过程的方法。
支持调用存储过程,提供了对输出（IN）、输出（OUT）、输入和输出参数(IN-OUT)的支持;
（4）结果集的getString ()和getObject()有什么区别
<1>getString ()：适合查询的结果集中获取的数量比较小的情况。程序会一次性地把数据都存放到内存中。当数据量大到内存中放不下时就会抛出异常
<2>getObject()：每次调用时会直接从数据库中去获取数据。
（5）JDBC和Hibernate有什么区别
Hibernate是JDBC的封装，用xml配置数据库连接参数，Hibernate是一个持久层框架，它将表的信息映射到xml文件中，再从xml文件映射到持久化类中。Hibernate具有访问层DAO。如果表名改了，只需要修改DAO层
二、数据库原理
（1）最基本的
查：select * from tablename where 条件语句
增：insert into tablename values (v1,v2,v3…)
删：delete from tablename where 条件语句
改：update tablename set 字段名=字段值 where 条件语句
创表：create table tablename
删表：drop table tablename
改表：alter table …add|alter|drop
授权：grant … to …
回收权：revoke … from …
创建索引：create index indexname on tablename (columnname)
删除索引：ALTER TABLE table_name DROP INDEX index_name
（2）delete与truncate区别？
<1>delete：是DML（数据操纵语言），被删除的数据占用的存储空间还在，还可以恢复，删除的操作以日志的形式保存，可以回滚
<2>truncate：是DDL（数据定义语言），被删除的数据立即释放占用的存储空间，被删除的数据不能恢复，执行后不能回滚。
（3）内连接与外连接有什么区别？
<1>内连接：只有两个表相匹配的行才能在结果集中出现。
<2>外连接：不仅包含符合连接条件的行，而且还包括左表（左外连接时）、右表（右外连接时）、两个边接表（全外连接）中的所有行。
LEFT JOIN 关键字会从左表 (table_name1) 那里返回所有的行，即使在右表 (table_name2) 中没有匹配的行。
RIGHT JOIN 关键字会右表 (table_name2) 那里返回所有的行，即使在左表 (table_name1) 中没有匹配的行。
（4）什么是事务？
事务是数据库中一个单独的执行单元，当在数据库中更改数据成功时，在事务中更改的数据就会提交，不再改变。否则，事务就取消或者回滚，更改无效。
（5）事务的四个特性？
A：原子性：不可分割的整体
C：一致性：事务执行前后，数据库数据必须保持一致
I：隔离线：事务a的事不会被其他事务b看到。两个事务不可能交叉执行。
D：持久性：事务的修改是永久的。
（5）什么是存储过程？
sql语句在执行的时候要先编译后才能执行。大型系统为提高效率，将sql语句进行编译优化后，存储在数据库服务器中。也就是存储过程。
执行方法：exec 存储过程名[参数]
删除方法：drop procedure 存储过程名
（6）存储过程与函数的区别
<1>存储过程功能较复杂，函数功能针对性较强
<2>存储过程是作为一个独立部分来执行的，函数需嵌在sql语句中才能执行
<3>存储过程在创建时就已经在服务器上进行编译了，执行速度比函数快
<4>函数不能直接操作实体表，只能操作内建表
（7）范式：
1NF：列不可以再分
2NF:非主属性对主键完全依赖
3NF：非主属性不传递依赖于主键
BCNF
4NF
（8）什么是触发器
一种特殊类型的存储过程，由事件触发，当发生数据操作语言事件时执行的存储过程，由after（记录改变后执行）和instead of（记录改变前执行）两种触发器。
（9）什么是游标
游标是由结果集和游标位置组成的
在使用游标的表中，对行提供删除和更新的功能
游标将面向集合的数据库管理系统和面向行的程序设计连接了起来
（10）union和union all区别
union合并两个表后会去重，union all简单合并两个表
（11）什么是视图
视图是基于 SQL 语句的结果集的可视化的表，是个虚图
CREATE VIEW view_name AS
SELECT column_name(s)
FROM table_name
WHERE condition
作用：简化数据查询语句，提高数据安全性，但是不能提高查询的效率
（12）怎么用sql实现分页？
String sql = "SELECT TOP " + pageSize + " * FROM tb_SQLServerFenye" +
" WHERE id NOT IN(SELECT TOP " + (page - 1) * pageSize + " id FROM" +
" tb_SQLServerFenye ORDER BY ID DESC) ORDER BY ID DESC";
三、
四、git和svn的区别
| svn | git |
|---|---|
| 集中式版本控制系统 （文档管理很方便） | 分布式系统（代码管理很方便） |
| 安全性较差，定期备份，并且是整个svn都得备份 | 安全性较高，每个开发者的本地就是一套完整版本库，记录着版本库的所有信息 |
| 每次更改文件之前都得update操作，有的时候修改过程中这个文件有更新，commit不会成功 | 开始工作前进行fetch操作，完成开发工作后push操作，有冲突解决冲突 |
| svn的权限管理相当严格，可以按组、个人针对某个子目录的权限控制 | git没有严格的权限管理控制，只有账号角色划分 |
| 用SVN的话，没有网络或者断开VPN你就无法做任何事情。 | Git在本地磁盘上就保存着所有有关当前项目的历史更新，并且Git中的绝大多数操作都只需要访问本地文件和资源，不用连网，所以处理起来速度飞快。日志都是在本地查看，效率较高 |
| 而SVN有全局版本号 | 文件没有改变时，分支指向这个文件的指针不会改变，文件发生改变，指针指向新版本 |