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()方法。
1 public void attack() { 2 System.out.println(name + " 进行了一次攻击 ,但是不确定打中谁了"); 3 } 4 5 public void attack(Hero h1) { 6 System.out.println(name + "对" + h1.name + "进行了一次攻击 "); 7 } 8 9 public void attack(Hero h1, Hero h2) { 10 System.out.println(name + "同时对" + h1.name + "和" + h2.name + "进行了攻击 "); 11 }
重载与重写的区别:
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. 基本数据类型作为参数时,是传递这个值的拷贝,而原值并没有改变
1 public static void change(int n){ 2 n = n + 10; 3 } 4 5 public static void main(String[] args) { 6 7 int n = 8; 8 change(n); 9 ////这里输出是8而不是18,因为参数是基本类型的时候,是传递这个值的拷贝,而原值并没改变,所以这里输出的是原来的n 10 System.out.println(n);
2.引用作为参数时,是把引用指向内存中的地址拷贝了一份传给了参数
先是原来的引用和参数里的引用都指向同一个内存地址,指向"Hello "这个对象,然后参数的引用通过append方法改变了对象的值
所以这时原来的引用指向的对象的值为"Hello bro"了
1 public static void change1(StringBuffer sb){ 2 sb.append("bro"); 3 } 4 5 public static void main(String[] args) { 6 7 StringBuffer sb = new StringBuffer("Hello "); 8 change1(sb); 9 //先是原来的引用和参数里的引用都指向同一个内存地址,指向"Hello "这个对象10 //然后参数的引用通过append方法改变了对象的值,所以这时原来的引用指向的对象的值为"Hello bro"了 11 System.out.println(sb);
3.一个参数的引用改变了指向的例子
1 public static void change1(String str){ 2 str = str + "bro"; 3 } 4 5 public static void main(String[] args) { 6 7 String str = "Hello "; 8 change1(str); 9 //此时输出依然是"Hello ",因为在做字符串拼接时,参数的引用str指向了一个新的对象"Hello bro",指向的内存地址变了 10 //而原来的引用还是指向旧的内存地址,指向的是"Hello " 11 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的移位运算
正数:
1 int x = 20; 2 /* 3 * 在二进制中的形式为:0000 0000 0000 0000 0000 0000 0001 0100 4 */ 5 System.out.println(x << 1); 6 /* 7 * 向左移1位,就变成:0000 0000 0000 0000 0000 0000 0010 1000 8 * x变成了40,说明左移一位等于乘以2*/ 9 10 System.out.println(x >> 1); 11 /* 12 * 向右移1位,就变成:0000 0000 0000 0000 0000 0000 0000 1010 13 * x变成了10,说明右移一位等于除以2 14 * */
负数:
1 int x = -11; 2 /* 3 * 在二进制中的形式为:1111 1111 1111 1111 1111 1111 1111 0101 4 */ 5 System.out.println(x << 1); 6 /* 7 * 向左移1位,就变成:1111 1111 1111 1111 1111 1111 1110 1010 8 * x变成了-22,说明左移一位等于乘以2*/ 9 10 System.out.println(x >> 1); 11 /* 12 * 向右移1位,就变成:1111 1111 1111 1111 1111 1111 1111 1010 13 * x变成了-6,说明负数是单数的话右移一位等于(x-1)/2,正数是单数的话右移一位也是等于(x-1)/2 14 * */
结论:不论单复数,如果是双数的话,左移一位就是乘以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