招银网络java面经

1. java有哪些基本类型？

byte:1B，short:2B，int:4B，long:8B，float:4B，double:8B，boolean:1B

2.有了基本类为什么还有有包装类？

首先，java是面向对象的语言，而基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型，它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

另外，当基本类型的变量作为函数参数时，往往是值传递，函数内部对此参数的修改并不会修改原变量，而当需要对原变量本身进行修改时，则需要引用传递，就需要使用包装类。因此Collection包里定义的容器都是装Object的，不能装基本类型，而要装基本类型的包装类。

3.泛型的作用？

泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

通过泛型可以定义类型安全的数据结构（类型安全），而无须使用实际的数据类型（可扩展）。这能够显著提高性能并得到更高质量的代码（高性能），因为可以重用数据处理算法，而无须复制类型特定的代码（可重用）。

4.重载和重写的区别？重载时只是返回值类型不同可以吗？为什么不可以？

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。因为调用这个方法的时候，可以不指定其返回值类型，如果仅仅是返回值类型不相同，这样编译器就不知道调用的是哪个方法了。

重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。

5.java多线程中的乐观锁和悲观锁？

乐观锁和悲观锁都是逻辑上的锁的分类，乐观锁是每次执行时先假设没有竞争，执行完了再检查是否有竞争，乐观锁可使用CAS（compare and swap）和版本号的方式实现。悲观锁是每次执行前都假设有竞争，先获得锁不让别的线程进入临界区，使用synchronized和ReentrantLock实现。

6.读写锁了解吗？（问的java中的读写锁，答成了mysql中的）

ReentrantReadWriteLock：读的时候为共享锁，写的时候为独占锁

7.mysql的union 和union all有啥区别？

UNION 的语法：[SQL 语句 1] UNION [SQL 语句 2]

UNION ALL 的语法：[SQL 语句 1] UNION ALL [SQL 语句 2]

UNION和UNION ALL关键字都是将两个结果集合并为一个，但这两者从使用和效率上来说都有所不同。

1）对重复结果的处理：UNION在进行表连接后会筛选掉重复的记录，Union All不会去除重复记录。

2）对排序的处理：Union将会按照字段的顺序进行排序；UNION ALL只是简单的将两个结果合并后就返回。

从效率上说，UNION ALL 要比UNION快很多，所以，如果可以确认合并的两个结果集中不包含重复数据且不需要排序时的话，那么就使用UNION ALL。

8.having的作用？不使用group by能用having吗？

过滤不符合条件的分组，会过滤掉整个分组，只能跟在group by后使用。

9.讲一下单例模式的实现方式 ？

单例模式：在一个系统运行期间，某个类只需要一个类实例就可以了，并提供一个访问它的全局访问点。

五种实现方式：

1） 线程安全的饿汉式

/**

 * 饿汉单例模式：在类加载时就实例化，之后不再实例化，线程安全，但还没用就先实例化占堆空间

 */

public class Hungry {

    //static类型的变量只会在类加载时实例化一次，保证只有一个对象

    private static Hungry instance = new Hungry();//静态变量不一定是全局可见的，声明成private类型就只能内部可见了

    private Hungry(){//构造函数私有化，构造函数默认没有返回值，不用加void

    }

    public static Hungry getInstance(){//没法在外面实例化后调用这个方法，所以只能在这里实例化

        return instance;

    }

}

2）线程不安全的懒汉式

/**

 * 懒汉单例模式：用它的时候才实例化，每次实例化之前检查下是否已有实例，没有才创建

 * 不加synchronized会线程不安全，但加了后但每次检查都要加锁太慢了

 */

public class Lazy {

    private static Lazy instance;

    private Lazy(){}

    public static synchronized Lazy getInstance(){

        if (instance == null){

            instance = new Lazy();

//            return instance;

        }

        return instance;

    }

}

3）线程安全的双重校验的懒汉式

/**

 * 双重校验的懒汉单例模式，只有当第一次检查没有实例时，才加锁进行第二次检查。如果检查到已有实例了，就不用加锁检查了。

 */

public class LazyDubbleCheck {

    private static LazyDubbleCheck instance;

    private LazyDubbleCheck(){}

    public static LazyDubbleCheck getInstance(){

        if (instance == null){

            synchronized (LazyDubbleCheck.class){//不能用this作为锁对象，因为this是和对象关联的，是对象自身的引用，一个类的不同实例有不同的this。所以只能锁类

                if (instance == null){

                    instance = new LazyDubbleCheck();

                }

            }

        }

        return instance;

    }

}

4)线程安全又可实现懒加载的静态内部类方式

/**

 * 既能实现延迟创建，又不用sychronized的方法，就是在静态内部类的静态变量中创建实例。

 * 因为内部类是使用时才会执行类加载，在类加载期间就会初始化静态变量，线程安全。

 */

public class InnerClass {

    private static class Inner{

        private static InnerClass instance = new InnerClass();

    }

    private InnerClass(){};

    public static InnerClass getInstance(){

        return Inner.instance;

    }

}

5)最简单的枚举类方式

public enum Enum {

    instance;//每个枚举常量都是一个实例，通过public static final域为枚举常量导出实例，由jvm保证线程安全。

}