Java面试题—基础（一）

1. 标题面向对象的特征有哪些方面？

   • 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。
   • 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的
     延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎宏博士的《Java与模式》或《设计模式精解》中关于桥梁模式的部分）。
   • 封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编
     写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口（可以想想普通洗衣机
     和全自动洗衣机的差别，明显全自动洗衣机封装更好因此操作起来更简单；我们现在使用的智能手机也是封装得足够好的，因为几个按键就搞定了所有的事情）。
   • 多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务，那么运行时的多态性可以解释为：当A系统访问B系统提供的服务时，B系统有多种提供服务的方式，但一切对A系统来说都是透明的（就像电动剃须刀是A系统，它的供电系统是B系统，B系统可以使用电池供电或者用交流电，甚至还有可能是太阳能，A系统只会通过B类对象调用供电的方法，但并不知道供电系统的底层实现是什么，究竟通过何种方式获得了动力）。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：
     • 方法重写（子类继承父类并重写父类中已有的或抽象的方法）；
     • 对象造型（用父类型引用引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

2. 访问修饰符public,private,protected,以及不写（默认）时的区别？

   修饰符	当前类	同包	子类	其他包
   public	√	√	√	√
   protected	√	√	√	x
   default(friendly)	√	√	x	x
   private	√	x	x	x

   当前类：如果是讨论的是内部类，则当前类指的是其最外层外部类的所有作用域
   子类：包括子类所有的作用域，包括子类的所有内部类

3. ** String 是最基本的数据类型吗？**
   不是，Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型(primitive type)剩下的都是引用类型(reference type)，注意：枚举、注解类型都是引用类型。

4. float f=3.4;是否正确？
   答:不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F(f)。

5. short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？
   对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。

6. Java有没有goto？
   goto 是Java中的保留字，在目前版本的Java中没有使用。（根据James Gosling（Java之父）编写的《The Java Programming Language》一书的附录中给出了一个Java关键字列表，其中有goto和const，但是这两个是目前无法使用的关键字，因此有些地方将其称之为保留字，其实保留字这个词应该有更广泛的意义，因为熟悉C语言的程序员都知道，在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留字）

7. int和Integer有什么区别？
   Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。
   Java 为每个原始类型提供了包装类型：

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

   实例：

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

   自动装装箱/拆箱原理：

   • 装箱：WrapType.valueOf(primitiveValue)，例如：Integer.valueOf(),Long.valueOf()
   • 拆箱：WrapType.primitiveTypeValue，Integer.intValue，Long.longValue()

   以上转换在编译阶段完成，通过查看字节码可以习得
   一个面试题，也是和自动装箱和拆箱有点关系的，代码如下所示：

    public static void main(String[] args) {
   	 Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
   	 System.out.println(f1 == f2);
   	 System.out.println(f3 == f4);
    }
   

   如果不明就里很容易认为两个输出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用，所以下面的==运算比较的不是值而是引用。装箱的本
   质是什么呢？当我们给一个Integer对象赋一个int值的时候，会调用Integer类的静态方法valueOf，如果看看valueOf的源代码就知道发生了什么。

    public static Integer valueOf(int i) {
    	if (i >= IntegerCache.low && i <= IntegerCache.high)
    	return IntegerCache.cache[i + (-IntegerCache.low)];
    	return new Integer(i);
    }
   

   IntegerCache是Integer的内部类，其代码如下所示：

   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) {
   		 try {
   				 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);
   			 } catch( NumberFormatException nfe) {
   			 // If the property cannot be parsed into an int, ignore it.
   		 	}
   		 }
   		 high = h;
   		 cache = new Integer[(high - low) + 1];
   		 int j = low;
   		 for(int k = 0; k < cache.length; k++)
   		 cache[k] = new Integer(j++);
   		 // range [-128, 127] must be interned (JLS7 5.1.7)
   		 assert IntegerCache.high >= 127;
   	 }
   	 private IntegerCache() {}
    }
   

   不难发现，如果整型字面量的值在-128到127之间，那么不会new新的Integer对象，而是直接引用常量池中的Integer对象，所以上面的面试题中f1==f2的结果是true，而f3==f4的结果是false。

