java基础004

事物相关：

1.事物的四个特征：ACID   

    a)原子性

    b)一致性

    c)隔离性

    d)持续性

2.事物的隔离级别：

    1.读未提交       解决-- 

    2.读已提交       解决了--脏读取（脏读是指在一个事务处理过程里读取了另一个未提交的事务中的数据。）

    3.可重复读       解决了--不可重复读（不可重复读是指在对于数据库中的【某个字段】，一个事务范围内多次查询却返回了不同的数据值，这是由于在查询间隔，被另一个事务修改并提交了。）

    4.串行化           解决了--幻读（同一事物以前没有的行由于其他事物的提交出现新行）

 

幻读和不可重复读都是读取了另一条已经提交的事务（这点就脏读不同），所不同的是不可重复读查询的都是同一个数据项，而幻读针对的是一批数据整体（比如数据的个数）

 

MySQL默认  可重复读

Oracle默认    读已提交  （只支持串行化和读已提交）

SqlServer      读已提交

 

3.事物的传播特性：

PROPAGATION_REQUIRED

PROPAGATION_SUPPORTS

PROPAGATION_MANDATORY

PROPAGATION_REQUIRED_NEW

PROPAGATION_NOT_SUPPORTED

PROPAGATION_NEVER

PROPAGATION_NESTED

http://blog.csdn.net/yuanlaishini2010/article/details/45792069

 

1.抽象类和接口的区别：

    一个类    实现    一个接口

    一个类    继承    一个抽象类

    （1.继承只有单继承   实现 一个类可同时实现多个接口  --2. 抽象类 是强关系 （是 is）  接口是弱关系（像 like））

    

    --接口：【修饰符】 interface  接口名称

        1.接口 中的 变量是常量（ 必须由 publicstatic final 修饰） 

               --接口是一个公有的，共享的，static 保证了不能被修改，  final 保证了不能被 修改

        2.接口 中的 方法是抽象方法（默认 public abstract 修饰）  抽象方法不能被static修饰  static保证不能被修改

        3.接口 中没有静态方法

        4.接口 中 没有构造方法，无法被实例化

        5.一个类要实现一个接口，要将接口中所有方法都实现

 

    --抽象类： abstract 类名

        1.抽象类中  可以没有抽象方法，但抽象方法必须出现在抽象类中

        2.抽象类中 可以有静态方法

        3.抽象类|抽象方法  不能被final修饰 （因为被final修饰的类不能被继承，抽象类是要被继承的）【abstract 和final 不能同时出现】 

        4.抽象类中 有构造方法，但抽象类也无法被实例化，该构造方法是给子类创建对象用的

        5.一个非抽象类继承了抽象类，要实现抽象类中的所有象方法

 

 

 final: 修饰类，该类不能被继承(故：一个类不可能既被final修饰又被abstract修饰)

           修饰方法，该方法不能被重写

           修饰局部变量，一旦被赋值，不可被改变

           修饰成员变量，一般与static连用（常量）

 

 

2.方法重载和方法重写区别：

    --方法重载：

        1.方法名必须相同

        2.参数列表必须不同（参数个数，类型，顺序）

        3.返回值类型没有限制

        4.访问权限没有限制

        5.抛出异常没有限制

        6.在本类中进行重载

        7.重载次数没有限制

    --方法重写

        1.方法名必须相同

        2.参数列表必须相同

        3.返回值类型必须相同

        4.访问权限不能降低

        5.抛出异常不能扩大

        6.在子类中进行

        7.只能覆盖一次

 

3.final  finally  finalize区别

    final:修饰类，该类不能被继承(故：一个类不可能既被final修饰又被abstract修饰)

            修饰方法，该方法不能被重写

            修饰局部变量，一旦被赋值，不可被改变

            修饰成员变量，一般与static连用（常量）

    finally:异常处理机制的finally语句块

    finalize:是java回收机制在回收Java对象前，会自动调用finalize()

 

4.异常分类：

 

5. == 两边是基本数据类型时，判断值是否相等

    == 两边是引用数据类型时，判断内存地址是否相等

    Integer   -128 ~ 127 在缓存中（常量池中）

    

 

Integer A = 100;

Integer B = 100;

Integer C = 200;

Integer D = 200;

int a = 100;

int b= 100;

int c = 200;

int d = 200;

