乐趣区

关于java:Java基础八股文背诵版

jiezi

背之前先来看看阿里巴巴的常问 Java 根底你们会几个？

Java 语言具备哪些特点？

  1. Java 为纯面向对象的语言。它可能间接反馈现实生活中的对象。
  2. 具备平台无关性。java 利用 Java 虚拟机运行字节码，无论是在 Windows、Linux 还是 MacOS 等其它平台对 Java 程序进行编译，编译后的程序可在其它平台运行。
  3. Java 为解释型语言，编译器把 Java 代码编译成平台无关的中间代码，而后在 JVM 上解释运行，具备很好的可移植性。
  4. Java 提供了很多内置类库。如对多线程反对，对网络通信反对，最重要的一点是提供了垃圾回收器。
  5. Java 具备较好的安全性和健壮性。Java 提供了异样解决和垃圾回收机制，去除了 C ++ 中难以了解的指针个性。
  6. Java 语言提供了对 Web 利用开发的反对。

面向对象的三大个性？

  1. 继承：对象的一个新类能够从现有的类中派生，派生类能够从它的基类那继承办法和实例变量，且派生类能够批改或新增新的办法使之更适宜非凡的需要。
  2. 封装：将客观事物形象成类，每个类能够把本身数据和办法只让可信的类或对象操作，对不可信的进行信息暗藏。
  3. 多态：容许不同类的对象对同一音讯作出响应。不同对象调用雷同办法即便参数也雷同，最终体现行为是不一样的。

字节序定义以及 Java 属于哪种字节序？

字节序是指多字节数据在计算机内存中存储或网络传输时个字节的存储程序。通常由小端和大端两组形式。

  1. 小端: 低位字节寄存在内存的低地址端，高位字节寄存在内存的高地址端。
  2. 大端：高位字节寄存在内存的低地址端，低位字节寄存在内存的高地址端。

Java 语言的字节序是大端。

JDK 与 JRE 有什么区别？

  1. JDK：Java 开发工具包（Java Development Kit），提供了 Java 的开发环境和运行环境。
  2. JRE：Java 运行环境 (Java Runtime Environment)，提供了 Java 运行所需的环境。

JDK 蕴含了 JRE。如果只运行 Java 程序，装置 JRE 即可。要编写 Java 程序需装置 JDK.

简述 Java 拜访修饰符

  • default: 默认拜访修饰符，在同一包内可见
  • private: 在同一类内可见，不能润饰类
  • protected : 对同一包内的类和所有子类可见，不能润饰类
  • public: 对所有类可见

构造方法、成员变量初始化以及动态成员变量三者的初始化程序？

先后顺序：动态成员变量、成员变量、构造方法。
具体的先后顺序：父类动态变量、父类动态代码块、子类动态变量、子类动态代码块、父类非动态变量、父类非动态代码块、父类构造函数、子类非动态变量、子类非动态代码块、子类构造函数。

接口和抽象类的相同点和区别？

相同点:

  1. 都不能被实例化。
  2. 接口的实现类或抽象类的子类需实现接口或抽象类中相应的办法能力被实例化。

不同点：

  1. 接口只能有办法定义，不能有办法的实现，而抽象类能够有办法的定义与实现。
  2. 实现接口的关键字为 implements, 继承抽象类的关键字为 extends。一个类能够实现多个接口，只能继承一个抽象类。
  3. 当子类和父类之间存在逻辑上的层次结构，举荐应用抽象类，有利于性能的累积。当性能不须要，心愿反对差异较大的两个或更多对象间的特定交互行为，举荐应用接口。应用接口能升高软件系统的耦合度，便于日后保护或增加删除办法。