8. &和&&的区别？
   &运算符有两种用法：(1)按位与；(2)逻辑与。&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为，如果&&左边的表达式的值是false，右边的表达式会被直接短路掉，不会进行运算。很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是null而且不是空字符串，应当写为：username != null &&!username.equals("")，二者的顺序不能交换，更不能用&运算符，因为第一个条件如果不成立，根本不能进行字符串的equals比较，否则会产生NullPointerException异常。注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。

9. Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？
   答：Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。
   11.** swtich 是否能作用在byte 上，是否能作用在long 上，是否能作用在String上？**
   在Java 5以前，switch(expr)中，expr只能是byte、short、char、int。从Java 5开始，Java中引入了枚举类型，expr也可以是enum类型，从Java 7开始，expr还可以是字符串
   （String），但是长整型（long）在目前所有的版本中都是不可以的。

10. 用最有效率的方法计算2乘以8？
    2 << 3（左移3位相当于乘以2的3次方，右移3位相当于除以2的3次方）。 补充：我们为编写的类重写hashCode方法时，可能会看到如下所示的代码，其实我们不太理解为什么要使用这样的乘法运算来产生哈希码（散列码），而且为什么这个数是个素数，
    为什么通常选择31这个数？前两个问题的答案你可以自己百度一下，选择31是因为可以用移位和减法运算来代替乘法，从而得到更好的性能。说到这里你可能已经想到了：31 * num 等价于(num << 5) - num，左移5位相当于乘以2的5次方再减去自身就相当于乘以31，现在的VM都能自动完成这个优化。

11. 数组有没有length()方法？String有没有length()方法？
    数组没有length()方法，有length 的属性。String 有length()方法。JavaScript中，获得字符串的长度是通过length属性得到的，这一点容易和Java混淆。

12. 在Java中，如何跳出当前的多重嵌套循环？
    在最外层循环前加一个标记如A，然后用break A;可以跳出多重循环。（Java中支持带标签的break和continue语句，作用有点类似于C和C++中的goto语句，但是就像要避免使用
    goto一样，应该避免使用带标签的break和continue，因为它不会让你的程序变得更优雅，很多时候甚至有相反的作用，所以这种语法其实不知道更好）

13. 构造器（constructor）是否可被重写（override）？
    构造器不能被继承，因此不能被重写，但可以被重载。

14. 两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对？
    不对，如果两个对象x和y满足x.equals(y) == true，它们的哈希码（hash code）应当相同。Java对于eqauls方法和hashCode方法是这样规定的：(1)如果两个对象相同（equals方
    法返回true），那么它们的hashCode值一定要相同；(2)如果两个对象的hashCode相同，它们并不一定相同。如果违背了上述原则就会发现在使用容器时，相同的对象可以出现在Set集合中，同时增加新元素的效率会大大下降（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。
    equals方法需要满足以下原则：

    • 自反性：x.equals(x)必须返回true
    • 对称性：x.equals(y)返回true时，y.equals(x)也必须返回true
    • 传递性：x.equals(y)和y.equals(z)都返回true时，x.equals(z)也必须返回true）
    • 一致性：当x和y引用的对象信息没有被修改时，多次调用x.equals(y)应该得到同样的返回值），而且对于任何非null值的引用x，x.equals(null)必须返回false。

    实现高质量的equals方法的诀窍和注意点

    • 使用==操作符检查"参数是否为这个对象的引用"；
    • 使用instanceof操作符检查"参数是否为正确的类型"；
    • 对于类中的关键属性，检查参数传入对象的属性是否与之相匹配；
    • 编写完equals方法后，问自己它是否满足对称性、传递性、一致性；
    • 重写equals时总是要重写hashCode；
    • 不要将equals方法参数中的Object对象替换为其他的类型，在重写时不要忘掉@Override注解。

15. 是否可以继承String类？
    答：String 类是final类，不可以被继承。
    补充：继承String本身就是一个错误的行为，对String类型最好的重用方式是关联关系（Has-A）和依赖关系（Use-A）而不是继承关系（Is-A）。

16. 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？
    是值传递，Java语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变，但对形参的引用的改变是不会影响到调用者的传递的那个参数的引用。C++和C#中可以通过传引用或传输出参数来改变传入的参数的值。

