java面试-基础部分

1.面向对象

什么是面向对象？与面向过程有什么不同？
面向过程更注重事情的每一个步骤及顺序，面向对象更注重事情有哪些参与者(对象)，及各自需要做什么。

• 封装： 明确标识出允许外部使用的所有成员函数和数据项，内部细节对外部调用透明
• 继承： 继承基类的方法，做出自己的改变或拓展
• 多态： 基于对象所属类的不同，外部对同一个方法的调用，实际执行的逻辑不同。继承，方法重写，父类引用指向子类对象

2.JDK,JRE,JVM区别和联系

• JDK(Java Develpment Kit) java开发工具
• JRE(Java Runtime Environment) java运行时环境
• JVM(Java Virtual Machine) java虚拟机

JDK包含JRE，JRE又包含JVM

3.==和equals

根据JVM的知识：
栈是JVM的内存指令区，java基本数据类型，对象引用都保存在栈中。
堆是JVM的内存数据区，保存对象实例。
若声明一个对象，则先在栈中内存中为其分配地址空间，若再new一下，实例化它，则在堆内存中为其分配地址。

==对比的是栈中的值，基本数据类型是变量值，引用类型是堆中内存对象的引用（地址）

equals默认也是==比较，通常会重写
object类里面的equals为

public boolean equals(Object obj) {
        return (this == obj);
}

String将它重写为，先比较地址，再挨个比较字符

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

面试题举例

        String str1 = "hello";
        String str2 = new String("hello");
        String str3 = str2;

        System.out.println(str1 == str2); //false
        System.out.println(str1 == str3); //false
        System.out.println(str2 == str3); //true
        System.out.println(str1.equals(str2)); //true
        System.out.println(str1.equals(str3)); //true
        System.out.println(str2.equals(str3)); //true

str1存在堆里的常量池，str2存在堆，所以str1地址与str2地址肯定不相等，str3存放了str2的引用，所以地址一模一样。

4.final

• 修饰类：表示类不可被继承
• 修饰方法：方法不可被字类覆盖，但是可以重载
• 修饰变量：变量一旦被赋值就不可以更改它的值

（1）修饰成员变量（在类里定义的变量）

• 如果final修饰类变量，只能在静态初始化块中指定初始值或者声明该类变量时指定初始值。

	//类变量
    final static int a = 0;
    /*
    static  {
        a = 0;
    }
    */

• 如果final修饰成员变量，可以在非静态初始化块、声明时或者构造器中执行初始值。

	//局部变量
    final int b = 0;
    /*
    {
        b = 0;
    }
    */

（2）修饰局部变量（方法里定义的变量）
系统不会为局部变量进行初始化，局部变量必须由程序员显示初始化。使用时可在定义时指定默认值，也可以不指定，但在用之前一定要赋值（仅一次）。

final int localA; //可以不指定值
localA = 0; //使用之前一定要赋值

注：修饰引用类型的变量，在初始化后不能再指向另一个对象，但是引用的值可变。

final int[] iarr = {1, 2, 3, 4};
iarr[2] = -3; //合法
iarr = null; //非法

为什么局部内部类和匿名内部类只能访问局部final变量？
编译之后会生成两个class文件，Test.class Test1.class

	public void test(final int b) {
        final int a = 10;
        //匿名内部类
        new Thread() {
            public void run() {
                System.out.println(a);
                System.out.println(b);
            };
        }.start();
    }

    public void outPrint(final int x) {
        //局部内部类
        class InClass {
            public void InPrint() {
                System.out.println(x);
            }
        }
        new InClass().InPrint();
    }

首先，内部类和外部类处于同一个级别，内部类不会因为定义在方法中就随着方法的执行完毕就被销毁。
那么，当外部类方法结束时，局部变量就被销毁，但是内部对象可能存在，而内部对象引用了一个不存在的变量。为了解决这个问题，就将局部变量复制了一份作为内部类的成员变量，这样当局部变量死亡后，内部类仍然可以“访问它”，实际访问的是局部变量的copy。
既然访问的是copy，为了确保访问一致性，所以要将局部变量定义为final。