为什么 Java 语言不反对多重继承？

  1. 为了程序的构造可能更加清晰从而便于保护。假如 Java 语言反对多重继承，类 C 继承自类 A 和类 B, 如果类 A 和 B 都有自定义的成员办法 f(), 那么当代码中调用类 C 的 f() 会产生二义性。Java 语言通过实现多个接口间接反对多重继承，接口因为只蕴含办法定义，不能有办法的实现，类 C 继承接口 A 与接口 B 时即便它们都有办法 f(), 也不能间接调用办法，需实现具体的 f() 办法能力调用，不会产生二义性。
  2. 多重继承会使类型转换、构造方法的调用程序变得复杂，会影响到性能。

Java 提供的多态机制？

Java 提供了两种用于多态的机制，别离是重载与笼罩。

  1. 重载：重载是指同一个类中有多个同名的办法，但这些办法有不同的参数，在编译期间就能够确定调用哪个办法。
  2. 笼罩：笼罩是指派生类重写基类的办法，应用基类指向其子类的实例对象，或接口的援用变量指向其实现类的实例对象，在程序调用的运行期依据援用变量所指的具体实例对象调用正在运行的那个对象的办法，即须要到运行期能力确定调用哪个办法。

重载与笼罩的区别？

  1. 笼罩是父类与子类之间的关系，是垂直关系；重载是同一类中办法之间的关系，是程度关系。
  2. 笼罩只能由一个办法或一对办法产生关系；重载是多个办法之间的关系。
  3. 笼罩要求参数列表雷同；重载要求参数列表不同。
  4. 笼罩中，调用办法体是依据对象的类型来决定的，而重载是依据调用时实参表与形参表来对应抉择办法体。
  5. 重载办法能够扭转返回值的类型，笼罩办法不能扭转返回值的类型。

final、finally 和 finalize 的区别是什么？

  1. final 用于申明属性、办法和类，别离示意属性不可变、办法不可笼罩、类不可继承。
  2. finally 作为异样解决的一部分，只能在 try/catch 语句中应用，finally 附带一个语句块用来示意这个语句最终肯定被执行，常常被用在须要开释资源的状况下。
  3. finalize 是 Object 类的一个办法，在垃圾收集器执行的时候会调用被回收对象的 finalize() 办法。当垃圾回收器筹备好开释对象占用空间时，首先会调用 finalize() 办法，并在下一次垃圾回收动作产生时真正回收对象占用的内存。

呈现在 Java 程序中的 finally 代码块是否肯定会执行？

当遇到上面状况不会执行。

  1. 当程序在进入 try 语句块之前就出现异常时会间接完结。
  2. 当程序在 try 块中强制退出时，如应用 System.exit(0)，也不会执行 finally 块中的代码。

其它状况下，在 try/catch/finally 语句执行的时候，try 块先执行，当有异样产生，catch 和 finally 进行解决后程序就完结了，当没有异样产生，在执行完 finally 中的代码后，前面代码会继续执行。值得注意的是，当 try/catch 语句块中有 return 时，finally 语句块中的代码会在 return 之前执行。如果 try/catch/finally 块中都有 return 语句，finally 块中的 return 语句会笼罩 try/catch 模块中的 return 语句。

Java 语言中关键字 static 的作用是什么？

static 的次要作用有两个：

  1. 为某种特定数据类型或对象调配与创建对象个数无关的繁多的存储空间。
  2. 使得某个办法或属性与类而不是对象关联在一起，即在不创建对象的状况下可通过类间接调用办法或应用类的属性。

具体而言 static 又可分为 4 种应用形式：

  1. 润饰成员变量。用 static 关键字润饰的动态变量在内存中只有一个正本。只有动态变量所在的类被加载，这个动态变量就会被调配空间，能够应用 ” 类. 动态变量 ” 和 ” 对象. 动态变量 ” 的办法应用。
  2. 润饰成员办法。static 润饰的办法无需创建对象就能够被调用。static 办法中不能应用 this 和 super 关键字，不能调用非 static 办法，只能拜访所属类的动态成员变量和动态成员办法。
  3. 润饰代码块。JVM 在加载类的时候会执行 static 代码块。static 代码块罕用于初始化动态变量。static 代码块只会被执行一次。
  4. 润饰外部类。static 外部类能够不依赖外部类实例对象而被实例化。动态外部类不能与外部类有雷同的名字，不能拜访一般成员变量，只能拜访外部类中的动态成员和动态成员办法。