System.out.println(A==B);//true   --在常量池中

System.out.println(C==D);//false  --引用数据类型

       

System.out.println(a==b);//true    -基本数据类型

System.out.println(c==d);//true

 

----字符串常量池：

   https://segmentfault.com/a/1190000009888357

    

 

String s1 = "Programming"; //在常量池中 创建1个对象

String s2 = new String("Programming"); //在堆中 创建1个对象

String s3 = "Program" + "ming";   //在常量池中 创建 3个对象（有一个和s1同一个） Program  ming   Programming （和s1一个）

                                  //故 一共创建了4个对象

System.out.println(s1 == s2);   //false

System.out.println(s1 == s3);   //true --

System.out.println(s1 == s1.intern());  //true

6.单例模式：

    为了保证jvm中某个类型的Java对象只有一个

    三要素：

    1.构造方法私有化

    2.对外提供一个公开的静态的获取当前类型对象的方法

    3.提供一个当前类型的静态变量

 

懒汉式：当用到对象的时候才去创建

public Class Singleton{

   private static Singleton singObject ;

   private Singleton(){};//构造方法 1.没有任何返回值  2.方法名与类名相同

   public static Singleton getSingleton(){

       if(singObject == null){

           singObject = new Singleton();

          }

     

       return singObject;

    }

}

​

饿汉式：在类加载阶段就创建对象

public class Singleton{

   private static Singleton singObje = new Singleton();

   private Singleton(){}; //构造方法 1.没有任何返回值  2.方法名与类名相同

   public  static Singleton getSingleton(){

       return this.singObje;

    }

}

7.反射：

    就是动态加载对象，并对对象进行剖析。反射机制指在运行状态中，对任意一个类，都知道这个类的所有属性方法；对任意一个对象，都能调用他的任意一个方法，这种动态获取信息以及动态调用对象方法的功能叫反射机制。

Java反射机制的作用：

1）在运行时判断任意一个对象所属的类。

2）在运行时判断任意一个类所具有的成员变量和方法。

3）在运行时任意调用一个对象的方法

4）在运行时构造任意一个类的对象

获得成员变量：Field getField(String name)    

获得成员方法：Method getMethod(String name, Class[] params)

获得构造方法：Constructor getContructors()

 

 Spring中的IoC的实现原理就是工厂模式加反射机制。

eg:jdbc中class.forName("com.mysql.jdbc.Driver").newInstance(); 很多框架都用到反射机制，hibernate，struts都是用反射机制实现的。

 

8.Java中的流：

   字符流Reader Writer 和字节流 InputStream OutputStream

    序列化Serilizable：把对象写入到文件或网络中(将一个对象转换成一串二进制表示的字节数组，通过保存或转移这些字节数据来达到持久化的目的。)

    反序列化：从文件或网络中读取对象(将字节数组重新构造成对象。)

    transient：对于类似身份证 密码。重要的信息不想被序列化用transient修饰

    https://www.cnblogs.com/szlbm/p/5504166.html

    https://www.cnblogs.com/lanxuezaipiao/p/3369962.html

9.两种实现多线程的方式：

    1.继承Thread类

    2.实现Runnable接口

    3.实现Callable接口 通过FutureTask包装器来创建Tread线程

    线程的状态：

    新建 -- 就绪 --运行 --阻塞 --死亡

    

 

    ----各种方法 需要看看

 

！！10.Object的直接子类有哪些？

Class,Integer,Enum,Math,Number,Package,String,StringBuffer,StringBulidler,System,Thread

 

11.静态语言和动态语言区别

 

12 mybatis和heribernate区别  

13 springmvc 和strust2区别

14 spring 和springboot

15 线程  死锁  悲观锁  乐观锁

16  设计模式

 

 

 

性能比较：

冒泡排序：

 

/**

 * 冒泡排序

 *

 * 时间复杂度：   O(n`2)

 * 空间复杂度：   O(1)

 * 稳定性：     稳定

 *

 * 思路：重复走访要排序的序列，一次比较2个元素，如果他们顺序错误将他们进行调换，

 *

 * Name: BubbleSort

 * Description: 

 * @author sj

 * @date 2018年3月20日 上午10:04:51

 */

public class BubbleSort

{

​

    //大---小