17. String、StringBuffer、StringBuilder区别，字符串常量池
    String类是不可变字符串，实例一旦被创建，内部的值是不可修改的，执行某些方法(substring、replace、contact等)或者“+”操作产生的“改变”都会产生新对象(对象本身不变化，改变是真真切切的改变，当预期产生的字符串与本身字面量相等时会返回本身，可以查看substring、replace、contact源码了解)
    StringBuffer、StringBuilder都是可变化的字符串，可以后追加、插入、前追加、删除字符，不会产生新的对象，不同的是前者是线程安全的，后者是线程不安全的，在没有线程安全隐患的场景是使用StringBuilder，多线程操作共享字符串时使用StringBuffer。
    常量池：直接在程序中定义的字面量字符串，编译时会被存入类常量池，运行时会被加载到运行时常量池，直接用字符串相同字面量赋值的变量指向的时同一份引用，执行equals为true，只有字面常量使用“+”拼接的字符串，编译时会预先替换为拼接好的值(如：String a =“hello,”+ "world"等价于String a =“hello,world”)；如果“+”拼接的字符串包含局部变量、属性、对象、基本类型常量或者执行方法，编译时会用StringBuilder进行append，这时即使最终结果一样，创建的也不是同一个对象。
    JDK对字符串“+”拼接编译优化：

    • 字符串拼接从jdk5开始就已经完成了优化，并且没有进行新的优化。
    • 循环内String+变量的话会每次new一个StringBuilder，再调用append方法。
    • 循环外字符串拼接可以直接使用String的+操作，一条语句创建一个StringBuilder，相关的多条“+”语句不会优化 。

    有循环体的话，好的做法是在循环外声明StringBuilder对象，在循环内进行手动append，不论循环多少层都只有一个StringBuilder对象)。

    String.intern方法
    intern方法显式操作字符串常量池的的方法，判断常量池中是否有与当前字符串equals的字符串，没有则将当前字符串放入常量池，不同的JDK版本处理方式不同。
    JDK1.6:判断如果常量池有与之相等的字符串，则返回常量池的字符串对象引用，如果没有则把当前字符串复制到常量池中，然后返回常量池的字符串对象引用
    JDK1.7+:判断如果常量池有与之相等的字符串，则返回常量池的字符串对象引用，如果在常量池中记录当前字符串的引用，然后返当前字符串对象引用
    之所以会有这种差异，是因为JDK1.7后常量池中放的不是字符串本身，而是引用，而且自1.7之后，常量池从方法区(Hotspot称PermGen space)中移动到其他区域，1.7移动到堆中，1.8移动到元空间(MetaSpace)

18. 重载(Overload)和重写(Override)的区别。重载的方法能否根据返回类型进行区分？
    方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常(里氏代换原则)。重载对返回类型没有特殊的要求。
    思考：为什么不能根据返回类型来区分重载？

19. 描述一下JVM加载class文件的原理机制？
    JVM中类的装载是由类加载器(ClassLoader)和它的子类来实现的，Java中的类加载器是一个重要的Java运行时系统组件，它负责在运行时查找和装入类文件中的类。

    由于Java的跨平台性，经过编译的Java源程序并不是一个可执行程序，而是一个或多个类文件。当Java程序需要使用某个类时，JVM会确保这个类已经被加载、连接(验证、准备和解析)和初始化。类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class文件，然后产生与所加载类对应的Class对象。加载完成后，Class对象还不完
    整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备(为静态变量分配内存并设置默认的初始值)和解析(将符号引用替换为直接引用)三个步骤。最后JVM对类进行初始化，包括

    • 如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；
    • 如果类中存在初始化语句，就依次执行这些初始化语句。

    ---

    类的加载是由类加载器完成的， 类加载器包括：根加载器(BootStrap)、扩展加载器(Extension)、系统加载器(System)和用户自定义类加载器(java.lang.ClassLoader的子类)。从Java2(JDK1.2)开始，类加载过程采取了父亲委托机制(PDM)。PDM更好的保证了Java平台的安全性，在该机制中，JVM自带的Bootstrap是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对Bootstrap的引用。下面是关于几个类加载器的说明：

    • Bootstrap：一般用本地代码实现，负责加载JVM基础核心类库(rt.jar)；
    • Extension：从java.ext.dirs系统属性所指定的目录中加载类库，它的父加载器是Bootstrap
    • System：又叫应用类加载器，其父类是Extension。它是应用最广泛的类加载器。它从环境变量classpath或者系统属性java.class.path所指定的目录中记载类，是用户自定义加载器的默认父加载器。