Java 代码块执行程序

  1. 父类动态代码块（只执行一次）
  2. 子类动态代码块（只执行一次）
  3. 父类结构代码块
  4. 父类构造函数
  5. 子类结构代码块
  6. 子类构造函数
  7. 一般代码块

Java 中一维数组和二维数组的申明形式？

一维数组的申明形式：

  1. type arrayName[]
  2. type[] arrayName

二维数组的申明形式：

  1. type arrayName[][]
  2. type[][] arrayName
  3. type[] arrayName[]

其中 type 为根本数据类型或类，arrayName 为数组名字

String 和 StringBuffer 有什么区别？

String 用于字符串操作，属于不可变类。String 对象一旦被创立，其值将不能被扭转。而 StringBuffer 是可变类，当对象创立后，依然能够对其值进行批改。

判等运算符 == 与 equals 的区别？

== 比拟的是援用，equals 比拟的是内容。

  1. 如果变量是根底数据类型，== 用于比拟其对应值是否相等。如果变量指向的是对象,== 用于比拟两个对象是否指向同一块存储空间。

  2. equals 是 Object 类提供的办法之一，每个 Java 类都继承自 Object 类，所以每个对象都具备 equals 这个办法。Object 类中定义的 equals 办法外部是间接调用 == 比拟对象的。但通过笼罩的办法能够让它不是比拟援用而是比拟数据内容。

    为什么要把 String 设计为不变量？

  3. 节俭空间：字符串常量存储在 JVM 的字符串池中能够被用户共享。
  4. 提高效率:String 会被不同线程共享，是线程平安的。在波及多线程操作中不须要同步操作。

  5. 平安：String 常被用于用户名、明码、文件名等应用，因为其不可变，可防止黑客行为对其歹意批改。

    序列化是什么？

    序列化是一种将对象转换成字节序列的过程，用于解决在对对象流进行读写操作时所引发的问题。序列化能够将对象的状态写在流里进行网络传输，或者保留到文件、数据库等零碎里，并在须要的时候把该流读取进去从新结构成一个雷同的对象。

简述 Java 中 Class 对象

java 中对象能够分为实例对象和 Class 对象，每一个类都有一个 Class 对象，其蕴含了与该类无关的信息。

获取 Class 对象的办法：

  • Class.forName(“类的全限定名”)
  • 实例对象.getClass()
  • 类名.class

Java 反射机制是什么？

Java 反射机制是指在程序的运行过程中能够结构任意一个类的对象、获取任意一个类的成员变量和成员办法、获取任意一个对象所属的类信息、调用任意一个对象的属性和办法。反射机制使得 Java 具备动静获取程序信息和动静调用对象办法的能力。能够通过以下类调用反射 API。

  • Class 类：可取得类属性办法
  • Field 类：取得类的成员变量
  • Method 类：获取类的办法信息
  • Construct 类：获取类的构造方法等信息

简述注解

Java 注解用于为 Java 代码提供元数据。作为元数据，注解不间接影响你的代码执行，但也有一些类型的注解实际上能够用于这一目标。

其能够用于提供信息给编译器，在编译阶段时给软件提供信息进行相干的解决，在运行时解决写相应代码，做对应操作。

简述元注解

元注解能够了解为注解的注解，即在注解中应用，实现想要的性能。其具体分为：

  • @Retention: 示意注解存在阶段是保留在源码，还是在字节码（类加载）或者运行期（JVM 中运行）。
  • @Target：示意注解作用的范畴。
  • @Documented：将注解中的元素蕴含到 Javadoc 中去。
  • @Inherited：一个被 @Inherited 注解了的注解润饰了一个父类，如果他的子类没有被其余注解润饰，则它的子类也继承了父类的注解。
  • @Repeatable：被这个元注解润饰的注解能够同时作用一个对象屡次，然而每次作用注解又能够代表不同的含意。