    public staticint[] BubbleImpl(int A[]) {

        //表明循环次数   不用与自己比较 所以为A.length-1

        for(int i =0 ;i < A.length-1; i++) {

            //表明

            for(intj = 0;j<A.length-1-i ; j++) {

               if(A[j]<A[j+1]) {

                   int temp = A[j];

                   A[j]    = A[j+1];

                   A[j+1] = temp;

                }

            }

        }

        return(A);

    }

   

    public staticvoid main(String args[]) {

        int A[] ={6,9,3,7,18};

       BubbleSort.BubbleImpl(A);

       System.out.print("冒泡排序结果：");

        for(int i=0;i<A.length;i++) {

           System.out.println(A[i]);

        }

    }

   

}

！！快速排序：

    思路：

        快速排序采用了分治策略。就是在一个数组中取一个基准数字，把小的数放基准的左边，大的数放基准的右边。     

        基准左边和右边分别是新的序列。在新的序列中再取一个基准数字，小的放左边，大的放右边。     

        这个里面用到的递归。我们需要三个参数，一个是数组，另外两个是序列的边界。

 

/**

 * 快速排序：

 *

 * 时间复杂度：O(nlogn)

 * 空间复杂度：O(1)

 * 稳定性： 不稳定

 *

 * 思路：快速排序采用了分治策略。就是在一个数组中取一个基准数字，把小的数放基准的左边，大的数放基准的右边。

 * 基准左边和右边分别是新的序列。在新的序列中再取一个基准数字，小的放左边，大的放右边。

 * 这个里面用到的递归。我们需要三个参数，一个是数组，另外两个是序列的边界

 *

 * Name: QuickSort

 * Description: 

 * @author sj

 * @date 2018年3月20日 上午10:12:10

 */

public class QuickSort

{

​

    //核心  

    public static int[]QuickSortCore(int arr[],int left,int right) {

       if(left<right) {

            //获得基线

            intbase = QuickSortBase(arr,left,right);

            //递归调用

           QuickSortCore(arr,base+1,right);

           QuickSortCore(arr,left,base-1);

        }

        return arr;

    }

   

    //获得基线

    public staticint QuickSortBase(int arr[],int startIndex,int endIndex) {

        int base =arr[startIndex];

        int left =startIndex;

        int right =endIndex;

       while(left<right) {

           while(left<right && arr[right]>=base) {

               right--;

            }

           arr[left]=arr[right];

           while(left<right && arr[left]<=base) {

               left ++;

            }

           arr[right]=arr[left];

        }

        arr[left] =base;

        returnleft;

    }

   

    public staticvoid main (String args[]){

        int A[] ={6,9,3,7,18};

       QuickSort.QuickSortCore(A,0,A.length-1);

       System.out.println("快排结果：");

        for(int i =0;i<A.length;i++) {

           System.out.println(A[i]);

        }

    }

}

！！堆排序：

 

/**

 * 堆排

 *

 * 时间复杂度：O(nlogn)

 * 空间复杂度：O(1)

 * 稳定性： 不稳定

 *

 * 思路：

 *  二叉堆类似二叉树：二叉堆满足2个特性：

 *      1）父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值

 *      2）每个结点的左子树和右子树都是一个二叉堆

 *  堆的存储：

 *      i结点的父结点下标为 （i-1）/2 ; 他的左右子节点为 左：2i+1  右：2i+2

 *

 *  基本思路：

 *      将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。

 *      将它移走（其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值），然后将剩余的 n-1 个序列重新构造成一个堆，

 *      这样就会得到 n 个元素中次大的值。如此反复执行，便能得到一个有序序列了。

 *

 * Name: HeapSort

 * Description:  

 * @author sj

 * @date 2018年3月20日 下午5:05:37

 */

public class HeapSort

{

​

   public static void main(String[] args) {

       int[] array = { 19, 38, 7, 36, 5, 5, 3, 2, 1, 0, 56 };

​

       System.out.println("排序前:");

       for (int i = 0; i < array.length; i++) {

           System.out.print(array[i] + ",");

       }

​

       System.out.println();

       System.out.println("分割线---------------");

​

       heapSort(array);

​

       System.out.println("排序后:");

       for (int i = 0; i < array.length; i++) {

           System.out.print(array[i] + ",");

       }

    }

​

