【java基础】java基础整理

1.Java语言特性

1.1.运行

Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。

Java 编写的程序需要先经过编译步骤，生成字节码（.class 文件），这种字节码必须由 Java 解释器来解释执行。

1.2.JDK 和 JRE

JDK 是 Java Development Kit 缩写，它是功能齐全的 Java SDK。它拥有 JRE 所拥有的一切，还有编译器（javac）和工具（如 javadoc 和 jdb）。它能够创建和编译程序。（用来开发）

JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有内容的集合，包括 Java 虚拟机（JVM），Java 类库，java 命令和其他的一些基础构件。但是，它不能用于创建新程序。（用来运行）

1.3.Java 和 C++ 的区别?

虽然，Java 和 C++ 都是面向对象的语言，都支持封装、继承和多态，但是，它们还是有挺多不相同的地方：

Java 不提供指针来直接访问内存，程序内存更加安全
Java 的类是单继承的，C++ 支持多重继承；虽然 Java 的类不可以多继承，但是接口可以多继承。
Java 有自动内存管理垃圾回收机制(GC)，不需要程序员手动释放无用内存。
C ++同时支持方法重载和操作符重载，但是 Java 只支持方法重载（操作符重载增加了复杂性，这与 Java 最初的设计思想不符）。

2.基本语法

2.1.标识符和关键字的区别是什么？

标识符就是一个名字（程序、类、变量、方法） 。
关键字是被赋予特殊含义的标识符 。

2.2.return

return 用于跳出所在方法，结束该方法的运行。return 一般有两种用法：

• return; ：直接使用 return 结束方法执行，用于没有返回值函数的方法
• return value; ：return 一个特定值，用于有返回值函数的方法

2.3.静态方法

2.3.1静态方法为什么不能调用非静态成员?

• 静态方法是属于类的，在类加载的时候就会分配内存，可以通过类名直接访问（优先于对象非静态成员存在）。
• 非静态成员属于实例对象，只有在对象实例化之后才存在，需要通过类的实例对象去访问。
  在类的非静态成员不存在的时候静态成员就已经存在了，此时调用在内存中还不存在的非静态成员，属于非法操作。

2.3.2静态方法和实例方法有何不同？

• 调用方式
  在外部调用静态方法时，可以使用 类名.方法名 的方式，也可以使用 对象.方法名 的方式，而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象 。

• 调用范围
  静态方法只能访问静态成员，实例方法可以访问静态和实例成员。静态方法不能访问实例成员是因为实例成员变量是属于某个对象。
  静态方法不能使用关键字this。
  main()方法是一个典型的静态方法。

2.4.方法重载和重写

重载就是同样的一个方法能够根据不同的传参，做出不同的处理；
重写就是当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法。

• 重载
  发生在同一个类中（或者父类和子类之间），方法名必须相同；
  参数类型、个数、顺序、方法、返回值和访问修饰符可能不同。

• 重写
  重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。
  方法名、参数列表必须相同（两同）；
  子类方法返回值类型应比父类方法返回值类型更小或相等，抛出的异常范围小于等于父类（两小），访问修饰符范围大于等于父类（一大）。
  如果父类方法访问修饰符为 private/final/static 则子类就不能重写该方法，但是被 static 修饰的方法能够被再次声明。
  构造方法无法被重写。
  综上：重写就是子类对父类方法的重新改造，外部样子不能改变，内部逻辑可以改变。重写要遵循“两同两小一大”。

2.5.基本数据类型

6 种数字类型，1 种字符类型，1 种布尔型；
对应位，字节

• 基本类型和包装类型的区别
  包装类型不赋值就是 null ，而基本类型有默认值且不是 null。
  包装类型可用于泛型，而基本类型不可以。
  基本数据类型的局部变量在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被 static 修饰 ）存放在 Java 虚拟机的堆中。包装类型属于对象类型，几乎所有对象实例都存在于堆中。
  相比于对象类型， 基本数据类型占用的空间非常小

2.6.成员变量与局部变量的区别有哪些？

• 语法形式：从语法形式上看，成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
• 存储方式 ：从变量在内存中的存储方式来看,如果成员变量是使用 static 修饰的，那么这个成员变量是属于类的，如果没有使用 static 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
• 生存时间 ：从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡。
• 默认值 ：从变量是否有默认值来看，成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

