Java基础常见面试题

1、重载和重写的区别

首先，重写存在于子类与父类中，重载存在于一个类中
重写（override）：
重写是覆盖了原来的方法，实现不同的功能。一般用于子类在继承父类时，重写父类中的方法。
重写规则：

• 1、参数列表与原来相同
• 2、访问修饰符不能小于原方法（public>protected>default>private）
• 3、返回值一致
• 4、声明为final的方法不能被重写。声明为static的方法不能被重写，但是能够被再次声明。
• 5、构造方法不能被重写。如果不能继承一个方法，则不能重写这个方法。
  重载（overloading）：
  重载是在一个类中，方法名相同，参数不同。返回值可以相同也可以不同，每个重载的方法都必须有一个独一无二的参数类型列表。
  重载规则：
• 1、被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
• 2、被重载的方法可以改变返回类型；
• 3、被重载的方法可以改变访问修饰符；
• 4、方法能够在同一个类中或者在一个子类中被重载。
• 5、无法以返回值类型作为重载函数的区分标准
  总结
  方法的重载和重写是Java多态性的不同表现。重载为编译期多态，在调用时可以有多种实现方式，重载在编译时就可以通过方法实参列表来确定方法的实现的状态。而重写是运行时多态，它一定是有继承关系的。

2、ArrayList和LinkedList的区别

1、数据结构不同
ArrayList是基于动态数组实现的，而LinkedList是基于双向链表实现的。
2、效率不同
在随机访问时即get和set操作，ArrayList的效率更高，因为它可以通过下标直接获取，而LinkedList采取线性存储，需要移动指针从前往后查找。
而在修改即add和remove操作时，LinkedList的效率更高，因为ArrayList在删除时会影响下标，需要进行数据移动。而LinkedList只需要修改一个结点。
3、扩容
ArrayList在进行插入等操作时，判断大小不够，会进行扩容，再将原来数组的内容复制到新数组。扩容后大小 = 原大小+原大小/2+1（这是jdk1.6源码，在jdk1.7时修改为扩容后大小 = 原大小+原大小/2）
4、主要控件开销不同
ArrayList主要控件开销在于需要在lList列表预留一定空间；而LinkList主要控件开销在于需要存储结点信息以及结点指针信息。
总结来说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

3 Static关键字的使用

首先，static关键字的基本作用，用一句话来描述就是：方便在没有创建对象的情况下来进行调用方法或变量。 static可以用来修饰类得成员方法、成员变量，以及代码块。
类的初始化顺序（这里可能笔试考的多）：静态变量→静态块→实例变量→实例块→构造函数。

3.1 static用途

3.1.1 修饰变量

static变量也称作静态变量，静态变量和非静态变量的区别是：

• 1 、存储位置不同，实例变量存放在Java堆上，静态变量在方法区中
• 2、实例变量跟对象个数一一对象，它有多个副本，各个对象的副本互不影响。静态变量只跟类有关，一个类只有一份静态变量，在内存中只有一个副本。
• 3、他们的初始化顺序不同

3.1.2 修饰方法

static方法一般称为静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象。
静态方法和实例方法的区别：

• 1、在调用方式上：静态方法依赖于类，通过类 · 静态方法调用；实例方法依赖于类的对象，需要创建对象后，对象 · 实例方法使用。
• 2、使用上：实例方法内部不能定义静态变量，会编译出错；实例方法可以直接调用静态方法；静态方法无法直接调用实例方法（因为此时类还没有实例化）
• 3、内存分配：大家都以为“ 静态方法常驻内存，实例方法不是，所以静态方法效率高但占内存。”事实上，他们都是一样的，在加载时机和占用内存上，静态方法和实例方法是一样的，在类型第一次被使用时加载。调用的速度基本上没有差别。

3.1.3 修饰内部类

静态内部类通常称为嵌套类，它可以不依赖于外部类实例被实例化，与外围对象没有联系。而一般的内部类需要在外部类实例化后才能实例化。
内部类依靠外部类的存在为前提，而静态嵌套类则可以完全独立。

3.2 单例模式

