什么是SVN，小乌龟是什么，SVN的文件版本号是怎么来的，哪些文件应该上传到SVN，哪些不该上传？Git和SVN的区别又是什么？

SVN: subversion，是一个开源的版本控制系统。

SVN把文件存储在中心仓库中，这个中心仓库就像文件系统一样，不同的是，它可以记录每次修改的情况，

借助于此就能够非常清楚的知道文件的变更情况。

SVN基本情况

SVN服务端软件：VisualSVN

SVN客户端软件：TortoiseSVN（外号：小乌龟）

Git和SVN的 区别

一、Git（分布式版本控制）

Git 旨在快速，高效地处理从小型到大型项目的所有事务。Git 易于学习，

 具有闪电般快速的性能和廉价本地分支，便捷的临时区域、多个工作流程等功能。

git每台电脑都有一个版本库，可以在本地做版本管理。而且每个工作成员可以任意在自己的本地版本库开启无限个分支，

并且Git的分支名可以使用不同名字的。

但是Git 没有严格的权限管理控制，一般通过系统设置文件读写权限的方式来做权限控制。工作目录只能是整个项目。

比如 checkout，建分支，都是基于整个项目的。而 svn 可以基于项目中的某一个目录。

二、SVN（集中式版本控制）

SVN就是用于多个人共同开发同一个项目，共用资源的目的。SVN允许一个文件有任意多的可命名属性，

功能十分完全。在SVN，分支是一个完整的目录，且这个目录拥有完整的实际文件。

总结：

1、GIT是分布式的，SVN不是分布式。

2、GIT把内容按元数据方式存储，而SVN是按文件。

3、GIT分支和SVN的分支不同。

4、GIT没有一个全局的版本号，而SVN有。

5、GIT的内容完整性要优于SVN。

------------------------------------------------------------------------------

什么是AOP，适用于哪些场景，AOP的实现方案有哪些？

什么是AOP

全称是 Aspect Oriented Programming 即：面向切面编程。是OOP的延续，也是Spring框架中的一个重要内容，

是函数式编程的一种衍生泛型。简单的说他就是把我们程序重复的代码抽取出来，

在需要执行的时候使用动态代理技术在不修改源码的基础上，对我们的已有方法进行增强。

AOP应用场景

场景一： 记录日志

场景二： 监控方法运行时间 （监控性能）

场景三： 权限控制

场景四： 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ）

场景五： 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ）

AOP的三种实现方式:

1.基于Spring容器的自动代理实现AOP:

2.AspectJ技术，通过切面Aspect,基于Spring AOP的配置实现AOP:

3.通过注解实现AOP:

----------------------------------------------------------

Map，List，Array，Set之间的关系是什么，分别适用于哪些场景，集合大家族还有哪些常见的类？

在代码中进行随机访问和存储，array的效率是最高的，但是array是固定的，不能动态改变，

且一个array只能存放同一种数据类型。针对以上缺点，就出现了集合就是list,set,map。

List和Set是存储单列数据的集合，Map是存储键值对这样的双列数据的集合；

List中存储的数据是有顺序的，并且值允许重复；Map中存储的数据是无序的，它的键是不允许重复的，

但是值是允许重复的；Set中存储的数据是无顺序的，并且不允许重复，但元素在集合中的位置是由元素的hashcode决定，

即位置是固定的（Set集合是根据hashcode来进行数据存储的，所以位置是固定的，但是这个位置不是用户可以控制的，

所以对于用户来说set中的元素还是无序的）。

list与Set、Map 区别及适用场景

1、List,Set都是继承自Collection接口，Map则不是

2、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，

（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，

加入Set 的Object必须定义equals()方法 ，另外list支持for循环，也就是通过下标来遍历，也可以用迭代器，

但是set只能用迭代，因为他无序，无法用下标来取得想要的值。） 

3.Set和List对比： 

Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。 

List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。 

4.Map适合储存键值对的数据

5.线程安全集合类与非线程安全集合类 

LinkedList、ArrayList、HashSet是非线程安全的，Vector是线程安全的;

HashMap是非线程安全的，HashTable是线程安全的;

StringBuilder是非线程安全的，StringBuffer是线程安全的。

集合大家族中的常见类：

1 List列表：有序，可重复

1.1 ArrayList数组列表，有序，可重复，内部是通过Array实现。对数据列表进行插入、删除操作时都需要对数组进行拷贝并重排序。因此在知道存储数据量时，尽量初始化初始容量，提升性能。