2.7.构造方法

2.7.1如果一个类没有声明构造方法，该程序能正确执行吗?

如果一个类没有声明构造方法，也可以执行！因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法（无论是否有参），Java 就不会再添加默认的无参数的构造方法了，这时候，就不能直接 new 一个对象而不传递参数了，所以我们一直在不知不觉地使用构造方法，这也是为什么我们在创建对象的时候后面要加一个括号（因为要调用无参的构造方法）。
如果我们重载了有参的构造方法，记得都要把无参的构造方法也写出来（无论是否用到），因为这可以帮助我们在创建对象的时候少踩坑。

2.7.2构造方法有哪些特点？是否可被 override?

名字与类名相同。
没有返回值，但不能用 void 声明构造函数。
生成类的对象时自动执行，无需调用。
构造方法不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况。

2.8.面向对象三大特征

2.8.1封装

封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。

2.8.2继承

通过使用继承，可以快速地创建新的类，可以提高代码的重用，程序的可维护性，节省大量创建新类的时间 ，提高我们的开发效率。

子类只能继承父类对象非私有成员（成员变量、成员方法）
子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

2.8.3多态

多态，顾名思义，表示一个对象具有多种的状态，具体表现为父类的引用指向子类的实例。

• 实现多态的步骤
  要有继承（或实现）关系
  要有方法重写（重写父类的某些方法）
  父类引用指向子类对象（is a关系）
• 成员变量遵循编译看左，运行看右
• 子类父类的转换（继承层次内，向下转型需要instance of判断）

2.8.接口和抽象类有什么共同点和区别？

接口interface可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，即接口中的方法必须全部是抽象方法。另外接口可解耦，解耦的方式是让设计依赖于抽象，而不是依赖于实现（设计模式的原则）。

抽象类用来描述一种类型应该具备的基本特征与功能， 具体如何去完成这些行为由子类通过方法重写来完成。抽象类无法直接创建对象，只能被子类继承后，创建子类对象。子类需要继承抽象父类并完成最终的方法实现细节(即重写方法，完成方法体)。而此时，方法重写不再是加强父类方法功能，而是父类没有具体实现，子类完成了具体实现，我们将这种方法重写也叫做实现方法。

• 共同点 ：
  都不能被实例化。
  都可以包含抽象方法。
  都可以有默认实现的方法（Java 8 可以用 default 关键在接口中定义默认方法）。
• 区别 ：
  接口主要用于对类的行为进行约束，你实现了某个接口就具有了对应的行为。抽象类主要用于代码复用，强调的是所属关系（即抽象方法指只有功能声明，没有功能主体实现的方法。具有抽象方法的类一定为抽象类）。
  一个类只能继承一个类，但是可以实现多个接口。
  接口中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义，也可被重新赋值。

2.9.Java 常见对象

2.9.1.Object

Object 类是一个特殊的类，是所有类的父类。Object 类的11个方法。

/**
 * native 方法，用于返回当前运行时对象的 Class 对象，使用了 final 关键字修饰，故不允许子类重写。
 */
public final native Class<?> getClass()
/**
 * native 方法，用于返回对象的哈希码，主要使用在哈希表中，比如 JDK 中的HashMap。
 */
public native int hashCode()
/**
 * 用于比较 2 个对象的内存地址是否相等，String 类对该方法进行了重写以用于比较字符串的值是否相等。
 */
public boolean equals(Object obj)
/**
 * naitive 方法，用于创建并返回当前对象的一份拷贝。
 */
protected native Object clone() throws CloneNotSupportedException
/**
 * 返回类的名字实例的哈希码的 16 进制的字符串。建议 Object 所有的子类都重写这个方法。
 */
public String toString()
/**
 * native 方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。
 */
public final native void notify()
/**
 * native 方法，并且不能重写。跟 notify 一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。
 */
public final native void notifyAll()
/**
 * native方法，并且不能重写。暂停线程的执行。注意：sleep 方法没有释放锁，而 wait 方法释放了锁 ，timeout 是等待时间。
 */
public final native void wait(long timeout) throws InterruptedException
/**
 * 多了 nanos 参数，这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 毫秒。。
 */
public final void wait(long timeout, int nanos) throws InterruptedException
/**
 * 跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念
 */