20. char 型变量中能不能存贮一个中文汉字，为什么？
    char类型可以存储一个大部分的中文汉字，因为Java中char使用的编码是Unicode,一个char类型占2个字节(16比特)，当Unicode的码值小于0xFFFF时一个char是可以存储的，此时char的二进制值跟unicode码值一一对应，当码值大于0xFFFF时2个字节的char就无法表示，此时需要4个字节来表示，编码方式为UTF-16，Unicode的码值小于0xFFF的编码表示方式是UTF-16的子集，可以说Java中字符串的内部编码是UTF-16。有一些汉字的码值大于0xFFFF(Unicode2.0扩展时收录的，不常用，多为一些异体字和生僻字)，因此这部分汉字需要“两个char”表示，这样的字符只能用字符串表示，因为字符串内部存储的是char数组。比如“?”，就不能用char存储，char c = '?’是会编译错的，因为它相当于char c = ‘\uD869\uDEA5’,char只能存储一个字符。
    补充：编码UTF-8/16/32、ASCII、GBK

21. 抽象类(abstract class)和接口(interface)有什么异同？
    抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的变量或属性。
    一个非抽象类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。

    接口比抽象类更加抽象，抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器，方法的限制受Java版本影响，Java7-只能定义抽象方法，java8+可以定义默认实现具体方法，Java9+可以定义私有方法。

    抽象类中的成员可以是private、default(不修饰)、protected、public的，而接口中的成员全都是public的。抽象类中可以定义成 员变量，而接口中定义只能定义静态常量(默认添加static final修饰)。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。

22. 如何实现对象克隆？
    1. 实现Cloneable接口并重写Object类中的clone()方法，Object中的clone方法是浅度克隆，引用类型的属性不会克隆；
    2. 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

    • 实现Cloneable接口
      Cloneable是一个标记接口，表示对象具有clone能力；Object类里面有一个clone方法，protected native修饰，本地方法底层用C实现。

      protected native Object clone() throws CloneNotSupportedException;
      

      定义一个其对象可克隆的类，在实现了Cloneable接口之后，如果要把clone方法暴露出去，需要重写clone方法，提升访问权限为public，一般地，复写clone方法直接调用super.clone()即可，但是Object的clone只是浅复制，如果想深度复制，需要自行实现引用类型属性的复制，重写clone就显得很有必要了。我们看到Object中的clone方法声明抛出CloneNotSupportedException，如果类没有实现Cloneable接口，就会抛出这种异常。
      示例：

      public class Student implements Cloneable {
          private String name;//引用类型复制的引用
          private int age; //基本类型复制的值
          private Teacher teacher;//引用类型，需要特殊处理
      
          public Student(String name, int age) {
              this.name = name;
              this.age = age;
          }
      
          @Override
          protected Student clone() throws CloneNotSupportedException {
              Student student = (Student) super.clone();
              student.teacher = this.teacher.clone();//调用自身的clone方法，实现深度克隆
              student.name = new String(name.getBytes());//其实可以不用，因为String对象是不可变的
              return student;
          }
      }
      
      class Teacher implements Cloneable {
      
          private int classesCount;//基本类型复制的值
      
          public Teacher(int classesCount) {
              this.classesCount = classesCount;
          }
      
          @Override
          protected Teacher clone() throws CloneNotSupportedException {
              Teacher teacher = (Teacher) super.clone();
              return teacher;
          }
      }
      
      

      Object.clone与new是的区别：前者是直接复制对象的内存单元，效率较高，后者需要重新执行一边对象的创建过程(分配内存，属性初始化为0，执行构造方法)，一般情况下后者比较耗时。

    • 实现Serializable接口，利用序列化机制实现
      序列化是将内存对象转化为二进制序列的过程，用于存储、传输、远程调用。
      由于序列化是属性深层递归的，因此可以实现深度克隆，但是要求需要深层clone的对象实现Serializable接口，像一些资源类的对就不能序列化(Socket、Connection，当然这些也不在克隆的考虑之列)。
      扩展：序列化

23. 接口是否可继承（extends）接口？抽象类是否可实现（implements）接口？抽象类是否可继承具体类（concrete class）？
    接口可以继承接口，而且支持多重继承。抽象类可以实现(implements)接口，抽象类可继承具体类也可以继承抽象类。

