java开发从入门到精通 java开发基础知识

文章目录

• 面向对象的特征
• 面向对象和面向过程的区别与优缺点
• JDK、JRE和JVM的联系与区别
• Java跨平台性的定义及原理
• 字节码的定义及采用字节码的好处
• 多态机制及多态实现
• Java中的覆盖与重载及重载构成的条件
• 抽象类和接口的异同
• Java和C++的区别
• final、finally和finalize区别
• this和super的区别
• static
• 在Java中跳出当前的多重嵌套循环
• 普通类和抽象类的区别
• 对象实例和对象引用的区别
• 成员变量与局部变量的区别
• 在Java中定义一个不做事且没有参数的构造方法的作用
• 静态变量和实例变量/普通变量/非静态变量的区别
• 静态方法和实例方法的区别
• 内部类
• ==和equals的区别
• hashCode与equals
• JDK中常用的包
• BIO、NIO和AIO的区别
• Files的常用方法
• 反射机制
• 字符串常量池
• String
• 在使用HashMap的时候，用String做key的好处
• String和StringBuffer、StringBuilder的区别，String为什么是不可变的
• 包装类

面向对象的特征

• 封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治，封闭的对象，可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。封装给对象提供了隐藏内部特性和行为的能力，对象提供一些能这被其它对象访问的方法来改变它内部的数据。
• 继承：继承（Java关键字extends）是从已有类得到继承信息创建新类的过程，继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。子类继承父类属性（静态特征）和方法（动态特征），继承必须遵循封装当中的控制访问。
• 多态：多态性是指允许相同或不同子类型的对象对同一消息作出不同响应。广义多态包括重载（Java关键字overload）和重写（也叫覆盖，Java关键字override），狭义多态指重写。重载（又称静态多态，编译时多态）：同一个动作作用在同一个对象上拥有不同的解释。重写（又称动态多态，运行时多态）：同一个动作作用在不同的对象上拥有不同的解释。

注：上述为面向对象的三大特征，当说面向对象的四大特征时，还有一个特征是抽象。抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面，抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

面向对象和面向过程的区别与优缺点

• 区别
  面向过程是具体化的、流程化的，解决一个问题需要一步一步地分析、实现。面向对象是模型化的，只需抽象出一个类，在这里拥有数据也拥有解决问题的方法，需要什么功能直接使用就可以了，不必去一步一步的实现。
  面向对象的底层其实还是面向过程，把面向过程抽象成类，然后封装，方便我们使用的就是面向对象了。
• 优缺点

• 面向过程
  优点：性能比面向对象高，因为面向对象中类调用时需要实例化，开销比较大。单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
  缺点：没有面向对象易维护、易复用、易扩展。
• 面向对象
  优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。
  缺点：性能比面向过程低。

JDK、JRE和JVM的联系与区别

• JDK是Java开发工具包(Java Development Kit)，是java开发环境的核心组件，并提供编译、调试和运行一个Java程序所需要的所有工具、可执行文件和二进制文件，是一个平台特定的软件。
  JDK包含了JRE，所以安装了JDK，就无需再单独安装JRE了。其中的开发工具有编译工具(javac.exe)、打包工具(jar.exe)等。
• JRE是Java运行时环境(Java Runtime Environment)，是JVM实施的基础，提供了运行Java程序的环境。
  JRE包含了JVM，但是不包含Java编译器、调试器之类的开发工具。JRE大部分都是由C和C++语言编写的，它提供编译Java时所需要的基础类库，包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是java.lang包：包含了运行Java程序必不可少的系统类，如基本数据类型、基本数学函数、字符串处理、线程、异常处理类等，系统缺省加载这个包。如果只需要运行一个开发好的Java程序而不需要编译调试的话，计算机中只需要安装JRE即可。
• JVM是Java虚拟机(Java Virtual Machine)，当我们运行一个程序时，JVM负责将字节码转换为特定机器代码，JVM提供了内存管理、垃圾回收和安全机制等。
  Java程序需要运行在虚拟机上，不同的平台有自己支持的Java虚拟机，因此Java语言可以实现跨平台。

Java跨平台性的定义及原理

• 定义：Java语言编写的程序可以一次编译后在多个系统平台上运行。
• 实现原理：独立于硬件和操作系统，Java程序是通过Java虚拟机在系统平台上运行的，只要该系统可以安装相应的Java虚拟机，该系统就可以运行Java程序。

字节码的定义及采用字节码的好处

