基础概念与常识Java 语言有哪些特点?简单易学；面向对象（封装，继承，多态）；平台无关性，平台无关性的具体表现在于，Java 是“一次编写，到处运行（Write Once，Run any Where）”的语言，因此采用 Java 语言编写的程序具有很好的可移植性，而保证这一点的正是 Java 的虚拟机机制。在引入虚拟机之后，Java 语言在不同的平台上运行不需要重新编译。支持多线程（ C++ 语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而 Java 语言却提供了多线程支持）；可靠性、安全性；支持网络编程并且很方便（ Java 语言诞生本身就是为简化网络编程设计的，因此 Java 语言不仅支持网络编程而且很方便）；编译与解释并存；注意：C++11 开始（2011 年的时候）,C++就引入了多线程库，在 windows、linux、macos 都可以使用std::thread和std::async来创建线程。Java和C++有什么关系，它们有什么区别？都是面向对象的语言，都支持封装、继承和多态；C++ 支持指针，而 Java 没有指针的概念；C++ 支持多继承，而 Java 不支持多重继承，但允许一个类实现多个接口；Java 是完全面向对象的语言，并且还取消了 C/C++ 中的结构和联合，使编译程序更加简洁；Java 自动进行无用内存回收操作，不再需要程序员进行手动删除，而 C++ 中必须由程序释放内存资源，这就增加了程序员的负担。Java 不支持操作符重载，操作符重载则被认为是 C++ 的突出特征；Java 允许预处理，但不支持预处理器功能，所以为了实现预处理，它提供了引入语句（import），但它与 C++ 预处理器的功能类似；Java 不支持缺省参数函数，而 C++ 支持；C 和 C++ 不支持字符串变量，在 C 和 C++ 程序中使用“Null”终止符代表字符串的结束。在 Java 中字符串是用类对象（String 和 StringBuffer）来实现的；goto 语句是 C 和 C++ 的“遗物”，Java 不提供 goto 语句，虽然 Java 指定 goto 作为关键字，但不支持它的使用，这使程序更简洁易读；Java 不支持 C++ 中的自动强制类型转换，如果需要，必须由程序显式进行强制类型转换。JVM vs JRE vs JDKJVMJava 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。JVM 并不是只有一种！只要满足 JVM 规范，每个公司、组织或者个人都可以开发自己的专属 JVM。 也就是说我们平时接触到的 HotSpot VM 仅仅是是 JVM 规范的一种实现而已。JREJRE 是 Java 运行时环境，它是运行已编译 Java 程序所需的所有内容的集合，包括 Java 虚拟机（JVM）、Java 基础类库等，但是，它不能用于创建新程序。JDKJDK 是 Java Development Kit 缩写，它是功能齐全的 Java SDK，它能够创建和编译程序。它拥有 JRE 所拥有的一切，还有编译器（javac）和一些其他的工具（如 javadoc 和 jdb(调试器)）。JDK包含JRE，JRE包含JVM。什么是字节码?在 Java 中，JVM 可以理解的代码就叫做字节码（即扩展名为 .class 的文件），它不面向任何特定的处理器，只面向虚拟机。Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以， Java 程序运行时相对来说还是高效的（不过，和 C++，Rust，Go 等语言还是有一定差距的），而且，由于字节码并不针对一种特定的机器，因此，Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。Java 程序从源代码到运行的过程如下图所示：我们需要格外注意的是 .class->机器码 这一步。在这一步 JVM 类加载器首先加载字节码文件，然后通过解释器逐行解释执行，这种方式的执行速度会相对比较慢。而且，有些方法和代码块是经常需要被调用的（也就是所谓的热点代码），所以后面引进了 JIT（just-in-time compilation） （Java即时编译器），而 JIT 属于运行时编译。当 JIT 编译器完成第一次编译后，其会将字节码对应的机器码保存下来，下次可以直接使用。而我们知道，机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语言。HotSpot 采用了惰性评估(Lazy Evaluation)的做法，根据二八定律，消耗大部分系统资源的只有那一小部分的代码（热点代码），而这也就是JIT所需要编译的部分。JVM 会根据代码每次被执行的情况收集信息并相应地做出一些优化，因此执行的次数越多，它的速度就越快。JDK 9 引入了一种新的编译模式 AOT(Ahead of Time Compilation)，它是直接将字节码编译成机器码，这样就避免了 JIT 预热等各方面的开销。JDK 支持分层编译和 AOT 协作使用。采用字节码的好处是什么?Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java程序无须重新编译便可在多种不同的计算机上运行。为什么不全部使用 AOT 呢?虽然AOT可以提高程序的性能和安全性，但也存在一些使用限制和适用场景的限制。首先，AOT编译会将程序代码编译成本地机器代码，这意味着程序的大小会变得更大，占用更多的存储空间；而且将代码编译成本地机器码意味着具有跨平台特性的好处会减少。其次，AOT编译需要花费更多的时间，这对于需要频繁迭代的动态语言和开发环境不利。而且，由于AOT编译是在编译时进行的，意味着程序无法动态地修改和调整其执行环境。另外，AOT编译不适合动态生成代码，因为生成的代码无法进行AOT编译，只能采用解释执行的方式。因此，对于需要频繁迭代、动态生成代码、或者需要大量动态性能优化的应用，AOT可能不是最优解决方案。而对于需要更高性能、更高安全性、静态编译、和预编译代码的应用，则可以考虑使用AOT。为什么说 Java 语言“编译与解释并存”？我们可以将高级编程语言按照程序的执行方式分为两种：Java 语言既具有编译型语言的特征，也具有解释型语言的特征。因为 Java 程序要经过先编译，后解释两个步骤，由 Java 编写的程序需要先经过编译步骤，生成字节码（.class 文件），这种字节码必须由 Java 解释器来解释执行。Oracle JDK 和 OpenJDK 的区别是什么？ Oracle JDK 版本将每三年发布一次，而 Open JDK 版本每三个月发布一次；
OpenJDK 是一个参考模型并且是完全开源的，而 Oracle JDK 是OpenJDK 的一个实现，并不是完全开源的；
Oracle JDK 比 OpenJDK 更稳定。OpenJDK 和 Oracle JDK 的代码几乎相同，但 Oracle JDK 有更多的类和一些错误修复。因此，如果您想开发企业/商业软件，建议选择 Oracle JDK，因为它经过了彻底的测试和稳定。某些情况下，有些人提到在使用 OpenJDK 可能会遇到了许多应用程序崩溃的问题，但是，只需切换到 Oracle JDK 就可以解决问题；
在响应性和 JVM 性能方面，Oracle JDK 与 OpenJDK 相比提供了更好的性能；
Oracle JDK 不会为即将发布的版本提供长期支持，用户每次都必须通过更新到最新版本获得支持来获取最新版本；
Oracle JDK 根据二进制代码许可协议获得许可，而 OpenJDK 根据 GPLv2 许可获得许可。 基础语法注释有哪几种形式？Java 中的注释有三种： 单行注释 ：通常用于解释方法内某单行代码的作用。
多行注释 ：通常用于解释一段代码的作用。
文档注释 ：通常用于生成 Java 开发文档。 用的比较多的还是单行注释和文档注释，多行注释在实际开发中使用的相对较少。 public static void main(String[] args) {
//单行注释
System.out.println("单行注释");
/*
* 多行注释
* 多行注释
*/
System.out.println("多行注释");
/**
* 文档注释
*/
System.out.println("文档注释");
}
自增自减运算符在写代码的过程中，常见的一种情况是需要某个整数类型变量增加 1 或减少 1，Java 提供了一种特殊的运算符，用于这种表达式，叫做自增运算符（++)和自减运算符（–）。++ 和 – 运算符可以放在变量之前，也可以放在变量之后，当运算符放在变量之前时(前缀)，先自增/减，再赋值；当运算符放在变量之后时(后缀)，先赋值，再自增/减。例如，当 b = ++a 时，先自增（自己增加 1），再赋值（赋值给 b）；当 b = a++ 时，先赋值(赋值给 b)，再自增（自己增加 1）。也就是，++a 输出的是 a+1 的值，a++输出的是 a 值。用一句口诀就是：“符号在前就先加/减，符号在后就后加/减”。移位运算符移位运算符是最基本的运算符之一，几乎每种编程语言都包含这一运算符。移位操作中，被操作的数据被视为二进制数，移位就是将其向左或向右移动若干位的运算。移位运算符在各种框架以及 JDK 自身的源码中使用还是挺广泛的，HashMap（JDK1.8） 中的 hash 方法的源码就用到了移位运算符：static final int hash(Object key) {
int h;
// key.hashCode()：返回散列值也就是hashcode
// ^ ：按位异或
// >>>:无符号右移，忽略符号位，空位都以0补齐
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
在 Java 代码里使用 << 、 >> 和>>>转换成的指令码运行起来会更高效些。Java 中有三种移位运算符：<< :左移运算符，向左移若干位，高位丢弃，低位补零。x << 1,相当于 x 乘以 2(不溢出的情况下)。
<< :左移运算符，向左移若干位，高位丢弃，低位补零。x << 1,相当于 x 乘以 2(不溢出的情况下)。
>>> :无符号右移，忽略符号位，空位都以 0 补齐。
由于 double，float 在二进制中的表现比较特殊，因此不能来进行移位操作。移位操作符实际上支持的类型只有int和long，编译器在对short、byte、char类型进行移位前，都会将其转换为int类型再操作。如果移位的位数超过数值所占有的位数会怎样？当 int 类型左移/右移位数大于等于 32 位操作时，会先求余（%）后再进行左移/右移操作。也就是说左移/右移 32 位相当于不进行移位操作（32%32=0），左移/右移 42 位相当于左移/右移 10 位（42%32=10）。当 long 类型进行左移/右移操作时，由于 long 对应的二进制是 64 位，因此求余操作的基数也变成了 64。也就是说：x<<42 等同于 x<<10，x>>42 等同于 x>>10，x >>>42 等同于 42 >>> 10。continue、break 和 return 的区别是什么？在循环结构中，当循环条件不满足或者循环次数达到要求时，循环会正常结束。但是，有时候可能需要在循环的过程中，当发生了某种条件之后 ，提前终止循环，这就需要用到下面几个关键词：continue ：指跳出当前的这一次循环，继续下一次循环。break ：指跳出整个循环体，继续执行循环下面的语句。return 用于跳出所在方法，结束该方法的运行。return 一般有两种用法：return; ：直接使用 return 结束方法执行，用于没有返回值函数的方法return value; ：return 一个特定值，用于有返回值函数的方法两层循环内层break会咋样只会跳出内层循环。如何跳出两层循环？使用 OUT 标识符（任意，不一定是OUT）。public static void main(String[] args) {
test();
}
public static void test(){
for(int i = 0; i < 3; ++i){
for(int j = 0; j < 1; ++j){
if(i == 1) break ;
System.out.println(i + ":" + j);
}
}
}
Output:0:0
2:0
public static void main(String[] args) {
test();
}
public static void test(){
OUT:
for(int i = 0; i < 3; ++i){
for(int j = 0; j < 1; ++j){
if(i == 1) break OUT;
System.out.println(i + ":" + j);
}
}
}
Output:0:0
switch 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String 上？Java5 以前 switch(expr)中，expr 只能是 byte、short、char、int。从 Java 5 开始，Java 中引入了枚举类型， expr 也可以是 enum 类型。从 Java 7 开始，expr还可以是字符串(String)，但是长整型(long)在目前所有的版本中都是不可以的。访问修饰符public、private、protected、以及不写（默认）时的区别？Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）public : 对所有类可见。使用对象：类、接口、变量、方法protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。关于被 protected 修饰的变量和方法如何在不同包的子类中访问，可以参考一下这篇文章——关于protected权限的子类访问方式变量成员变量与局部变量的区别？ 语法形式 ： 从语法形式上看，成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
存储方式 ： 从变量在内存中的存储方式来看,如果成员变量是使用 static 修饰的，那么这个成员变量是属于类的，如果没有使用 static 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
生存时间 ： 从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡。
默认值 ： 从变量是否有默认值来看，成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。 静态变量有什么作用？静态变量可以被类的所有实例共享。无论一个类创建了多少个对象，它们都共享同一份静态变量。通常情况下，静态变量会被 final 关键字修饰成为常量。字符型常量和字符串常量的区别? 形式 : 字符常量是单引号引起的一个字符，字符串常量是双引号引起的 0 个或若干个字符。
含义 : 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)。
占内存大小 ： 字符常量只占 2 个字节; 字符串常量占若干个字节。 (注意： char 在 Java 中占两个字节方法什么是方法的返回值?方法有哪几种类型？方法的返回值 是指我们获取到的某个方法体中的代码执行后产生的结果！（前提是该方法可能产生结果）。返回值的作用是接收出结果，使得它可以用于其他的操作！我们可以按照方法的返回值和参数类型将方法分为下面这几种：无参数无返回值的方法、有参数无返回值的方法、有返回值无参数的方法、有返回值有参数的方法。静态方法为什么不能调用非静态成员?静态方法是属于类的，在类加载的时候就会分配内存，可以通过类名直接访问。而非静态成员属于实例对象，只有在对象实例化之后才存在，需要通过类的实例对象去访问。在类的非静态成员不存在的时候静态成员就已经存在了，此时调用在内存中还不存在的非静态成员，属于非法操作。静态方法和实例方法有何不同？调用方式在外部调用静态方法时，可以使用 类名.方法名 的方式，也可以使用 对象.方法名 的方式，而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象 。不过，需要注意的是一般不建议使用 对象.方法名 的方式来调用静态方法。这种方式非常容易造成混淆，静态方法不属于类的某个对象而是属于这个类。因此，一般建议使用 类名.方法名 的方式来调用静态方法。访问类成员是否存在限制静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），不允许访问实例成员（即实例成员变量和实例方法），而实例方法不存在这个限制。重载和重写有什么区别？重载就是同样的一个方法能够根据输入数据的不同，做出不同的处理
重写就是当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法
重载发生在同一个类中（或者父类和子类之间），方法名必须相同，参数列表不同（参数类型不同、个数不同、顺序不同），方法返回值和访问修饰符可以不同。重载就是同一个类中多个同名方法根据不同的传参来执行不同的逻辑处理。重写重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。 方法名、参数列表必须相同，子类方法返回值类型应比父类方法返回值类型更小或相等，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。
如果父类方法访问修饰符为 private/final/static 则子类就不能重写该方法，但是被 static 修饰的方法能够被再次声明。
构造方法无法被重写。 综上：重写就是子类对父类方法的重新改造，外部样子不能改变，内部逻辑可以改变。区别点重载方法重写方法发生范围同一个类子类参数列表必须修改不可以修改返回类型可修改子类方法返回值类型应比父类方法返回值类型更小或相等异常可修改子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等访问修饰符可修改一定不能做更严格的限制（可以降低限制）发生阶段编译期运行期方法的重写要遵循“两同两小一大”“两同”即方法名相同、形参列表相同；“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。关于 重写的返回值类型 这里需要额外多说明一下，上面的表述不太清晰准确：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。为什么说Java中重载的方法在编译时就确定了Java 中的方法重载是静态多态性（编译时多态性）的一种表现形式，也就是在编译期间就能够确定具体调用哪个方法。其原因是在方法重载的时候，编译器会根据方法的名称、参数类型、参数个数和参数顺序等信息，生成一个唯一的方法签名，将其作为方法的唯一标识符。在调用该方法时，编译器会根据方法名、参数的类型、个数和顺序等信息，匹配该方法的唯一标识符，从而确定具体调用哪个方法。例如，下面是一个简单的方法重载示例：public class Test {
public static void main(String[] args) {
int a = 1, b = 2;
double c = 1.5, d = 2.5;
System.out.println(add(a, b)); // 调用 add(int, int)
System.out.println(add(c, d)); // 调用 add(double, double)
}
public static int add(int a, int b) {
return a + b;
}
public static double add(double a, double b) {
return a + b;
}
}
什么是可变长参数？从 Java5 开始，Java 支持定义可变长参数，所谓可变长参数就是允许在调用方法时传入不定长度的参数。就比如下面的这个 printVariable 方法就可以接受 0 个或者多个参数。public static void method1(String... args) {
//......
}
另外，可变参数只能作为函数的最后一个参数，但其前面可以有也可以没有任何其他参数。public static void method2(String arg1, String... args) {
//......
}
遇到方法重载的情况怎么办呢？会优先匹配固定参数还是可变参数的方法呢？答案是会优先匹配固定参数的方法，因为固定参数的方法匹配度更高。另外，Java 的可变参数编译后实际会被转换成一个数组，我们看编译后生成的 class文件就可以看出来了。关键字标识符和关键字的区别是什么？在我们编写程序的时候，需要大量地为程序、类、变量、方法等取名字，于是就有了 标识符 。简单来说， 标识符就是一个名字 。有一些标识符，Java 语言已经赋予了其特殊的含义，只能用于特定的地方，这些特殊的标识符就是 关键字 。简单来说，关键字是被赋予特殊含义的标识符 。final、finally、finalize的区别？final 用于修饰变量、方法和类。 final 变量：被修饰的变量不可变，不可变分为引用不可变和对象不可变，final 指的是引用不可变，final 修饰的变量必须初始化，通常称被修饰的变量为常量。
final 方法：被修饰的方法不允许任何子类重写，子类可以使用该方法。
final 类：被修饰的类不能被继承，所有方法不能被重写。 如果想要详细了解引用不可变和对象不可变可以参考这篇文章——关键字final“不可变的对象”与“不可变的对象引用”。finally 作为异常处理的一部分，它只能在 try/catch 语句中，并且附带一个语句块表示这段语句最终一定被执行（无论是否抛出异常），经常被用在需要释放资源的情况下，System.exit (0) 可以阻断 finally 执行。public static void main(String[] args) {
try {
System.out.println("1");
System.exit(0);
}catch (Exception e){
e.printStackTrace();
}finally {
System.out.println("2");
}
}
output:1
finalize 是在 java.lang.Object 里定义的方法，也就是说每一个对象都有这么个方法，这个方法在 gc 启动，该对象被回收的时候被调用。一个对象的 finalize 方法只会被调用一次，finalize 被调用不一定会立即回收该对象，所以有可能调用 finalize 后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会再次调用 finalize 了，进而产生问题，因此不推荐使用 finalize 方法。为什么要用static关键字？类是抽象的存在，简单的说我们在代码中定义的class，而类的实例是类具体化的存在。在实际的开发中，会存在这样的情况，有些类的使用没有实例化的必要。这时候，就可以用static来修饰成员变量和方法，表明这些变量和方法属于类本身。因为一个类的基本信息在类初始化以后类的相关信息是放在堆里面的，是共享的。类里面static修饰方法、变量是属于类本身，自然也会随之加载。因此我们可以使用className.method()的格式来调用静态方法、类名className.params来调用静态变量，而无需去实例化一个对象。"static"关键字是什么意思？Java中是否可以覆盖(override)一个private或者是static的方法？在Java中，"static"关键字用于修饰类的属性和方法，表示这些属性和方法属于类本身而不是具体的对象实例。具体来说，被static修饰的属性和方法可以直接使用类名访问，而不需要先创建对象实例。关于是否可以覆盖(override)一个private或者是static的方法，答案是不可以。对于private方法，它们被定义为只能在所在类中访问。由于覆盖(override)是在子类中进行的，子类无法访问父类的私有方法，因此无法对其进行覆盖(override)。对于static方法，由于它们属于类级别而不是对象实例级别，因此它们是与类名相关联的，子类无法通过覆盖(override)方式改变它们的行为。在子类中重新定义一个同名的static方法，实际上是将父类的方法隐藏起来，而不是覆盖(override)它。因此，就算在子类中再定义一个同名的static方法，也不会影响到父类和其他子类对原有方法的调用。是否可以在static环境中访问非static变量？static变量在Java中是属于类的，它在所有的实例中的值是一样的。当类被Java虚拟机载入的时候，会对static变量进行初始化。如果你的代码尝试不用实例来访问非static的变量，编译器会报错，因为这些变量还没有被创建出来，还没有跟任何实例关联上。static静态方法能不能引用非静态资源？不能，new的时候才会产生的东西，对于初始化后就存在的静态资源来说，根本不认识它。static静态方法里面能不能引用静态资源？可以，因为都是类初始化的时候加载的，大家相互都认识。非静态方法里面能不能引用静态资源？可以，非静态方法就是实例方法，那是new之后才产生的，那么属于类的内容它都认识。java静态变量、代码块、和静态方法的执行顺序是什么？基本上代码块分为三种：Static静态代码块、构造代码块、普通代码块代码块执行顺序：静态代码块——> 构造代码块 ——> 构造函数——> 普通代码块继承中代码块执行顺序：父类静态块——>子类静态块——>父类构造代码块——>父类构造器——>子类构造代码块——>子类构造器如果想要详细了解这个问题，可以参考这篇文章——Static静态代码块以及各代码块之间的执行顺序。基本数据类型Java有哪些数据类型？Java 语言的数据类型分为两种：基本数据类型和引用数据类型。这 8 种基本数据类型的默认值以及所占空间的大小如下：基本类型位数字节默认值取值范围byte810-128 ~ 127short1620-32768 ~ 32767int3240-2147483648 ~ 2147483647long6480L-9223372036854775808 ~ 9223372036854775807char162‘u0000’0 ~ 65535float3240f1.4E-45 ~ 3.4028235E38double6480d4.9E-324 ~ 1.7976931348623157E308boolean1falsetrue、false对于 boolean，官方文档未明确定义，它依赖于 JVM 厂商的具体实现。逻辑上理解是占用 1 位，但是实际中会考虑计算机高效存储因素。另外，Java 的每种基本类型所占存储空间的大小不会像其他大多数语言那样随机器硬件架构的变化而变化。这种所占存储空间大小的不变性是 Java 程序比用其他大多数语言编写的程序更具可移植性的原因之一。注意：Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析。char a = ‘h’ ：单引号，String a = “hello” ：双引号。这八种基本类型都有对应的包装类分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean 。不知道大家有没有疑惑，反正看到这里我是有点疑惑的，好吧，应该是我太菜了——String，为什么这个最常用的不在这八大基本类型中？因为基本数据类型不能创建对象，而String是可以创建对象的，String它是一个类，而基本数据类型不是，这就是这个数据类型的特别之处。为什么浮点数运算的时候会有精度丢失的风险？浮点数运算精度丢失代码演示：float a = 2.0f - 1.9f;
float b = 1.8f - 1.7f;
System.out.println(a);// 0.100000024
System.out.println(b);// 0.099999905
System.out.println(a == b);// false
为什么会出现这个问题呢？这个和计算机保存浮点数的机制有很大关系。我们知道计算机是二进制的，而且计算机在表示一个数字时，宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。这也就是解释了为什么浮点数没有办法用二进制精确表示。就比如说十进制下的 0.2 就没办法精确转换成二进制小数：// 0.2 转换为二进制数的过程为，不断乘以 2，直到不存在小数为止，
// 在这个计算过程中，得到的整数部分从上到下排列就是二进制的结果。
0.2 * 2 = 0.4 -> 0
0.4 * 2 = 0.8 -> 0
0.8 * 2 = 1.6 -> 1
0.6 * 2 = 1.2 -> 1
0.2 * 2 = 0.4 -> 0（发生循环）
...
如何解决浮点数运算的精度丢失问题？BigDecimal 可以实现对浮点数的运算，不会造成精度丢失。通常情况下，大部分需要浮点数精确运算结果的业务场景（比如涉及到钱的场景）都是通过 BigDecimal 来做的。Java 在 java.math 包中提供的 API 类 BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量 double 可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal 所创建的是对象，我们不能使用传统的+、-、*、/ 等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是 BigDecimal 的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
BigDecimal c = new BigDecimal("0.8");
BigDecimal x = a.subtract(b);
BigDecimal y = b.subtract(c);
System.out.println(x); /* 0.1 */
System.out.println(y); /* 0.1 */
System.out.println(Objects.equals(x, y)); /* true */
超过 long 整型的数据应该如何表示？基本数值类型都有一个表达范围，如果超过这个范围就会有数值溢出的风险。在 Java 中，64 位 long 整型是最大的整数类型。long l = Long.MAX_VALUE;
System.out.println(l + 1); // -9223372036854775808
System.out.println(l + 1 == Long.MIN_VALUE); // true
BigInteger 内部使用 int[] 数组来存储任意大小的整形数据。相对于常规整数类型的运算来说，BigInteger 运算的效率会相对较低。包装类型包装类型是什么？Java 为每一个基本数据类型都引入了对应的包装类型（wrapper class），int 的包装类就是 Integer，从 Java 5 开始引入了自动装箱/拆箱机制，把基本类型转换成包装类型的过程叫做装箱（boxing）；反之，把包装类型转换成基本类型的过程叫做拆箱（unboxing），使得二者可以相互转换。Java 为每个原始类型提供了包装类型：原始类型: boolean，char，byte，short，int，long，float，double包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double基本类型和包装类型的区别？ 成员变量包装类型不赋值就是 null ，而基本类型有默认值且不是 null。
包装类型可以为 null，而基本类型不可以。它使得包装类型可以应用于 POJO 中，而基本类型则不行。那为什么 POJO 的属性必须要用包装类型呢？《阿里巴巴 Java 开发手册》上有详细的说明， 数据库的查询结果可能是 null，如果使用基本类型的话，因为要自动拆箱（将包装类型转为基本类型，比如说把 Integer 对象转换成 int 值），就会抛出 NullPointerException 的异常。
包装类型可用于泛型，而基本类型不可以。
基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被 static 修饰 ）存放在 Java 虚拟机的堆中。包装类型属于对象类型，我们知道几乎所有对象实例都存在于堆中。
相比于对象类型， 基本数据类型占用的空间非常小。基本类型在栈中直接存储的具体数值，而包装类型则存储的是堆中的引用。 很显然，相比较于基本类型而言，包装类型需要占用更多的内存空间。 为什么说是几乎所有对象实例呢？这是因为 HotSpot 虚拟机引入了 JIT 优化之后，会对对象进行逃逸分析，如果发现某一个对象并没有逃逸到方法外部，那么就可能通过标量替换来实现栈上分配，而避免堆上分配内存。注意 ： 基本数据类型存放在栈中是一个常见的误区！ 基本数据类型的成员变量如果没有被 static 修饰的话（不建议这么使用，应该要使用基本数据类型对应的包装类型），就存放在堆中。包装类型的缓存机制了解么？Java 基本数据类型的包装类型的大部分都用到了缓存机制来提升性能。Byte，Short，Integer，Long 这 4 种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，Character 创建了数值在 [0,127] 范围的缓存数据，Boolean 直接返回 True or False。Integer 缓存源码：public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
private static class IntegerCache {
static final int low = -128;
static final int high;
static {
// high value may be configured by property
int h = 127;
}
}
Character 缓存源码:public static Character valueOf(char c) {
if (c <= 127) { // must cache
return CharacterCache.cache[(int)c];
}
return new Character(c);
}
private static class CharacterCache {
private CharacterCache(){}
static final Character cache[] = new Character[127 + 1];
static {
for (int i = 0; i < cache.length; i++)
cache[i] = new Character((char)i);
}
}
Boolean 缓存源码：public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
如果超出对应范围仍然会去创建新的对象，缓存的范围区间的大小只是在性能和资源之间的权衡。两种浮点数类型的包装类 Float，Double 并没有实现缓存机制。Integer i1 = 33;
Integer i2 = 33;
System.out.println(i1 == i2);// 输出 true
Float i11 = 333f;
Float i22 = 333f;
System.out.println(i11 == i22);// 输出 false
Double i3 = 1.2;
Double i4 = 1.2;
System.out.println(i3 == i4);// 输出 false
下面我们来看一下问题。下面的代码的输出结果是 true 还是 false 呢？Integer i1 = 40;
Integer i2 = new Integer(40);
System.out.println(i1==i2);
Integer i1=40 这一行代码会发生装箱，也就是说这行代码等价于 Integer i1=Integer.valueOf(40) 。因此，i1 直接使用的是缓存中的对象。而Integer i2 = new Integer(40) 会直接创建新的对象。因此，答案是 false 。所有整型包装类对象之间值的比较， 全部使用 equals 方法比较。说明： 对于 Integer var = ? 在-128 至 127 之间的赋值， Integer 对象是在 <IntegerCache.cache >产生，
会复用已有对象，这个区间内的 Integer 值可以直接使用==进行判断，但是这个区间之外的所有数据，都
会在堆上产生，并不会复用已有对象，这是一个大坑，推荐使用 equals 方法进行判断。
自动装箱与拆箱了解吗？原理是什么？什么是自动拆装箱？装箱： 将基本类型用它们对应的引用类型包装起来；拆箱： 将包装类型转换为基本数据类型；Integer i = 10;
//装箱
int n = i;
//拆箱
上面这两行代码对应的字节码为：
L1
LINENUMBER 8 L1
ALOAD 0
BIPUSH 10
INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
PUTFIELD AutoBoxTest.i : Ljava/lang/Integer;
L2
LINENUMBER 9 L2
ALOAD 0
ALOAD 0
GETFIELD AutoBoxTest.i : Ljava/lang/Integer;
INVOKEVIRTUAL java/lang/Integer.intValue ()I
PUTFIELD AutoBoxTest.n : I
RETURN
从字节码中，我们发现装箱其实就是调用了 包装类的valueOf()方法，拆箱其实就是调用了xxxValue()方法。因此，注意：如果频繁拆装箱的话，也会严重影响系统的性能。我们应该尽量避免不必要的拆装箱操作。private static long sum() {
// 应该使用 long 而不是 Long
Long sum = 0L;
for (long i = 0; i <= Integer.MAX_VALUE; i++)
sum += i;
return sum;
}
int 和 Integer 有什么区别?Integer是int的包装类；int是基本数据类型；Integer变量必须实例化后才能使用；int变量不需要；Integer实际是对象的引用，指向此new的Integer对象；int是直接存储数据值 ；Integer的默认值是null；int的默认值是0。两个new生成的Integer变量的对比由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。Integer i = new Integer(10000);
Integer j = new Integer(10000);
System.out.print(i == j); //false
Integer变量和int变量的对比Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）int a = 10000;
Integer b = new Integer(10000);
Integer c=10000;
System.out.println(a == b); // true
System.out.println(a == c); // true
非new生成的Integer变量和new Integer()生成变量的对比非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）Integer b = new Integer(10000);
Integer c=10000;
System.out.println(b == c); // false
两个非new生成的Integer对象的对比对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false。Integer i = 100;
Integer j = 100;
System.out.print(i == j); //true
Integer i = 128;
Integer j = 128;
System.out.print(i == j); //false
当值在 -128 ~ 127之间时，java会进行自动装箱，然后会对值进行缓存，如果下次再有相同的值，会直接在缓存中取出使用。缓存是通过Integer的内部类IntegerCache来完成的。当值超出此范围，会在堆中new出一个对象来存储。给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf，源码如下：public static Integer valueOf(String s, int radix) throws NumberFormatException {
return Integer.valueOf(parseInt(s,radix));
}
/**
* （1）在-128~127之内：静态常量池中cache数组是static final类型，cache数组对象会被存储于静态常量池中。
*
cache数组里面的元素却不是static final类型，而是cache[k] = new Integer(j++)，
*
那么这些元素是存储于堆中，只是cache数组对象存储的是指向了堆中的Integer对象（引用地址）
*
* （2）在-128~127 之外：新建一个 Integer对象，并返回。
*/
public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high) {
return IntegerCache.cache[i + (-IntegerCache.low)];
}
return new Integer(i);
}
IntegerCache是Integer的内部类，源码如下：
/**
* 缓存支持自动装箱的对象标识语义 -128和127（含）。
* 缓存在第一次使用时初始化。 缓存的大小可以由-XX：AutoBoxCacheMax = <size>选项控制。
* 在VM初始化期间，java.lang.Integer.IntegerCache.high属性可以设置并保存在私有系统属性中
*/
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++) {
cache[k] = new Integer(j++); // 创建一个对象
}
}
private IntegerCache() {}
}