1.2 LinkedList双向链表，每个元素都有指向前后元素的指针。顺序读取的效率较高，随机读取的效率较低。

1.3 Vector向量，线程安全的列表，与ArrayList一样也是通过数组实现的，不同的是Vector是线程安全的，也即同一时间下只能有一个线程访问Vector，线程安全的同时带来了性能的耗损，所以一般都使用ArrayList。

1.4 Stack栈，后进先出（LIFO），继承自Vector，也是数组，线程安全的栈。但作为栈数据类型，不建议使用Vector中与栈无关的方法，尽量只用Stack中的定义的栈相关方法，这样不会破坏栈数据类型。

1.5 ArrayQueue数组队列，先进先出（FIFO）

2 Queue队列，有序、可重复

2.1 ArrayDeque数组实现的双端队列，可以在队列两端插入和删除元素

2.2 LinkedList也是双向链表

2.3 PriorityQueue优先队列，数组实现的二叉树，完全二叉树实现的小顶堆（任意一个非叶子节点的权值，都不大于其左右子节点的权值）

3 Map映射/字典，无序，键值对，键唯一

3.1 HashMap哈希映射/字典，无序字典，键值对数据，key是唯一的，Key和Value都可以为null

3.2 TreeMap红黑树实现的key->value融合，可排序，红黑树是一种自平衡二叉查找树。

3.3 LinkedHashMap链表映射/字典，继承了hashmap的所有特性，同时又实现了双向链表的特性，保留了元素插入顺序。

4 Set集合，不可重复

4.1 HashSet基于HashMap实现的集合，对HashMap做了一些封装。与HaspMap不同的是元素的保存为链表形式，插入数据时遍历链表查看是否有相同数据，有则返回false，没有则返回true.

4.2 LinkedHashSet链表集合，继承自HashSet与LinkedHashMap相似，是对LinkedHashMap的封装。

4.3 TreeSet红黑树集合，与TreeMap相似，是对TreeMap的封装。

-----------------------------------------------------------------------------------------------------------------

Spring的IOC有几种方式？它们之间的差别是什么，应该选择Annonation还是应该选择XML？

IOC控制反转

使用对象是由主动new产生对象，转化为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转

业务层要想使用数据层的对象，以前都是自己new

现在自己不new 了，交给外部来创建对象

外部旧反转控制了数据层对象的创建权

Spring 提供了一个容器，IOC容器，用来充当思想中“外部”

DI的基本原理：

对象之间的依赖关系只会通过三种方式：构造函数参数，

工厂方法的参数以及构造函数或工厂方法创建的对象属性设置。因此，容器的工作哦就是在创建Bean时注入所有的依赖关系。

相对于由Bean自己控制其实例化,直接在构造器中指定依赖关系或者类似服务定位器(Service Locator)这三种自主控制依赖关系注入的方法，

而控制权从根本上发生改变，即控制反转(Inverse of Controll)---IOC.

应用DI规则后，我们不用在关注对象之间的依赖关系，从而达到高层次的松耦合。

DI有两种实现方式---Setter/getter方式（传值方式）和构造器方式(引用方式)。

spring IOC有两种大的实现方式：分别是xml配置文件实现和类上添加注解实现

区别

•  xml:可以适用任何场景  结构清晰，维护方便
•    注解：开发方便，快速有些地方用不了，这个类不是自己提供的（比如源码提供的类）。 开发方便

4种注入方式

a.接口注入

b.setter方法注入

c.构造方法注入

d.注解方式注入

小结：

基于注解的 spring IoC 配置中， bean 对象的特点和基于 XML 配置是一模一样的。

xml 配置 可以 与注解配置一起使用。

目前开发比较常用的是:

    XML + 注解 混合使用.

    XML:  配置一些全局的对象(举例:DataSource/JdbcTemplate..)

-------------------------------------------------------------------------------------------------------------------------------------

.JDBCTemplate和JDBC

什么是JDBC？

JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，

可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。

什么是JDBCtemplate？

JDBCTemplate就是Spring对JDBC的封装,通俗点说就是Spring对jdbc的封装的模板。

使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中,

相比较于传统的JDBC,大大简化了数据库的操作。

JDBCtemplate又是如何连接数据库呢？

SpringIOC容器将管理数据库连接的数据源当作普通Java Bean一样管理,