• 字节码：Java源代码经过虚拟机编译器编译后产生的文件（即扩展为.class的文件），它不面向任何特定的处理器，只面向虚拟机。
• 采用字节码的好处：Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且由于字节码并不专对一种特定的机器，因此Java程序无须重新编译便可在多种不同的计算机上运行。

多态机制及多态实现

• 多态机制
  所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
  多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。
• 多态实现
  Java实现多态有三个必要条件：继承、重写、向上转型。

• 继承：在多态中必须存在有继承关系的子类和父类。
• 重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
• 向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

Java中的覆盖与重载及重载构成的条件

• 覆盖(Override)是指子类对父类方法的一种重写，只能比父类抛出更少的异常，访问权限不能比父类的小。被覆盖的方法不能是 private 的，否则只是在子类中重新定义了一个方法。
  重载(Overload)表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同。
• 构成重载的条件
  参数类型不同、参数个数不同、参数顺序不同。
  注：函数的返回值不同不可以构成重载。因为Java 中调用函数并不需要强制赋值。比如有int fun(){}、void fun(){}等，那么执行fun();语句时，Java不能判断需要调用哪一个fun()。

抽象类和接口的异同

• 相同点
  ① 接口和抽象类都不能实例化。
  ② 都位于继承的顶端，用于被其他实现或继承。
• 不同点
  ① 抽象类使用abstract关键字声明；接口使用interface关键字声明。
  ② 子类使用extends关键字来继承抽象类，如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现；子类使用implements关键字来实现接口，它需要提供接口中所有声明的方法的实现。
  ③ 抽象类可以有构造器；接口不能有构造器。
  ④ 抽象类中可以没有抽象方法；接口中的方法必须是抽象方法。
  ⑤ 抽象类中的方法可以是任意访问修饰符；接口方法默认修饰符是public，并且不允许定义为private或者protected。
  ⑥ 一个类最多只能继承一个抽象类；一个类可以实现多个接口。
  ⑦ 抽象类的字段声明可以是任意的，可以有普通的成员变量；接口的字段默认都是static和final的，必须被初始化 , 接口中只有常量没有变量。

注：Java8中接口中引入默认方法和静态方法，以此来减少抽象类和接口之间的差异。现在，我们可以为接口提供默认实现方法，并且不用强制子类来实现它。

Java和C++的区别

• 都是面向对象的语言，都支持封装、继承和多态。
• Java不提供指针来直接访问内存，程序内存更加安全。
• Java的类是单继承的，C++支持多重继承；虽然Java的类不可以多继承，但是接口可以多继承，Java 通过一个类实现多个接口来实现 C++ 中的多重继承。
• Java有自动内存管理机制，不需要程序员手动释放无用内存。

final、finally和finalize区别

• final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。
• finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
• finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调用，当我们调用System.gc()方法的时候，由垃圾回收器调用finalize()回收垃圾，一个对象是否可回收的最后判断。

this和super的区别

• this是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。
  this的用法在java中大体可以分为3种：
  ① 普通的直接引用，this相当于是指向当前对象本身。
  ② 形参与成员名字重名，用this来区分。
  ③ 引用本类的构造函数。
• super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。
  super也有三种用法：
  ① 普通的直接引用，与this类似，super相当于是指向当前对象的父类的引用，这样就可以用super.xxx来引用父类的成员。
  ② 子类中的成员变量或方法与父类中的成员变量或方法同名时，用super进行区分。
  ③ 引用父类构造函数。

static

• static存在的主要意义
  ① static的主要意义是在于创建独立于具体对象的域变量或者方法。以致于即使没有创建对象，也能使用属性和调用方法。
  ② static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
  为什么说static块可以用来优化程序性能，是因为它的特性——只会在类加载的时候执行一次。因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。
• static的独特之处
  ① 被static修饰的变量或者方法是独立于该类的任何对象，也就是说，这些变量和方法不属于任何一个实例对象，而是被类的实例对象所共享。
  ② 在该类被第一次加载的时候，就会去加载被static修饰的部分，而且只在类第一次使用时加载并进行初始化，注意这是第一次用就要初始化，后面根据需要是可以再次赋值的。
  ③ static变量值在类加载的时候分配空间，以后创建类对象的时候不会重新分配。赋值的话，是可以任意赋值的。
  ④ 被static修饰的变量或者方法是优先于对象存在的，也就是说当一个类加载完毕之后，即便没有创建对象，也可以去访问。