数据库技术中，所有的数据存储的结构和形式都是由数据表限制和规定的。所以数据表的设计非常的重要，因为数据库的研究重点之一就是如何科学的组织和存储数据。如何可以设置科学、合理的数据表呢？一、表设计的规范化从数据表设计的规范化来说。一般的，关系（表）设计都要满足3NF。范式在数据库设计中有以下几种：1NF，2NF，3NF，BCNF，4NF。1）1NF——第一范式要求一个关系中的所有属性都是简单属性，不可再分。2）2NF——第二范式在满足第一范式的要求下，每一个非关键属性完全依赖于关键属性。3）3NF——第三范式在满足第二范式的要求下，每一个非关键属性之间不存在依赖关系例如，学生成绩学号英语数学语文总分1994589233上述关系中，虽然满足1、2范式，但是不满足3范式。总分属性依赖于其他几个成绩属性。要想满足3范式，直接去掉总分属性即可。二、表中数据的类型设计表的时候，设计好表中存储的数据的数据类型。只有科学合理的数据类型存储数据的时候才会更加有意义。例如创建表的时候：选择的数据类型。Oracle中常用的数据类型1）数值-整数和小数NUMBER——数字。INT/SMALLINT/LONG——整数。FLOAT/DOUBLE PRECISON/DECIMAL——小数。2）字符/字符串CHAR/CHARACTOR——字符串。表示固定长度。计算机会给这个字段的所有数据分配相同个数的字符空间。即使用不完，也会占用。VARCHAR/VARCHAR2——可变字符串。表示不固定长度的。计算机按照字段对应的值实际长度进行空间的分配。3）时间日期类型DATE——日期和时间。可以包含年月日、时分秒。TIMESTAMP——时间戳。表示从1970年1月1日0时0分0秒开始到目前的所有秒数。三、表中数据的约束1）主键约束。在一个表中，最重要的能够唯一区别元组的属性。primary key。一个表中只有一个主键。2）非空约束。表中的某一个字段，其属性值必须填写。not
null表中的所有字段都可以设置非空。3）默认约束表中的某一个字段中的属性值，在不填写的情况下就有一个默认的值。default4）唯一约束表中的某一个字段的属性值，要求必须是唯一的。unique唯一在表中可以有一个字段值为空。但是只能有一个。主键是唯一且不为空。5）检查约束对字段的属性值的取值范围进行限定。check6）外键约束在一个表和另一个表中，对应的数据必须要满足的互相依赖的一种限制。foreign
key
references（参照）四、表的操作1、创建表create
table
表名(列名1
数据类型（大小） nut null,列名2
数据类型（大小） unique,列名3
数据类型（大小） default
'默认值',列名4
数据类型（大小） check
列名4>=值,列名5
数据类型（大小）,列名6
数据类型（大小）,constraint 主键约束名称
primary key （主键列名5）,constraint 外键约束名称
foreign key （外键列名6） references
其他表名（列名）);例如。创建一个省份（sheng）表：字段数据类型约束sid（省份的顺序）NUMBER主键sname（省份的名称）varchar2（20）唯一，非空other（其他）varchar2（50）空图形界面：查看唯一约束的创建使用SQL语句创建：创建带有外键的表：市（shi）。shid（城市编号）NUMBER（3）主键sid（省份序号）NUMBER（2）外键（参照省份表中的省份序号）shname（城市名称）varchar2（50）唯一other（其他）varchar2（50）空操作语句：2、删除表drop
table
表名；这个比较简单就不演示了。3、修改表1）添加属性对于student表，修改前的结构：例如，在学生表中添加一个属性，班级属性。该属性是字符串，最多15个字符，不能为空。输入操作命令：ALTER TABLE STUDENT ADD (CLASSID VARCHAR2(15) NOT NULL);注意：①alter table 就是修改表，后面跟被修改的表的名称；②add表示添加属性，要添加的属性用圆括号括起来；③添加的属性书写格式：（属性名 数据类型 约束条件）；④一次只能添加一个属性；运行命令：查看修改后的表：在学生表中，添加一个属性名Other（备注），允许空，字符串，最多100个字符。2）删除属性（删除一个属性）如果一个表中的属性不需要，可以进行删除。将Student表中的Other属性删除。输入以下命令：ALTER TABLE STUDENT DROP COLUMN OTHER;注意：①drop表示删除，后面跟被删除的内容②column表示列（属性），后面跟属性名（列名）；运行结果：3）删除属性（删除多个）如果需要一次性删除多个属性。可以使用如下的命令：ALTER TABLE 表名 DROP (属性名1，属性名2，……);例如，student表中有多个不要的属性 t1，t2，t3需要删除。可以使用以下方式：