Java核心概念详解-优快云博客

内容来源：https://github.com/Snailclimb/JavaGuide

一、重载与重写的区别

1、重载

发生在同一个类中，方法名相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
在这里插入图片描述

2、重写@Override

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

二、String和StringBuffer、StringBuilder的区别是什么，String为什么是不可变的

1、可变性

简单来说:String类中使用final关键字字符数组保存字符串,private final char value[] ，所以String对象是不可变的,而StringBuilder与StringBuffer都继承自AbstractStringBuilder类,在AbstractStringBuilder中也是使用字符数组保存字符串 char[]value 但是没有用 final 关键字修饰，所以这两种对象都是可变的。

StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，大家可以自行查阅源码。

AbstractStringBuilder.java

abstract class AbstractStringBuilder implements Appendable, CharSequence { 
	char[] value; 
	int count;
	AbstractStringBuilder() {
	}
	AbstractStringBuilder(int capacity) { 
	value = new char[capacity]; 
    }
}

2、线程安全性

String 中的对象是不可变的，也就可以理解为常量，线程安全。

AbstractStringBuilder 是 StringBuilder 与StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。

StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。

StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。

3、性能

每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。

StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

4、总结

操作少量的数据 = String
单线程操作字符串缓冲区下操作大量数据 = StringBuilder
多线程操作字符串缓冲区下操作大量数据 = StringBuffer

三、自动装箱与拆箱

1、基本类型及包装类型

基本类型：byte，short， int， long， float， double，char，boolean
包装类型：Byte，Short，Integer，Long，Float，Double，Character，Boolean

1、装箱

将基本类型用他们对应的引用类型包装起来

2、拆箱

将包装类型转换为基本数据类型

四、==与equals

1、==

它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。
(基本数据类型 == 比较的是值
引用数据类型 == 比较的是内存地址)

2、equals()

它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
情况1：类没有覆盖 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
情况2：类覆盖了 equals() 方法。一般，我们都覆盖 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。
举个栗子：

public class EqualsDemo {
    public static void main(String[] args) {
        String a = new String("ab");//a作为一个引用
        String b = new String("ab");//b为另一个引用,对象的内容一样
        String aa = "ab";//放在常量池中
        String bb = "ab";//从常量池中查找
        if (aa ==bb){//true
            System.out.println("aa==bb");
        }
        if (a==b){//false,不是同一个对象
            System.out.println(a=b);
        }
        if (a.equals(b)){//true
            System.out.println("aEQb");
        }
        if (42==42.0){//true
            System.out.println("42==42.0");
        }
    }
}

说明

String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是比较的对象的内存地址，而 String 的equals 方法比较的是对象的值。
当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象。

五、final关键字的一些总结

final关键字主要用在三个地方：变量、方法、类。

1、 final变量

基本数据类型的变量：其数值一旦在初始化之后便不能更改；
引用类型的变量：在对其初始化之后便不能再让其指向另一个对象。

2、 final修饰类

表明这个类不能被继承。final类中的所有成员方法都会被隐式地指定为final方法。

3、 final方法的原因有两个

第一个原因是把方法锁定，以防任何继承类修改它的含义；
第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的Java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都隐式地指定为fianl。

六、object类的常见方法总结

Object类是一个特殊的类，是所有类的父类。它主要提供了以下11个方法：

public final native Class<?> getClass()
native方法，用于返回当前运行时对象的Class对象，使用了 final关键字修饰，故不允许子类重写。

public native int hashCode()
native方法，用于返回对象的哈希码，主要使用在哈希表中，比如JDK中的 HashMap。

public boolean equals(Object obj)
用于比较2个对象的内存地址是否相等，String类对该方法进行了重写用于比较字符串的值是否相等。

protected native Object clone() throws CloneNotSupportedException
naitive方法，用于创建并返回当前对象的一份拷贝。一般情况下，对于任何对象 x，表达式 x.clone() != x 为true，x.clone().getClass() == x.getClass() 为true。Object本身没有实现Cloneable接口，所以不重写clone方法并且进行调用的话会发生 CloneNotSupportedException异常。

public String toString()
返回类的名字@实例的哈希码的16进制的字符串。建议Object所有的子类都重写这个方法。

public final native void notify()
native方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。

public final native void notifyAll()
native方法，并且不能重写。跟notify一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。

public final native void wait(long timeout) throws InterruptedException
native方法，并且不能重写。暂停线程的执行。注意：sleep方法没有释放锁，而wait方法释放了锁。timeout是等待时间。

public final void wait(long timeout, int nanos) throws InterruptedException
多了nanos参数，这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）。所以超时的时间还需要加上nanos毫秒。

public final void wait() throws InterruptedException
跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念

protected void finalize() throws Throwable { }
实例被垃圾回收器回收的时候触发的操作

七、java异常处理

在这里插入图片描述
在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 Throwable类。
Throwable有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。

1、Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。

例如，Java虚拟机运行错误（Virtual MachineError），当JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。
这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual
MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。

2、Exception（异常）:是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。

RuntimeException 异常由Java虚拟机抛出。
NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）、
ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）和
ArrayIndexOutOfBoundsException （下标越界异常）。
注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

3、Throwable类常用方法

public string getMessage():返回异常发生时的详细信息
public string toString():返回异常发生时的简要描述
public string getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
public void printStackTrace():在控制台上打印Throwable对象封装的异常信息

4、异常处理总结

try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句
时，finally语句块将在方法返回之前被执行。

在以下4种特殊情况下，finally块不会被执行：

在finally语句块中发生了异常。
在前面的代码中用了System.exit()退出程序。
程序所在的线程死亡。
关闭CPU。

八、获取键盘输入常用的两种方法

方法1：通过 Scanner

Scanner input = new Scanner(System.in); 
String s = input.nextLine();
 input.close();

方法2：通过 BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
String s = input.readLine();

九、接口和抽象类的区别

1、接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），抽象类可以有非抽象的方法

2、接口中的实例变量默认是 final 类型的，而抽象类中则不一定

3、一个类可以实现多个接口，但最多只能实现一个抽象类

4、一个类实现接口的话要实现接口的所有方法，而抽象类不一定

5、接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

备注:在JDK8中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，必须重写，不然会报错。(详见issue:https://github.com/Snailclimb/JavaGuide/issues/146)