public final void wait() throws InterruptedException
/**
 * 实例被垃圾回收器回收的时候触发的操作
 */
protected void finalize() throws Throwable { }

2.9.2. == 和 equals() 的区别

== 对于基本类型和引用类型的作用效果是不同的：
对于基本数据类型来说，== 比较的是值。
对于引用数据类型来说，== 比较的是对象的内存地址。
因为 Java 只有值传递，所以，对于 == 来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。

equals() 不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。equals()方法存在于Object类中，而Object类是所有类的直接或间接父类，因此所有的类都有equals()方法。

String a = new String("ab"); // a 为一个引用
String b = new String("ab"); // b为另一个引用,对象的内容一样
String aa = "ab"; // 放在常量池中
String bb = "ab"; // 从常量池中查找
System.out.println(aa == bb);// true
System.out.println(a == b);// false
System.out.println(a.equals(b));// true
System.out.println(42 == 42.0);// true

2.9.3. hashCode() 有什么用？

hashCode() 的作用是获取哈希码（int 整数），也称为散列码。这个哈希码的作用是确定该对象在哈希表中的索引位置。

hashCode()定义在 JDK 的 Object 类中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。另外需要注意的是： Object 的 hashCode() 方法是本地方法，也就是用 C 语言或 C++ 实现的，该方法通常用来将对象的内存地址转换为整数之后返回。

散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

• 为什么要有 hashCode？
  我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode？
  当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashCode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashCode 值作比较，如果没有相符的 hashCode，HashSet 会假设对象没有重复出现。但是如果发现有相同 hashCode 值的对象，这时会调用 equals() 方法来检查 hashCode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
  其实， hashCode() 和 equals()都是用于比较两个对象是否相等。
• 那为什么 JDK 还要同时提供这两个方法呢？
  这是因为在一些容器（比如 HashMap、HashSet）中，有了 hashCode() 之后，判断元素是否在对应容器中的效率会更高（参考添加元素进HashSet的过程）！
  我们在前面也提到了添加元素进HashSet的过程，如果 HashSet 在对比的时候，同样的 hashCode 有多个对象，它会继续使用 equals() 来判断是否真的相同。也就是说 hashCode 帮助我们大大缩小了查找成本。
• 那为什么不只提供 hashCode() 方法呢？
  这是因为两个对象的hashCode 值相等并不代表两个对象就相等。
• 那为什么两个对象有相同的 hashCode 值，它们也不一定是相等的？
  因为 hashCode() 所使用的哈希算法也许刚好会让多个对象传回相同的哈希值。越糟糕的哈希算法越容易碰撞，但这也与数据值域分布的特性有关（所谓哈希碰撞也就是指的是不同的对象得到相同的 hashCode )。
• 总结 ：
  如果两个对象的hashCode 值相等，那这两个对象不一定相等（哈希碰撞）。
  如果两个对象的hashCode 值相等并且equals()方法也返回 true，我们才认为这两个对象相等。
  如果两个对象的hashCode 值不相等，我们就可以直接认为这两个对象不相等。

重写 hashCode() 方法

• 为什么重写 equals() 时必须重写 hashCode() 方法？
  因为两个相等的对象的 hashCode 值必须是相等。也就是说如果 equals 方法判断两个对象是相等的，那这两个对象的 hashCode 值也要相等。
  如果重写 equals() 时没有重写 hashCode() 方法的话就可能会导致 equals 方法判断是相等的两个对象，hashCode 值却不相等。
• 总结 ：
  equals 方法判断两个对象是相等的，那这两个对象的 hashCode 值也要相等。
  两个对象有相同的 hashCode 值，他们也不一定是相等的（哈希碰撞）。

2.10.String

2.10.1.String、StringBuffer、StringBuilder 的区别？

• 可变性
  String 是不可变的（后面会详细分析原因）。
  StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串，不过没有使用 final 和 private 关键字修饰，最关键的是这个 AbstractStringBuilder 类还提供了很多修改字符串的方法比如 append 方法。
• 线程安全性
  String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。
• 性能
  每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
• 总结：
  操作少量的数据: 适用 String
  单线程操作字符串缓冲区下操作大量数据: 适用 StringBuilder
  多线程操作字符串缓冲区下操作大量数据: 适用 StringBuffer
• 细节