简述 Java 异样的分类

Java 异样分为 Error（程序无奈解决的谬误），和 Exception（程序自身能够解决的异样）。这两个类均继承 Throwable。

Error 常见的有 StackOverFlowError,OutOfMemoryError 等等。

Exception 可分为运行时异样和非运行时异样。对于运行时异样，能够利用 try catch 的形式进行解决，也能够不解决。对于非运行时异样，必须解决，不解决的话程序无奈通过编译。

简述 throw 与 throws 的区别

throw 个别是用在办法体的外部，由开发者定义当程序语句呈现问题后被动抛出一个异样。

throws 个别用于办法申明上，代表该办法可能会抛出的异样列表。

简述泛型

泛型，即“参数化类型”，解决不确定对象具体类型的问题。在编译阶段无效。在泛型应用过程中，操作的数据类型被指定为一个参数，这种参数类型在类中称为泛型类、接口中称为泛型接口和办法中称为泛型办法。

简述泛型擦除

Java 编译器生成的字节码是不包涵泛型信息的，泛型类型信息将在编译解决是被擦除，这个过程被称为泛型擦除。

简述 Java 根本数据类型

  • byte: 占用 1 个字节，取值范畴 -128 ~ 127
  • short: 占用 2 个字节，取值范畴 -2^15^ ~ 2^15^-1
  • int：占用 4 个字节，取值范畴 -2^31^ ~ 2^31^-1
  • long：占用 8 个字节
  • float：占用 4 个字节
  • double：占用 8 个字节
  • char: 占用 2 个字节

  • boolean：占用大小依据实现虚拟机不同有所差别

    简述主动装箱拆箱

    对于 Java 根本数据类型，均对应一个包装类。

装箱就是主动将根本数据类型转换为包装器类型，如 int->Integer

拆箱就是主动将包装器类型转换为根本数据类型，如 Integer->int

简述重载与重写的区别

重写即子类重写父类的办法，办法对应的形参和返回值类型都不能变。

重载即在一个类中，办法名雷同，参数类型或数量不同。

简述 java 的多态

Java 多态能够分为编译时多态和运行时多态。

编译时多态次要指办法的重载，即通过参数列表的不同来辨别不同的办法。

运行时多态次要指继承父类和实现接口时，可应用父类援用指向子类对象。

运行时多态的实现：次要依附办法表，办法表中最先寄存的是 Object 类的办法，接下来是该类的父类的办法，最初是该类自身的办法。如果子类改写了父类的办法，那么子类和父类的那些同名办法共享一个办法表项，都被认作是父类的办法。因而能够实现运行时多态。

简述抽象类与接口的区别

抽象类：体现的是 is- a 的关系，如对于 man is a person，就能够将 person 定义为抽象类。

接口：体现的是 can 的关系。是作为模板实现的。如设置接口 fly，plane 类和 bird 类均可实现该接口。

一个类只能继承一个抽象类，但能够实现多个接口。

简述 == 与 equals 办法的区别

对于 ==，在根本数据类型比拟时，比拟的是对应的值，对援用数据类型比拟时，比拟的是其内存的寄存地址。

对于 equals 办法，在该办法未被重写时，其成果和 == 统一，但用户能够依据对应需要对判断逻辑进行改写，比方间接比拟对象某个属性值是否雷同，雷同则返回 true，不同则返回 false。需保障 equals 办法雷同对应的对象 hashCode 也雷同。

简述 Object 类罕用办法

  1. hashCode：通过对象计算出的散列码。用于 map 型或 equals 办法。
    须要保障同一个对象屡次调用该办法，总返回雷同的整型值。
  2. equals：判断两个对象是否统一。需保障 equals 办法雷同对应的对象 hashCode 也雷同。
  3. toString: 用字符串示意该对象
  4. clone: 深拷贝一个对象