• static应用场景
  因为static是被类的实例对象所共享，因此如果某个成员变量是被所有对象所共享的，那么这个成员变量就应该定义为静态变量。因此比较常见的static应用场景有：
  ① 修饰成员变量。
  ② 修饰成员方法。
  ③ 静态代码块。
  ④ 修饰类（只能修饰内部类也就是静态内部类）。
  ⑤ 静态导包。
• static注意事项
  ① 静态只能访问静态。
  ② 非静态既可以访问非静态的，也可以访问静态的。

在Java中跳出当前的多重嵌套循环

在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break 语句，即可跳出外层循环。例如：

public static void main(String[] args) {
    ok:
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            System.out.println("i=" + i + ",j=" + j);
            if (j == 5) {
                break ok;
            }
        }
    }
}

普通类和抽象类的区别

• 普通类不能包含抽象方法，抽象类可以包含抽象方法。
• 抽象类不能直接实例化，普通类可以直接实例化。

注：抽象类不能使用final修饰。因为定义抽象类就是让其他类继承的，如果定义为final该类就不能被继承，这样彼此就会产生矛盾，所以final不能修饰抽象类。

对象实例和对象引用的区别

new关键字创建对象实例（在堆内存中），对象引用（在栈内存中）指向对象实例。一个对象引用可以指向0个或1个对象，一个对象可以有n个引用指向它。

成员变量与局部变量的区别

成员变量：方法外部，类内部定义的变量。
局部变量：类的方法中的变量。

• 作用域
  成员变量：针对整个类有效。
  局部变量：只在某个范围内有效。(一般指的就是方法，语句体内)
• 存储位置
  成员变量：存储在堆内存中。
  局部变量：存储在栈内存中。
• 生命周期
  成员变量：随着对象的创建而存在，随着对象的消失而消失。
  局部变量：在方法被调用或者语句被执行的时候存在，当方法调用完或者语句结束后就自动释放。
• 初始值
  成员变量：有默认初始值。
  局部变量：没有默认初始值，使用前必须赋值。

在Java中定义一个不做事且没有参数的构造方法的作用

Java程序在执行子类的构造方法之前，如果没有用super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用super()来调用父类中特定的构造方法，则编译时将发生错误，因为Java程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数的构造方法。

静态变量和实例变量/普通变量/非静态变量的区别

• 静态变量： 静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，在类的加载过程中，JVM只为静态变量分配一次内存空间。
• 实例变量： 每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在内存中，创建几次对象，就有几份成员变量。
• 静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

注：static成员变量的初始化顺序按照定义的顺序进行初始化。

静态方法和实例方法的区别

• 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式；而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
• 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。
  内部类

内部类

在Java中，可以将一个类的定义放在另外一个类的定义内部，这就是内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。
内部类可以分为四种：成员内部类、局部内部类、匿名内部类和静态内部类。

• 静态内部类

• 定义在类内部的静态类，就是静态内部类。
• 静态内部类可以访问外部类所有的静态变量，而不可访问外部类的非静态变量；静态内部类的创建方式：new 外部类.静态内部类()。

• 成员内部类

• 定义在类内部，成员位置上的非静态类，就是成员内部类。
• 成员内部类可以访问外部类所有的变量和方法，包括静态和非静态，私有和公有。成员内部类依赖于外部类的实例，它的创建方式：外部类实例.new 内部类()。

• 局部内部类

• 定义在方法中的内部类，就是局部内部类。
• 定义在实例方法中的局部类可以访问外部类的所有变量和方法，定义在静态方法中的局部类只能访问外部类的静态变量和方法。局部内部类的创建方式：在对应方法内，new 内部类()。

• 匿名内部类

• 匿名内部类就是没有名字的内部类，日常开发中使用的比较多。
• 除了没有名字，匿名内部类还有以下特点：
  ① 匿名内部类必须继承一个抽象类或者实现一个接口。
  ② 匿名内部类不能定义任何静态成员和静态方法。
  ③ 当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。
  ④ 匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
  匿名内部类创建方式：

new 类/接口{ 
  //匿名内部类实现部分
}

• 内部类的优点
  ① 一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据。
  ② 内部类不为同一包的其他类所见，具有很好的封装性。
  ③ 内部类有效实现了“多重继承”，优化 java 单继承的缺陷。
  ④ 匿名内部类可以很方便的定义回调。