5.String、StringBuffer、StringBuilder

String是final修饰的，不可变，每次操作都会产生新的String对象
StringBuffer和StringBuilder都在原对象上操作
StringBuffer线程安全，StringBuilder线程不安全。这是因为StringBuffer使用synchronized修饰方法，StringBuilder裸奔。
性能：StringBuilder>StringBuffer>String

优先使用StringBuilder，多线程使用共享变量时使用StringBuffer。

为什么要把String设置为不可变的？
1.让它们可共享。字面赋值的String会先去字符串常量池去寻找是否存在该值，如果存在则不会创建一个新的对象，而是引用已经存在的对象。（new形式的String不会用到常量池）
2.允许String对象缓存hashCode。String对象的哈希码被频繁使用，比如hashMap容器。字符串不变性可以放心进行缓存哈希码。
3.安全性。String被很多类用来当作参数，URL、文件路径path，倘若String不是固定的，就会引起各种安全隐患。

6.重载和重写

重载：发生在同一个类中，方法名必须相同，参数类型不同，个数不同，方法返回值和访问修饰符可以不同，发生在编译时。

	//直接报错
    public int add(int a, String b){
        return 0;
    }
    public String add(int a, String b){
        return null;
    }

重写：发生在父子类中，方法名，参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符大于等于父类，如果父类访问修饰符为private则子类不能重写该方法。

7.接口与抽象类

• 成员变量区别：抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的
• 成员函数区别：抽象类可以存在普通成员函数，而接口中只能存在public abstract方法，且接口没有方法体
• 抽象类只能继承一个，接口可以实现多个

接口设计的目的，是对类的行为进行约束，也就是提供一种机制，可以强制要求不同的类具有相同的行为，只约束了行为的有无，但不对如何实现进行限制。
抽象类设计的目的，是代码复用。当不同的类具有某些相同的行为，可以把这些行为抽离出来，派生于一个抽象类，达到代码复用的目的（比如模板方法模式）。
抽象类是对类本质的抽象，抽象类包含并实现子类的通用特性，将子类存在差异化的特性进行抽象，交由子类去实现。
接口是对行为的抽象，接口的核心是定义行为，即实现类可以做什么，至于实现类主体是谁，是如何实现的，接口并不关心。

8.List与Set

• List:有序，按对象进入的顺序保存对象，可使用数组和链表实现，可重复，允许多个Null元素对象，可以使用Iterator取出所有元素，还可以使用get(int index)获取指定下标的元素。
• Set:无序（会按照元素的值自动排序），不可重复，使用红黑树，最多允许一个Null元素对象，取元素时只能用Iterator接口取得所有元素。

9.hashCode与equals

hashCode介绍：
hashCode()的作用是获取哈希码，也称为散列码，它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置（key）,对应的value是对象在堆中的地址。hashCode()定义在Object中，java中的任何类都包含有hashCode()函数。利用哈希表，能快速找到所需要的对象。

hashCode和equals的关系：
哈希表的实现使用的是HashSet，对象加入HashSet时，HashSet会先计算对象的hashCode值来判断对象加入的位置，看该位置是否有值，如果没有，HashSet会假设对象没有重复出现，如果有值，会调用equals()方法来检查两个对象是否真的相同。如果二者相同，HashSet就不会让其加入操作成功。如果不同，就重新散列到其他位置。这样就大大减少了equals()的次数，提高了执行速度。

• 如果两个对象相等，则hashCode一定相同
• 两个对象相等，分别调用equals()方法都返回true
• 两个对象有相同的hashCode值，他们也不一定相等
• hashCode的默认行为是对堆上的对象产生独特值，如果没有重写，则该class的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)

10.ArrayList与LinkedList

ArrayList：

• 基于动态数组，连续内存存储，适合下标访问(随机访问)
• 默认容量为10，达到容量的0.75扩容1.5倍(通过新建数组复制扩容)
• 使用尾插法并指定初始容量可以极大提升性能，甚至超过LinkedList(需要创建大量的node对象)