简述外部类及其作用

  • 成员外部类：作为成员对象的外部类。能够拜访 private 及以上外部类的属性和办法。外部类想要拜访外部类属性或办法时，必须要创立一个外部类对象，而后通过该对象拜访外部类的属性或办法。外部类也可拜访 private 润饰的外部类属性。
  • 部分外部类：存在于办法中的外部类。拜访权限相似局部变量，只能拜访外部类的 final 变量。
  • 匿名外部类：只能应用一次，没有类名，只能拜访外部类的 final 变量。
  • 动态外部类：相似类的动态成员变量。

简述 String/StringBuffer 与 StringBuilder

String 类采纳利用 final 润饰的字符数组进行字符串保留，因而不可变。如果对 String 类型对象批改，须要新建对象，将老字符和新减少的字符一并存进去。

StringBuilder，采纳无 final 润饰的字符数组进行保留，因而可变。但线程不平安。

StringBuffer，采纳无 final 润饰的字符数组进行保留，可了解为实现线程平安的 StringBuilder。

简述 Java 序列化与反序列化的实现

序列化：将 java 对象转化为字节序列，由此能够通过网络对象进行传输。

反序列化：将字节序列转化为 java 对象。

具体实现：实现 Serializable 接口，或实现 Externalizable 接口中的 writeExternal() 与 readExternal() 办法。

简述 JAVA 的 List

List 是一个有序队列，在 JAVA 中有两种实现形式:

ArrayList 应用数组实现，是容量可变的非线程平安列表，随机拜访快，汇合扩容时会创立更大的数组，把原有数组复制到新数组。

LinkedList 实质是双向链表，与 ArrayList 相比插入和删除速度更快，但随机拜访元素很慢。

Java 中线程平安的根本数据结构有哪些

HashTable: 哈希表的线程平安版，效率低
ConcurrentHashMap：哈希表的线程平安版，效率高，用于代替 HashTable
Vector：线程平安版 Arraylist
Stack：线程平安版栈
BlockingQueue 及其子类：线程平安版队列

简述 JAVA 的 Set

Set 即汇合，该数据结构不容许元素反复且无序。JAVA 对 Set 有三种实现形式：

HashSet 通过 HashMap 实现，HashMap 的 Key 即 HashSet 存储的元素，Value 零碎自定义一个名为 PRESENT 的 Object 类型常量。判断元素是否雷同时，先比拟 hashCode，雷同后再利用 equals 比拟，查问 O(1)

LinkedHashSet 继承自 HashSet，通过 LinkedHashMap 实现，应用双向链表保护元素插入程序。

TreeSet 通过 TreeMap 实现的，底层数据结构是红黑树，增加元素到汇合时依照比拟规定将其插入适合的地位，保障插入后的汇合依然有序。查问 O(logn)

简述 JAVA 的 HashMap

JDK8 之前底层实现是数组 + 链表，JDK8 改为数组 + 链表 / 红黑树。次要成员变量包含存储数据的 table 数组、元素数量 size、加载因子 loadFactor。
HashMap 中数据以键值对的模式存在，键对应的 hash 值用来计算数组下标，如果两个元素 key 的 hash 值一样，就会产生哈希抵触，被放到同一个链表上。

table 数组记录 HashMap 的数据，每个下标对应一条链表，所有哈希抵触的数据都会被寄存到同一条链表，Node/Entry 节点蕴含四个成员变量：key、value、next 指针和 hash 值。在 JDK8 后链表超过 8 会转化为红黑树。

若以后数据 / 总数据容量 > 负载因子，Hashmap 将执行扩容操作。
默认初始化容量为 16，扩容容量必须是 2 的幂次方、最大容量为 1<< 30、默认加载因子为 0.75。

为何 HashMap 线程不平安

在 JDK1.7 中，HashMap 采纳头插法插入元素，因而并发状况下会导致环形链表，产生死循环。