24. 一个".java"源文件中是否可以包含多个类（不是内部类）？有什么限制？
    可以包含多个顶层类，但一个源文件中最多只能有一个公开类（public class）而且文件名必须和公开类的类名完全保持一致。

25. Anonymous Inner Class(匿名内部类)是否可以继承其它类？是否可以实现接口？
    可以继承其他类或实现其他接口，匿名类没有构造方法，但是可以在定义时调用父类构造方法(new SuperClass(args…){…}))。

26. Java 中的final关键字有哪些用法？
    final表示不可“再次操作”的意思

    • 修饰类：表示该类不能被继承；
    • 修饰方法：表示方法不能被重写；
    • 修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。
    • 修饰属性：表示属性只能初始化一次。

27. 下面程序的运行结果

    class A {
        static {
            System.out.print("1");
        }
    
        public A() {
            System.out.print("2");
        }
    }
    
    class B extends A {
        static {
            System.out.print("a");
        }
        public B() {
            System.out.print("b");
        }
    }
    
    public class Hello {
        public static void main(String[] args) {
            A ab = new B();
            ab = new B();
        }
    }
    

    执行结果：1a2b2b，在类未初始化的情况下，创建对象时会首先初始化类，然后调用构造方法，初始化类的时候如果父类未初始化则先初始化父类，在初始化当前类，调用构造方法时先调用父类的构造方法。存在多级继承的情况，则最先初始化顶级未初始化的类，然后逐级向下。构造方法则从Object类逐级向下执行。
    口诀：先静态再构造，先父类再自身

28. 字符串和基本数据类型的相互转换
    字符串转基本数据类型：对应的包装类中的方法parseXXX(String)、valueOf(String)；

    基本类型转字符串：基本类型+""、String.valueOf(基本类型)、基本类型转包装类型.toString()

29. 如何实现字符串的反转及替换？
    用StringBuffer/StringBuilder中的reverse方法。
    自己写代码实现：

    1. 递归

       public static String reverse(String originStr) {
           if (originStr == null || originStr.length() <= 1) return originStr;
           return reverse(originStr.substring(1)) + originStr.charAt(0);
       }
       

    2. 字符数组逆序方式

       public static String reverse(String originStr) {
          char[] chars = originStr.toCharArray();
          for (int i = 0; i < chars.length / 2; i++) {
              int j = chars.length - 1 - i;
              char ci = chars[i];
              char cj = chars[j];
              chars[i] = cj;
              chars[j] = ci;
          }
          return new String(chars);
       }
       

    以上两的方式不仅效率低下，且都不能解决UTF-16代理对的问题，当Unicode编码大于0xFFFF时需要用两个代理对表示字符时，就会出现高低代理对顺序颠倒的问题，导致与预期的结果不一致，建议还是使用StringBuilder/StringBuffer。StringBuilder、StringBuffer都继承了AbstractStringBuilder，reverse方法在AbstractStringBuilder中实现：

      public AbstractStringBuilder reverse() {
        boolean hasSurrogates = false;
        int n = count - 1;
        for (int j = (n-1) >> 1; j >= 0; j--) {
            int k = n - j;
            char cj = value[j];
            char ck = value[k];
            value[j] = ck;
            value[k] = cj;
            if (Character.isSurrogate(cj) ||
                Character.isSurrogate(ck)) {
                hasSurrogates = true;
            }
        }
        if (hasSurrogates) {
            reverseAllValidSurrogatePairs();
        }
        return this;
    }
    
    /** Outlined helper method for reverse() */
    private void reverseAllValidSurrogatePairs() {
        for (int i = 0; i < count - 1; i++) {
            char c2 = value[i];
            if (Character.isLowSurrogate(c2)) {
                char c1 = value[i + 1];
                if (Character.isHighSurrogate(c1)) {
                    value[i++] = c1;
                    value[i] = c2;
                }
            }
        }
    }
    

    先正常逆序，并在过程中判断是否又代理对，结束后如果有代理对，则低位和高位交互位置。

30. 阐述静态变量和实例变量的区、静态方法和实例方法的区别
    静态变量是被static修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个值或实例，静态变量是全局共享的。

    实例变量必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。

    静态方法也是属于类的，实例(成员)方法是属于实例的，静态方法(静态块)不能访问非静态的属性和方法，实例方法可以方法静态方法和属性。