LinkedList：

• 基于链表，可以存储在分散的内存中
• 适合数据插入及删除，不适合查询
• 遍历必须使用iterator不能用for循环，因为每次for循环体内通过get(i)取得某一元素时都需要对list重新遍历，性能消耗极大
• 不要试图使用indexOf等返回元素索引，并利用其进行遍历，使用indexOf对list进行了遍历，当结果为空时会遍历整个链表

11.HashMap与HashTable

区别：

• HashMap方法没有synchronized修饰，线程非安全，HashTable每个方法都有synchronized修饰，所以线程安全
• HashMap允许key和value为null，而HashTable不允许

底层实现：数组 + 链表实现
jdk8开始链表高度到8、数组长度超过64，链表转变为红黑树，元素以内部Node节点存在(存hash, key. value, next四个参数)

• 计算key的hash值，二次hash然后对数组长度取模，对应到数组下标
• 如果没有产生hash冲突(下标位置没有元素)，直接创建Node存入数组
• 如果产生hash冲突，先进行equals比较，相同则取代该元素，不同，则判断链表高度插入链表，链表高度达到8，并且数组长度到64则转变为红黑树，长度低于6则将红黑树转回链表
• key为null，存在下标0的位置

关于HashMap的源码，可参加大佬HashMap详解

12.ConcurrentHashMap

jdk7:
数据结构：ReentrantLock+Segment+HashEntry，一个Segment中包含一个HashEntry数组，每个HashEntry又是一个链表结构
元素查询：二次hash，第一次Hash定位到Segment，第二次Hash定位到元素所在的链表的头部
锁：Segment分段锁，Segment继承了ReentrantLock，锁定操作的Segment，其他的Segment不受影响，并发度为Segment个数，可以通过构造函数指定，数组扩容不会影响其他的Segment
get方法无需加锁，对value的volatile保证

jdk8:
数据结构：synchronized+CAS+Node+红黑树，Node的val和next都用volatile修饰，保证可见性
查找，替换，赋值操作都用CAS
锁：锁链表的head节点，不影响其他元素的读写，锁粒度更细，效率更高，扩容时，阻塞所有的读写操作，并发扩容
读操作无锁：Node的val和next使用volatile修饰，读写线程对该变量互相可见，数组用volatile修饰，保证扩容时被读线程感知

13.如何实现一个IOC容器

1. 配置文件配置包扫描路径
2. 递归包扫描获取.class文件
3. 反射，确定需要交给IOC管理的类
4. 对需要注入的类进行依赖注入

• 配置文件中指定需要扫描的包路径
• 定义一些注解，分别表示访问控制层，业务服务层，数据持久层，依赖注入注解，获取配置文件注解
• 从配置文件中获取需要扫描的包路径，获取到当前路径下的文件信息及文件夹信息，我们将当前路径下所有以.class结尾的文件添加到一个set集合中进行存储
• 遍历这个set集合，获取在类上有指定注解的类，并将其交给IOC容器，定义一个安全的Map用来存储这些对象
• 遍历这个IOC容器，获取到每个类的实例，判断里面是否有依赖其他的类的实例，然后进行递归注入

14.java中的异常体系

java中的所有异常都来自顶级父类Throwable，只有Throwable的实例才可以被抛出(throw)或者捕获(catch)。
Throwable下有两个子类Exception和Error
Error是程序无法处理的错误，一旦出现这个错误，则程序将被迫停止运行
Exception不会导致程序停止，又分为两个部分RunTimeException运行时异常和CheckedException检查异常。
RunTimeException常常发生在程序运行过程中，会导致程序当前执行失败。CheckedException常常发生在程序编译过程中，会导致程序编译不通过。

15.单例模式：饿汉式与懒汉式

单例模式，顾名思义，只能有一个实例对象。典型应用场景是 Spring 中 Bean 实例，它默认就是 singleton 单例模式。