• 内部类的应用场景
  ① 一些多算法场合。
  ② 解决一些非面向对象的语句块。
  ③ 适当使用内部类，使得代码更加灵活和富有扩展性。
  ④ 当某个类除了它的外部类，不再被其他的类使用时。
• 局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final
  因为生命周期不一致，局部变量直接存储在栈中，当方法执行结束后，非final的局部变量就被销毁，而局部内部类对局部变量的引用依然存在，如果局部内部类要调用局部变量时，就会出错。加了final，可以确保局部内部类使用的变量与外层的局部变量区分开，解决了这个问题。

==和equals的区别

• == ：它的作用是判断两个对象的地址是不是相等。即判断两个对象是不是同一个对象。（基本数据类型 == 比较的是值，引用数据类型 == 比较的是内存地址）
• equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：

• 情况1：类没有覆盖equals()方法。通过equals()比较该类的两个对象时，等价于通过==比较这两个对象。
• 情况2：类覆盖了equals()方法。一般我们都覆盖equals()方法来比较两个对象的内容是否相等，若它们的内容相等，则返回true（即认为这两个对象相等）。

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

hashCode与equals

• hashCode()介绍
  hashCode()的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode()定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode()函数。
  散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速地检索出对应的“值”。这其中就利用到了散列码。（可以快速找到所需要的对象）
• HashSet如何检查重复
  当把对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，同时也会与其他已经加入的对象的hashcode值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象，这时会调用equals()方法来检查hashcode相等的对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了equals的次数，相应就大大提高了执行速度。
• hashCode()与equals()的相关规定
  ① 如果两个对象相等，则hashcode一定也是相同的。
  ② 两个对象相等，对两个对象分别调用equals()方法都返回true。
  ③ 两个对象有相同的hashcode值，它们不一定是相等的。
  因此，equals()方法被覆盖过，则hashCode()方法也必须被覆盖。hashCode()的默认行为是对堆上的对象产生独特值，如果没有重写 hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）。

JDK中常用的包

• java.lang：这个是系统的基础类；
• java.io：这里面是所有输入输出有关的类，比如文件操作等；
• java.nio：为了完善 io 包中的功能，提高 io 包中性能而写的一个新包；
• java.net：这里面是与网络有关的类；
• java.util：这个是系统辅助类，特别是集合类；
• java.sql：这个是数据库操作的类。

BIO、NIO和AIO的区别

• 简答

• BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。
• NIO：Non IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。
• AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。

• 详细回答

• BIO (Blocking I/O): 同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
• NIO (New I/O): NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架，对应 java.nio 包，提供了 Channel , Selector，Buffer等抽象。NIO中的N可以理解为Non-blocking，不单纯是New。它支持面向缓冲的，基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。对于低负载、低并发的应用程序，可以使用同步阻塞I/O来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发
• AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。查阅网上相关资料，我发现就目前来说 AIO 的应用还不是很广泛，Netty 之前也尝试使用过 AIO，不过又放弃了。

Files的常用方法

• Files. exists()：检测文件路径是否存在。
• Files. createFile()：创建文件。
• Files. createDirectory()：创建文件夹。
• Files. delete()：删除一个文件或目录。
• Files. copy()：复制文件。
• Files. move()：移动文件。
• Files. size()：查看文件个数。
• Files. read()：读取文件。
• Files. write()：写入文件。

反射机制

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

• 静态编译和动态编译
  静态编译：在编译时确定类型，绑定对象。
  动态编译：运行时确定类型，绑定对象。
• 反射机制优缺点
  优点： 运行期类型的判断，动态加载类，提高代码灵活度。
  缺点： 性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多。
• 反射机制的应用场景

• 反射是框架设计的灵魂。
• 在我们平时的项目开发过程中，基本上很少会直接使用到反射机制，但这不能说明反射机制没有用，实际上有很多设计、开发都与反射机制有关，例如模块化的开发，通过反射去调用对应的字节码；动态代理设计模式也采用了反射机制，还有我们日常使用的Spring/Hibernate等框架也大量使用到了反射机制。
• 举例：①我们在使用JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序；②Spring框架也用到很多反射机制，最经典的就是xml的配置模式。Spring通过XML配置模式装载Bean的过程：1) 将程序内所有 XML或Properties配置文件加载入内存中；2) Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息；3) 使用反射机制，根据这个字符串获得某个类的class实例；4) 动态配置实例的属性。