所谓单例，就是整个程序有且仅有一个实例。该类负责创建自己的对象，同时确保只有一个对象被创建。在Java，一般常用在工具类的实现或创建对象需要消耗资源。
懒汉式
线程不安全，延迟初始化，严格意义上不是不是单例模式

public class Singleton {
    private static Singleton instance;
    private Singleton(){}
    
    public static Singleton getInstance(){
        if (instance == null){
            instance = new Singleton();
        }
        
        return instance;
    }
}

饿汉模式
线程安全，比较常用，但容易产生垃圾，因为一开始就初始化

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

双重锁模式
线程安全，延迟初始化。这种方式采用双锁机制，安全且在多线程情况下能保持高性能。

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}

双重检查模式，进行了两次的判断，第一次是为了避免不要的实例，第二次是为了进行同步，避免多线程问题。由于singleton=new Singleton()对象的创建在JVM中可能会进行重排序，在多线程访问下存在风险，使用volatile修饰signleton实例变量有效，解决该问题。
静态内部类单例模式

public class Singleton { 
    private Singleton(){
    }
      public static Singleton getInstance(){  
        return Inner.instance;  
    }  
    private static class Inner {  
        private static final Singleton instance = new Singleton();  
    }  
} 

3.3 类加载过程

类加载过程

4 String类（基于jdk1.8）

4.1 实现以及相关方法

String字符串对象本质是一个final修饰的字符数组对象。因为被final修饰，所以字符串是常量，它们的值一旦被创建后不能改变。同样String类也不能被继承。

常用方法
使用字符数组创建String对象

 public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }

获取指定下标位置的元素

 public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }

获取字符串长度

 public int length() {
        return value.length;
    }

转化为字节数组

public byte[] getBytes(String charsetName)
            throws UnsupportedEncodingException {
        if (charsetName == null) throw new NullPointerException();
        return StringCoding.encode(charsetName, value, 0, value.length);
    }

4.2 字符串拼接

”hello“ + ”world“ 和 s + ”world“的区别

+运算符如果一边是变量的话就会 先查找常量池中有没有拼接完的 如果有常量池就不会在新建 否则会新建一个常量 最后会在堆中创建一个新的String对象。也就是说s+”world“在拼接时原来的s对象并没有改变，只是s在拼接完成后会指向新创建的String对象引用。

如果二端都是常量 先查找常量池中有没有拼接完的 如果有常量池就不会在新建 否则会新建一个常量 但不会在堆中创建新的对象

4.3 字符串比较 “==”和“equals”

什么是==？
== 等于比较运算符,如果进行比较的两个操作数都是数值类型,即使他们的数据类型不相同,只要他们的值相等,也都将返回true.如果两个操作数都是引用类型,那么只有当两个引用变量的类型具有父子关系时才可以比较,而且这两个引用必须指向同一个对象,才会返回true.(在这里我们可以理解成 ==比较的是两个变量的内存地址)

什么是equals？
equals()方法是Object类的方法,在Object类中的equals()方法体内实际上返回的就是使用==进行比较的结果.但是我们知道所有的类都继承Object,而且Object中的equals()方法没有使用final关键字修饰,那么当我们使用equal()方法进行比较的时候,我们需要关注的就是这个类有没有重写Object中的equals()方法.

区别
== 是java提供的等于比较运算符,用来比较两个变量指向的内存地址是否相同.而equals()是Object提供的一个方法.Object中equals()方法的默认实现就是返回两个对象==的比较结果.但是equals()可以被重写,所以我们在具体使用的时候需要关注equals()方法有没有被重写.
Object中的equals

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

String中的equals

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类是重写了equals的方法的

4.4 string、stringbuffer、stringbuilder的区别

首先，三者的共同之处：都是final类,不允许被继承，主要是从性能和安全性上考虑的，因为这几个类都是经常被使用着，且考虑到防止其中的参数被参数修改影响到其他的应用。其次区别在于

• 在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的
• StringBuffer与StringBuilder两者共同之处:可以通过append、indert进行字符串的操作。
• 运行速度快慢为：StringBuilder > StringBuffer > String

总的来说：
　　String：适用于少量的字符串操作的情况
　　StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
　　StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况