饿汉式：一开始就创建好对象，每次直接拿就行。
懒汉式：一直到真正使用对象的时候才创建。
先来看简单的饿汉式：类一加载就实例化，空间换时间的思路，线程安全。

class Singleton{
	//私有的构造函数，保证外类不能实例化本类
	private Singleton(){}
	//自己创建一个类的实例化
	private static Singleton singleton = new Singleton();
	//创建一个get方法，返回一个实例s
	public static Singleton getInstance(){
		return singleton;
	}
}

再来看看懒汉式：真正使用才会实例化，时间换空间的思路，线程不安全。

class Singleton {
	// 私有的构造函数，保证外类不能实例化本类
	private Singleton() {
	}
 
	// 自己创建一个类的实例化
	private static Singleton singleton;
 
	// 创建一个get方法，返回一个实例s
	public static Singleton getInstance(){
		//判断singleton是否为null，如果为null，即判定需要实例化
		if (singleton == null) {
			singleton = new Singleton();
		}
		return singleton;
	}
}

可以使用双重检查加锁，让懒汉式线程安全。

public class Singleton {
    private volatile static Singleton uniqueInstance;

    private Singleton() {}

    //同步方法 缺点是每次都要同步 拖垮性能
    /*public static synchronized Singleton getInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }*/

    //同步代码块 双重检查加锁
    public static Singleton getInstance() {
        if (uniqueInstance == null){
        	//锁住类
            synchronized (Singleton.class){
                if (uniqueInstance == null)
                    uniqueInstance = new Singleton();
            }
        }
        return uniqueInstance;
    }
}

变量加volatile修饰，可以禁止指令重排，并且保证变量的可见性。
uniqueInstance = new Singleton()原本的逻辑：

1. 为uniqueInstance分配内存空间
2. 初始化uniqueInstance
3. 将uniqueInstance指向分配的内存地址

jvm可能重排为1->3->2。在多线程环境下，会出现问题，比如T1线程执行了1和3，此时T2调用getInstance()发现uniqueInstance不为空，因此返回了uniqueInstance，而此时的uniqueInstance还未被初始化。

16.哪些地方用到了什么设计模式

队列同步器使用了模板方法模式，在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。

17.怎么理解反射

在运行状态中，对于任意一个类，可以动态的创建类的对象，对于任意一个对象都能调用它的任意一个属性和方法。这种在运行时动态获取类的信息以及动态调用对象的方法的机制称为Java反射。

获取Class对象的三种方法

//方法一：通过实例拿类
Test test = new Test();
Class clazz1 = test.getClass();
System.out.println(clazz1.getName());
//方法二：通过Class静态方法拿类
Class clazz2 = Class.forName("com.atguigu.geekThread.Test");
System.out.println(clazz2.getName());
//方法三：类.class
Class clazz3 = Test.class;
System.out.println(clazz3.getName());

18.怎么理解java的三大特性

封装性
把数据和基于数据的操作隐藏起来，使其成为一个不可分割的整体，数据隐藏在抽象数据内部，尽可能的隐藏数据细节，只保留一些接口使其与外界发生联系，用户无需知道内部数据和方法的实现细节，只需根据留在外部的接口进行操作。
典型的例子就是项目中经常用到的get/set操作。

优点：
1.提高安全性
2.便于使用

继承
为了提高代码复用，但是《设计模式》里有说，不推荐使用继承来实现某个功能，因为这会存在高耦合，和代码开发高类聚低耦合相悖。

多态
三要素：

1. 必须有子类和父类，具有继承或实现
2. 子类必须重写父类的方法
3. 父类的引用变量指向子类的对象

也就是说，可以将子类的对象赋给超类变量。
变量所引用的具体类型在编译时并不确定，只有在程序运行期间才能决定(编译期看父类，运行期看子类)。如果有两个类，一个Person类，一个Student类，Student继承至Person，并且扩展了方法，那么以Person person = new Student()创建的person对象不能使用Student新扩展的方法(直接在编译就报错)。

优点：

1. 灵活性，在应用中体现了多样的操作，设计模式很多都使用了多态的性质。
2. 可扩充性。