   public static void heapSort(int[] array) {

       if (array == null || array.length == 1)

           return;

​

       buildMaxHeap(array); // 第一次排序，构建最大堆，只保证了堆顶元素是数组里最大的

​

       for (int i = array.length - 1; i >= 1; i--) {

           // 这个是什么意思呢？，经过上面的一些列操作，目前array[0]是当前数组里最大的元素，需要和末尾的元素交换

           // 然后，拿出最大的元素

           swap(array, 0, i);

​

           // 交换完后，下次遍历的时候，就应该跳过最后一个元素，也就是最大的那个值，然后开始重新构建最大堆

           // 堆的大小就减去1，然后从0的位置开始最大堆

//            maxHeap(array, i, 0);

           minHeap(array, i, 0);

       }

    }

​

    // 构建堆

   public static void buildMaxHeap(int[] array) {

       if (array == null || array.length == 1)

           return;

​

       // 堆的公式就是 int root = 2*i, int left =2*i+1, int right = 2*i+2;

       int cursor = array.length / 2;

       for (int i = cursor; i >= 0; i--) { // 这样for循环下，就可以第一次排序完成

//            maxHeap(array, array.length, i);

           minHeap(array, array.length, i);

       }

    }

​

    // 最大堆

   public static void maxHeap(int[] array, int heapSieze, int index) {

       int left = index * 2 + 1; // 左子节点

       int right = index * 2 + 2; // 右子节点

       int maxValue = index; // 暂时定在Index的位置就是最大值

​

       // 如果左子节点的值，比当前最大的值大，就把最大值的位置换成左子节点的位置

       if (left < heapSieze && array[left] >array[maxValue]) {

           maxValue = left;

       }

​

       // 如果右子节点的值，比当前最大的值大，就把最大值的位置换成右子节点的位置

       if (right < heapSieze && array[right] >array[maxValue]) {

           maxValue = right;

       }

​

       // 如果不相等，说明啊，这个子节点的值有比自己大的，位置发生了交换了位置

       if (maxValue != index) {

           swap(array, index, maxValue); // 就要交换位置元素

​

           // 交换完位置后还需要判断子节点是否打破了最大堆的性质。最大堆性质：两个子节点都比父节点小。

           maxHeap(array, heapSieze, maxValue);

       }

    }

​

    // 最小堆

   public static void minHeap(int[] array, int heapSieze, int index) {

       int left = index * 2 + 1; // 左子节点

       int right = index * 2 + 2; // 右子节点

       int maxValue = index; // 暂时定在Index的位置就是最小值

​

       // 如果左子节点的值，比当前最小的值小，就把最小值的位置换成左子节点的位置

       if (left < heapSieze && array[left] <array[maxValue]) {

           maxValue = left;

       }

​

       //  如果右子节点的值，比当前最小的值小，就把最小值的位置换成左子节点的位置

       if (right < heapSieze && array[right] <array[maxValue]) {

           maxValue = right;

       }

​

       // 如果不相等，说明啊，这个子节点的值有比自己小的，位置发生了交换了位置

       if (maxValue != index) {

           swap(array, index, maxValue); // 就要交换位置元素

​

           // 交换完位置后还需要判断子节点是否打破了最小堆的性质。最小性质：两个子节点都比父节点大。

           minHeap(array, heapSieze, maxValue);

       }

    }

​

    // 数组元素交换

   public static void swap(int[] array, int index1, int index2) {

       int temp = array[index1];

       array[index1] = array[index2];

       array[index2] = temp;

    }

}

回

 

 

 

计算机网络：

此文很全很好  好好看   这个人好流B呀   好好看看他的其他文章也

http://www.cnblogs.com/wxisme/p/4699049.html

计算机网络的层次结构：

    相互通信的两个计算机系统必须高度协调工作才行，而这种“协调”是相当复杂的。“分层”可将庞大而复杂的问题，转化为若干较小的局部问题，而这些较小的局部问题就比较易于研究和处理。现在有两种国际标准，一种是OSI标准，是法律上的标准，但是没有被市场认可。一种是事实上的标准TCP/IP标准。

五层协议的体系结构：

应用层(application layer) 

运输层(transport layer) 

网络层(network layer) 

数据链路层(data link layer) 

物理层(physical layer) 

！！！

各层的协议？如上图

运输层协议TCP UDP 区别？

TCP的三次握手，四次握手？

 

应用层：