尽管 JDK1.8 采纳了尾插法解决了这个问题，然而并发下的 put 操作也会使前一个 key 被后一个 key 笼罩。

因为 HashMap 有扩容机制存在，也存在 A 线程进行扩容后，B 线程执行 get 办法呈现失误的状况。

简述 java 的 TreeMap

TreeMap 是底层利用红黑树实现的 Map 构造，底层实现是一棵均衡的排序二叉树，因为红黑树的插入、删除、遍历工夫复杂度都为 O(logN)，所以性能上低于哈希表。然而哈希表无奈提供键值对的有序输入，红黑树能够依照键的值的大小有序输入。

Collection 和 Collections 有什么区别？

  1. Collection 是一个汇合接口，它提供了对汇合对象进行基本操作的通用接口办法，所有汇合都是它的子类，比方 List、Set 等。
  2. Collections 是一个包装类，蕴含了很多静态方法、不能被实例化，而是作为工具类应用，比方提供的排序办法：
    Collections.sort(list); 提供的反转办法：Collections.reverse(list)。

ArrayList、Vector 和 LinkedList 有什么共同点与区别？

  1. ArrayList、Vector 和 LinkedList 都是可伸缩的数组，即能够动静扭转长度的数组。
  2. ArrayList 和 Vector 都是基于存储元素的 Object[] array 来实现的，它们会在内存中开拓一块间断的空间来存储，反对下标、索引拜访。但在波及插入元素时可能须要挪动容器中的元素，插入效率较低。当存储元素超过容器的初始化容量大小，ArrayList 与 Vector 均会进行扩容。
  3. Vector 是线程平安的，其大部分办法是间接或间接同步的。ArrayList 不是线程平安的，其办法不具备同步性质。LinkedList 也不是线程平安的。
  4. LinkedList 采纳双向列表实现，对数据索引须要从头开始遍历，因而随机拜访效率较低，但在插入元素的时候不须要对数据进行挪动，插入效率较高。

HashMap 和 Hashtable 有什么区别？

  1. HashMap 是 Hashtable 的轻量级实现，HashMap 容许 key 和 value 为 null，但最多容许一条记录的 key 为 null. 而 HashTable 不容许。
  2. HashTable 中的办法是线程平安的，而 HashMap 不是。在多线程拜访 HashMap 须要提供额定的同步机制。
  3. Hashtable 应用 Enumeration 进行遍历，HashMap 应用 Iterator 进行遍历。

如何决定应用 HashMap 还是 TreeMap?

如果对 Map 进行插入、删除或定位一个元素的操作更频繁，HashMap 是更好的抉择。如果须要对 key 汇合进行有序的遍历，TreeMap 是更好的抉择。

fail-fast 和 fail-safe 迭代器的区别是什么？

  1. fail-fast 间接在容器上进行，在遍历过程中，一旦发现容器中的数据被批改，就会立即抛出 ConcurrentModificationException 异样从而导致遍历失败。常见的应用 fail-fast 形式的容器有 HashMap 和 ArrayList 等。
  2. fail-safe 这种遍历基于容器的一个克隆。因而对容器中的内容批改不影响遍历。常见的应用 fail-safe 形式遍历的容器有 ConcurrentHashMap 和 CopyOnWriteArrayList。

HashSet 中，equals 与 hashCode 之间的关系？

equals 和 hashCode 这两个办法都是从 object 类中继承过去的,equals 次要用于判断对象的内存地址援用是否是同一个地址；hashCode 依据定义的哈希规定将对象的内存地址转换为一个哈希码。HashSet 中存储的元素是不能反复的，次要通过 hashCode 与 equals 两个办法来判断存储的对象是否雷同：

  1. 如果两个对象的 hashCode 值不同，阐明两个对象不雷同。
  2. 如果两个对象的 hashCode 值雷同，接着会调用对象的 equals 办法，如果 equlas 办法的返回后果为 true，那么阐明两个对象雷同，否则不雷同。
退出移动版