//如果字符串常量池中已存在字符串常量“abc”，则只会在堆空间创建一个字符串常量“abc”。
//如果字符串常量池中没有字符串常量“abc”，那么它将首先在字符串常量池中创建，然后在堆空间中创建，因此将创建总共 2 个字符串对象。
String s1 = new String("abc");// 堆内存的地址值
String s2 = "abc";
System.out.println(s1 == s2);// 输出 false,因为一个是堆内存，一个是常量池的内存，故两者是不同的。
System.out.println(s1.equals(s2));// 输出 true

//比较 String 字符串的值是否相等，可以使用 equals() 方法。 String 中的 equals 方法是被重写过的。 
//Object 的 equals 方法是比较的对象的内存地址，而 String 的 equals 方法比较的是字符串的值是否相等。
String str1 = "str";
String str2 = "ing";
String str3 = "str" + "ing";//常量池中的对象
String str4 = str1 + str2; //在堆上创建的新的对象
String str5 = "string";//常量池中的对象
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false

2.11.泛型

Java 泛型（generics） 是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

Java 的泛型是伪泛型，这是因为 Java 在运行期间，所有的泛型信息都会被擦掉，这也就是通常所说类型擦除 。
泛型一般有三种使用方式: 泛型类、泛型接口、泛型方法。
**场景：**可用于定义通用返回结果 CommonResult 通过参数 T 可根据具体的返回类型动态指定结果的数据类型

2.12.反射

反射之所以被称为框架的灵魂，主要是因为它赋予了我们在运行时分析类以及执行类中方法的能力。
通过反射你可以获取任意一个类的所有属性和方法，你还可以调用这些方法和属性。

2.13.注解

Annotation （注解） 是Java5 开始引入的新特性，可以看作是一种特殊的注释，主要用于修饰类、方法或者变量。
注解本质是一个继承了Annotation 的特殊接口

2.13.异常

在 Java 中，所有的异常都有一个共同的祖先 java.lang 包中的 Throwable 类。Throwable 类有两个重要的子类：Exception :程序本身可以处理的异常；Error ：Error 属于程序无法处理的错误 ；

Java----异常类（错误和异常，两者区别）

Java中的异常分为两大类：
　　1.Checked Exception（非Runtime Exception）
　　2.Unchecked Exception（Runtime Exception）

RuntimeException类是Exception类的子类，它叫做运行时异常，Java中的所有运行时异常都会直接或者间接地继承自RuntimeException类。
Java中凡是继承自Exception，而不继承自RuntimeException类的异常都是非运行时异常。一个try后面可以跟多个catch，但不管多少个，最多只会有一个catch块被执行。对于非运行时异常（checked exception），必须要对其进行处理，否则无法通过编译。处理方式有两种：
　　1.使用try…catch…finally进行捕获；
　　2.在产生异常的方法声明后面写上throws 某一个Exception类型，如throws Exception，将异常抛出到外面一层去。
对于运行时异常（runtime exception），可以对其进行处理，也可以不处理。推荐不对运行时异常进行处理。

扩展：错误和异常的区别(Error vs Exception)
1).java.lang.Error: Throwable的子类，用于标记严重错误。合理的应用程序不应该去try/catch这种错误。绝大多数的错误都是非正常的，就根本不该出现的。
java.lang.Exception: Throwable的子类，用于指示一种合理的程序想去catch的条件。即它仅仅是一种程序运行条件，而非严重错误，并且鼓励用户程序去catch它。
2).Error和RuntimeException 及其子类都是未检查的异常（unchecked exceptions），而所有其他的Exception类都是检查了的异常（checked exceptions）.

2.14.I/O

持久化 Java 对象保存在文件中，或者在网络传输 Java 对象，这些场景都需要用到序列化。

序列化，反序列化
transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。

• 分类：
  按照流的流向分，可以分为输入流和输出流；
  按照操作单元划分，可以划分为字节流和字符流；
  InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
  OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
• 既然有了字节流,为什么还要有字符流?
  问题本质想问：不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？
  **回答：**字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。

2.15.几个问题

• Java 中将实参传递给方法（或函数）的方式是 值传递 ：
  如果参数是基本类型的话，很简单，传递的就是基本类型的字面量值的拷贝，会创建副本。
  如果参数是引用类型，传递的就是实参所引用的对象在堆中地址值的拷贝，同样也会创建副本。