然后将数据源注入封装类JdbcTemplate中,JdbcTemplate的dataSource属性就是注入配置的数据源

JdbcTemplate对JDBC的差别在哪?

jdbc需要每次进行数据库连接, 然后处理SQL语句,传值,关闭数据库.

甚至有时还可能会出现数据库忘记关闭导致连接被占用.在以后的工作中,客户的需求肯定不是一成不变的,这就导致经常会改动数据库内容.

通过JDBCtemplate我们只需更改需要更改的那一部分内容就可以了,不需要进行全局修改.Spring将替我们完成所有的JDBC底层细节处理工作.

总体来说：

JdbcTemplate的底层使用的还是传统的JDBC连接数据库的那一套，

由于借助了spring框架的封装，所以在实际的开发中相较于JDBC而言

更加的快捷和方便，在性能上并没有多大的区别。

由于现在我们都在使用SSM或者SSH，以及现在比较流行的spring-Boot

所以关于数据的连接的直接使用集成的持久层框架，例如Mybatis等已经非常方便了。

------------------------------------------------------------------------------------------------------------

为什么要使用Interface，而不是直接使用一个实体类来完成任务？Interface和Impl这种方式的好处是什么？

Interface（接口）：

接口是一种特殊的抽象类，是一个比抽象类还抽象的类，这种抽象类中只包含常量与方法的定义，

而没有变量和方法的实现，接口，接口里所有的方法全是抽象方法。

接口中成员的特点

（1）Java 为了保证数据安全性是不能多继承的，也就是一个类只有一个父类。

但是接口不同，一个类可以同时实现多个接口，不管这些接口之间有没有关系，所以接口弥补了抽象类不能多继承的缺陷。

（2）接口是抽象类的延伸，它可以定义没有方法体的方法，要求实现者去实现。

接口的所有方法访问权限自动被声明为 public

（3）接口中可以定义“成员变量”，会自动变为 public static final 修饰的静态常量

可以通过类命名直接访问：ImplementClass.name

不推荐使用接口创建常量类

（4）实现接口的非抽象类必须实现接口中所有方法，抽象类可以不用全部实现

接口不能创建对象，但可以申明一个接口变量，方便调用

（5）完全解耦，可以编写可复用性更好的代码

接口的作用

1.重要性。在java中，abstract class和interface是支持抽象类定义的两种机制。赋予了Java面向对象的能力。

2.简单、规范性。大型项目，通过定义接口可以告诉开发人员需要实现的业务，同时限制了命名规范。

3.维护、扩展性。接口定义了功能，然后通过定义类来实现功能。这样需要使用接口的功能时就是使用这个接口去引用实现它的类。

这样当接口功能需要更新时，对应功能上来讲，只需要更换引用的实现类。

4.安全、严密性。接口是实现软件松耦合的重要手段，它描述了系统对外的所有服务，而不涉及任何具体的实现细节。

接口和抽象类的区别？

一个抽象类只能继承一个抽象父类，而接口可以继承多个接口

一个子类只能继承一个抽象类，却可以实现多个接口

接口实现的基础——对象转型和多态

好处：

   定义类的解耦性高

   减少代码的书写（上边分析的代码重载）
   提高了代码的可维护性和扩展性。
   在团队合作中，代码的规范性

-----------------------------------------------------------------------------------------------------------

为什么要处理异常，Try/Catch应该在什么样的场景下使用，在真实的系统中，会出现网络中断，DB连接不上的错误吗？多久会发 生一次？ 

Exception 类的层次

所有的异常类是从 java.lang.Exception 类继承的子类。

Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。

Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。

Error 用来指示运行时环境发生的错误。

例如，JVM 内存溢出。一般地，程序不会从错误中恢复。

异常类有两个主要的子类：IOException 类和 RuntimeException 类。

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；

如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。

以业务逻辑功能为单位，在最上层加Try-Catch机制。为什么要这样做呢？这主要是增加程序的健壮性，防止因抛出异常过多，导致程序崩溃。

底层代码，在可能出错的地方加Try-Catch机制，用Catch侦测具体的异常，然后就具体的异常，采取相应的解决方案。

底层代码，在需异常追踪时加Try-Catch机制，在Catch块中抛出自定义异常，调试时可迅速定位到错误代码段。

Try-Catch机制会将异常屏蔽掉，必须根据具体的应用场景，具体分析。

明天计划：了解深度思考。