复习Java基础的总结随笔

Java的基本类型有8种，整型4种：byte, short, int, long; 浮点型2种：float, double(其中小数默认为double，要用float需在数后加f); 

字符型1种：char; 布尔型1种：boolean.

所有的基本类型都有其对应的类类型，同种之间可以自动装、拆箱，不同种之间不行。

异常分三类：错误(Error)，运行时异常(RuntimeException)，可查异常。

错误指的是系统级别的异常，通常是OutOfMemoryError，不要求强制捕捉

运行时异常不是必须进行try catch，常见的有ArthmeticException, ArrayIndexOutOfBoundsException, NullPointerException

可查异常即必须进行处理的异常，要么try catch，要么throws，不处理编译器则不通过

Vector是线程安全的类，ArrayList非线程安全；

StringBuffer是线程安全的类，StringBuilder非线程安全；

String是类类型，是用final修饰的，是immutable的，即一旦创建好，则不可改变，而String的+拼接，底层是用StringBuilder来实现的。

Collection是List和Set等这些接口的父接口

Collections则是工具类，提供了reverse, shuffle, sort, swap, rotate等方法

逻辑操作符：

1. &&这样长的叫短路与，&这样短的叫长路与（区别是短路与只要前面判断成功，就不会进行后面的运算；长路则即使前面判断成功也进行后面运算）

2.例子：int i = 1; (i++ == 3)&(i ++ == 2)最后i = 3。int i = 1; (i++ == 3)&&(i++ == 2)最后i = 2。

3. &叫与，只要有一边为false时则为false。|叫或，只要有一边为true，则为true。

4. ^叫异或，只有一边为true一边为false的时候才为true，两边都是false或两边都是true，则为false（如上图所示）。

final, finally, finalize的区别

1. final是修饰符，修饰类（表示该类不可继承），方法（表示该方法不能被重写），基本类型变量（表示该变量只能被赋值一次，也就是不可变的变量，则变为常量），引用（表示该引用只有一次指向对象的机会）（引用与对象的区别：Hero h = new Hero()，h为引用，new Hero()为对象）。

2. finally是try catch块最后的finally{}块，无论是否抛出异常都会最后执行finally块。

3. finallize是Object类的方法，所有的类都继承了该方法，当一个对象满足垃圾回收的条件并且被回收的时候，就会调用finalize()方法。

public void attack() {
        System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");
    }
 
    public void attack(Hero h1) {
        System.out.println(name + "对" + h1.name + "进行了一次攻击 ");
    }
 
    public void attack(Hero h1, Hero h2) {
        System.out.println(name + "同时对" + h1.name + "和" + h2.name + "进行了攻击 ");
    }

重载与重写的区别：

1. 重载指的是方法名字一样，但是参数的类型或者数量并不一样。事实上，重载的方法除了同名之外还可以返回类型不一样，因为重载其实本质上是完全不同的方法，只不过名字一样而已（如上图）。

2. 重写指的是子类继承了父类，并把父类提供的某方法重写了一遍，进行了不同的实现

抽象类（Abstract class）与接口（Interface）的区别

1. 抽象类只能通过继承被使用，抽象类本身是不可以实例化的。抽象类不仅可以提供实现抽象方法（即没有实现内容的方法）如public abstract void creep(); 还可以提供正常的实现方法。

2. 接口其实可看做一套标准，里面规定了一系列方法，供其实现类来实现这些方法。接口里的方法默认是抽象的，但Java8之后可以提供正常实现方法了，不过前面要加个default修饰符。

所以其实抽象类和接口的区别正在变得越来越小了。

3. 接口可以继承接口，抽象类可以实现（也就是implements）接口，抽象类可以继承实体类（如，所有抽象类都继承了Object类）

————————————————————————————————————————————————————————————————

数组获取长度的手段是.length属性

String获取长度的手段是length()方法

集合获取长度的手段是size()方法

文件获取长度的手段是length()方法

synchronized与java.util.concurrent.locks.Lock的异同

1. Lock是一个接口，而synchronized是Java的关键字，synchronized是内置的语言实现，Lock是代码层面的实现

2. Lock可以选择性地获取锁，如果一段时间获取不到，可以放弃。而synchronized不行，会一直获取下去。借助Lock的这个特性，就能够规避死锁，synchronized则必须通过谨慎和良好的设计才能减少死锁的发生

3. synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放锁，如果忘记了释放锁，一样会造成死锁

另注意：当一个线程进入了一个对象的一个synchronized方法后，如果该对象的其他方法也是synchronized方法，那么其他线程就访问不了该对象的其他方法，否则其他线程可以进入该对象的其他方法

基本数据类型和对象传参数时的不同

1. 基本数据类型作为参数时，是传递这个值的拷贝，而原值并没有改变