• Java获取反射的三种方法
  ① 通过new对象实现反射机制。
  ② 通过路径实现反射机制。
  ③ 通过类名实现反射机制。

字符串常量池

字符串常量池位于堆内存中，专门用来存储字符串常量，可以提高内存的使用率，避免开辟多块空间存储相同的字符串，在创建字符串时 JVM 会首先检查字符串常量池，如果该字符串已经存在池中，则返回它的引用，如果不存在，则实例化一个字符串放到池中，并返回其引用。

String

• String的特性

• 不变性：String是只读字符串，是一个典型的immutable对象，对它进行任何操作，其实都是创建一个新的对象，再把引用指向该对象。不变模式的主要作用在于当一个对象需要被多线程共享并频繁访问时，可以保证数据的一致性。
• 常量池优化：String对象创建之后，会在字符串常量池中进行缓存，如果下次创建同样的对象时，会直接返回缓存的引用。
• final：使用final来定义String类，表示String类不能被继承，提高了系统的安全性。

• String str = “i”;与 String str = new String(“i”);一样吗？
  不一样，因为内存的分配方式不一样。String str="i"的方式，java 虚拟机会将其分配到常量池中；而 String str=new String(“i”) 则会被分到堆内存中。
• String s = new String(“xyz”);创建了几个字符串对象？
  两个对象，一个是静态区的"xyz"，一个是用new创建在堆上的对象。

String str1 = "hello"; //str1指向静态区
String str2 = new String("hello");  //str2指向堆上的对象
String str3 = "hello";
String str4 = new String("hello");
System.out.println(str1.equals(str2)); //true
System.out.println(str2.equals(str4)); //true
System.out.println(str1 == str3); //true
System.out.println(str1 == str2); //false
System.out.println(str2 == str4); //false
System.out.println(str2 == "hello"); //false
str2 = str1;
System.out.println(str2 == "hello"); //true

• String类的常用方法

• indexOf()：返回指定字符的索引。
• charAt()：返回指定索引处的字符。
• replace()：字符串替换。
• trim()：去除字符串两端空白。
• split()：分割字符串，返回一个分割后的字符串数组。
• getBytes()：返回字符串的 byte 类型数组。
• length()：返回字符串长度。
• toLowerCase()：将字符串转成小写字母。
• toUpperCase()：将字符串转成大写字符。
• substring()：截取字符串。
• equals()：字符串比较。

在使用HashMap的时候，用String做key的好处

HashMap内部实现是通过key的hashcode来确定value的存储位置，因为字符串是不可变的，所以当创建字符串时，它的hashcode被缓存下来，不需要再次计算，所以相比于其他对象更快。

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

• 可变性
  String类中使用字符数组保存字符串，private final char value[]，所以string对象是不可变的。StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，char[] value，这两种对象都是可变的。
• 线程安全性
  String中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
• 性能
  每次对String 类型进行改变的时候，都会生成一个新的String对象，然后将指针指向新的String 对象。StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StirngBuilder相比使用StringBuffer仅能获得10%~15%左右的性能提升，但却要冒多线程不安全的风险。

对于三者使用的总结
如果要操作少量的数据用String
单线程操作字符串缓冲区下操作大量数据用StringBuilder
多线程操作字符串缓冲区下操作大量数据用StringBuffer

包装类

Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型(wrapper class)，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

• 自动装箱与拆箱
  装箱：将基本类型用它们对应的引用类型包装起来。
  拆箱：将包装类型转换为基本数据类型。
• Java 为每个原始类型提供了包装类型

原始类型	包装类型
boolean	Boolean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double

• Integer a = 127与Integer b = 127相等吗？
  对于对象引用类型：== 比较的是对象的内存地址。
  对于基本数据类型：== 比较的是值。

public static void main(String[] args) {
    Integer a = new Integer(3);
    Integer b = 3;  // 将3自动装箱成Integer类型
    int c = 3;
    System.out.println(a == b); // false 两个引用没有引用同一对象
    System.out.println(a == c); // true a自动拆箱成int类型再和c比较
    System.out.println(b == c); // true

    Integer a1 = 128;
    Integer b1 = 128;
    System.out.println(a1 == b1); // false

    Integer a2 = 127;
    Integer b2 = 127;
    System.out.println(a2 == b2); // true
}

注：如果整型字面量的值在-128到127之间，那么自动装箱时不会new新的Integer对象，而是直接引用常量池中的Integer对象，超过范围 a1==b1的结果是false。