public static void change(int n){
        n = n + 10;
    }
    
    public static void main(String[] args) {
        
        int n = 8;
        change(n);
        ////这里输出是8而不是18，因为参数是基本类型的时候，是传递这个值的拷贝，而原值并没改变，所以这里输出的是原来的n
        System.out.println(n);

2.引用作为参数时，是把引用指向内存中的地址拷贝了一份传给了参数

先是原来的引用和参数里的引用都指向同一个内存地址，指向"Hello "这个对象，然后参数的引用通过append方法改变了对象的值

所以这时原来的引用指向的对象的值为"Hello bro"了

public static void change1(StringBuffer sb){
        sb.append("bro");
    }
    
    public static void main(String[] args) {
        
        StringBuffer sb = new StringBuffer("Hello ");
        change1(sb);
        //先是原来的引用和参数里的引用都指向同一个内存地址，指向"Hello "这个对象10         //然后参数的引用通过append方法改变了对象的值，所以这时原来的引用指向的对象的值为"Hello bro"了
        System.out.println(sb);

3.一个参数的引用改变了指向的例子

public static void change1(String str){
        str = str + "bro";
    }
    
    public static void main(String[] args) {
        
        String str = "Hello ";
        change1(str);
        //此时输出依然是"Hello "，因为在做字符串拼接时，参数的引用str指向了一个新的对象"Hello bro"，指向的内存地址变了
        //而原来的引用还是指向旧的内存地址，指向的是"Hello "
        System.out.println(str);

Mybatis缓存

1. 一级缓存(SqlSession级别的缓存)

一级缓存，也就是SqlSession级别的缓存，是默认开启的，每个SqlSession类的实例对象中都有一个HashMap来存储缓存数据，不同的SqlSession类的实例对象的缓存区域(HashMap)是互不影响的。当同一个SqlSession执行两次相同的sql查询语句时，第一次会访问DB并将数据写入内存中，第二次则不会

2. 二级缓存（Mapper级别的缓存）

二级缓存，要在配置文件中设置cacheEnable = true来开启。一个Mapper配置文件中的sql语句是由多个SqlSession类的实例对象操作的，多个SqlSession类的实例对象可以共用一个二级缓存。二级缓存区域是按照namespace来区分的，多个同namespace的Mapper共用一个二级缓存。

父类引用指向子类对象

先给个前提，A是父类，B是子类，父类引用指向子类对象就是 A a = new B();

我一直不明白父类引用指向子类对象到底有什么用，因为这样子的话，a是不能用B类自己的非重写方法的，如下图所示：

所以我就纳闷，直接用B b = new B()不好吗，又能用父类方法和变量，又能用自己的方法和变量

考虑这样一个情景：现在需要创建一个对象，它不能用B类的非重写方法，但又要用B类的重写过的方法，那就只有A a = new B()符合了

事实上，父类引用指向子类对象是为了多态和解耦。应该说先是有A，然后业务的变更使得要使用多态，所以才创一个B出来，这样就不用去改A里面的东西了，直接在B里重写方法就行了，实现了多态和解耦

HashMap, Hashtable, ConcurrentHashMap的区别

HashMap是非线程安全的，Hashtable是线程安全的（但是因为加锁是在方法上加synchronized等于锁的是Hashtable本身，所以效率很低），ConcurrentHashMap则又是线程安全的，又是高效的

变量命名只能用字母，数字，$, _；变量的第一个字符，不能使用数字

Java的移位运算

正数：

int x = 20;
/*
* 在二进制中的形式为：0000 0000 0000 0000 0000 0000 0001 0100
*/
System.out.println(x << 1);
/*
* 向左移1位，就变成：0000 0000 0000 0000 0000 0000 0010 1000
* x变成了40，说明左移一位等于乘以2*/

 System.out.println(x >> 1);
/*
* 向右移1位，就变成：0000 0000 0000 0000 0000 0000 0000 1010
* x变成了10，说明右移一位等于除以2
* */

负数：

int x = -11;
/*
* 在二进制中的形式为：1111 1111 1111 1111 1111 1111 1111 0101
*/
System.out.println(x << 1);
/*
* 向左移1位，就变成：1111 1111 1111 1111 1111 1111 1110 1010
* x变成了-22，说明左移一位等于乘以2*/

System.out.println(x >> 1);
/*
* 向右移1位，就变成：1111 1111 1111 1111 1111 1111 1111 1010
* x变成了-6，说明负数是单数的话右移一位等于(x-1)/2，正数是单数的话右移一位也是等于(x-1)/2
* */

结论：不论单复数，如果是双数的话，左移一位就是乘以2，右移一位就是除以2；如果是单数的话，左移一位就是乘以2，右移一位就是(x-1) / 2

 

————————————————————————————————————————————————————————————————

Firstly written on Sept. 26th, 2019

Secondly supplemented on Sept. 27th, 2019

Thirdly supplemented on Sept. 30th, 2019

Forthly written on Oct. 17th, 2019