【学习】Java基础整理（一）

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

  • 面向对象

    • 面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象，隐藏一切可以隐藏的东西，只向外界提供最简单的编程接口。

  • 继承

    • 从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类、超类、基类；得到继承信息的类被称为子类、派生类。

  • 封装

    • 把数据和方法绑定，只能通过已定义的接口访问数据。

  • 多态

    • 允许不同子类型的对象对同一消息作出不同的响应，就是用同样的对象引用调用同样的方法但是做了不同的事情。

2. 访问修饰符public,private,protected以及不写默认时有什么区别？

修饰符 当前类 同包 子类 其他包
public √ √ √ √
protected √ √ √ ×
default √ √ × ×
private √ × × ×

类的成员不写修饰符时默认为default。Java中，外部类的修饰符只能是public或default，类的成员（包含内部类）可以使用以上四种。

3. String是最基本的数据类型吗？

String不是基本数据类型。

基本数据类型：

  • byte、short、int、long、float、double、char、boolean；

其余为引用类型，枚举为特殊的引用类型。

4. float f=3.4;是否正确？

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

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 开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

基本数据类型 boolean char byte short int long float double
包装类型 Boolean Character Byte Short Integer Long Float Double

扩展 A

Integer a = new Integer(3); // 声明一个 Integer 类型的对象
Integer b = 3; // 将 3 自动装箱成 Integer 类型
int c = 3; // 声明一个 int整型的变量
System.out.println(a == b); // false 两个引用没有引用同一对象
System.out.println(a == c); // true a 自动拆箱成 int 类型再和 c比较

扩展 B

// 整形数字在-128到127之间时，不会new新的 Integer 对象，而是直接引用常量池中的 Integer 对象

Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
System.out.println(f1 == f2);// True
System.out.println(f3 == f4);// False

8. &和&&的区别

相同点

  • 二者都是在左右两端的布尔值为True时整个表达式才为True

不同点

  • &&为短路运算，当左侧布尔值为false时，右侧将直接被短路掉，不再判断

9. 解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法。

栈空间

  • 主管Java方法运行过程中所产生的值变量、运算结果、方法的调用与返回等信息。

堆空间

  • 通过new关键字和构造器创建的对象存储在堆空间，同时也是垃圾收集器管理的主要区域。

  • 堆空间还可以细分为新生代和老生代，再具体一点可以分为 Eden、Survivor（又可分为 From Survivor 和 To Survivor）、Tenured；

方法区

  • JVM 运行时数据区域的一块逻辑区域，是各个线程共享的内存区域。当虚拟机要使用一个类时，它需要读取并解析 Class 文件获取相关信息，再将信息存入到方法区。方法区会存储已被虚拟机加载的 类信息、字段信息、方法信息、常量、静态变量、即时编译器编译后的代码缓存等数据。
String str = new String("hello");

对于上面的语句，变量str放在栈上，用new创建出来的字符串对象放在堆上，而“hello”这个字面量是放在方法区中。

10. Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？

Java中四舍五入的原理是在参数上加0.5然后进行向下取整，所以：

  • Math.round(11.5) ：12
  • Math.round(-11.5) ：-11

11. switch 是否能作用在 byte 上，是否能作用在 long 上，是否能作用在 String 上？

Java5之前，支持 byte、short、char、int；

Java5开始加入了enum（枚举类型）

Java7加入了String

一直不支持long

12. 用最有效率的方法计算 a 乘以 8？

加减法操作的执行时间只占用1个时钟周期，是最快速的操作。 位运算与移位操作的执行速度和加减法接近。

乘法的执行时间要长一些，大概在5至6个时钟周期内完成。除法的执行速度最慢，大约需要50个时钟周期才能完成。

因此用移位操作替代乘法后，执行效率会快很多。

a*8 -> a<<3;
a*13 -> (a<<3)+(a<<2)+a;
a*31 -> (a<<5)-a;
// 除法只有当除数为2的n次幂时才可替代
a/8 -> a>>3;

13. 数组有没有 length()方法？String 有没有 length()方法？

数组没有 length()方法，有 length 的属性。String 有 length()方法。

String[] list = {"a","b","c"};
System.out.println(list.length);

String a = "apple";
System.out.println(a.length());

14. 在 Java 中，如何跳出当前的多重嵌套循环？

使用带标签的break和continue

label:
for (int i = 0; i < 3; ++i) {
    for (int j = 0; j < 3; ++j) {
        if (j == 2) {
            break label;
        }
        System.out.println("i:" + i + ",j:" + j);
    }
}

15. 构造器（constructor）是否可被重写（override）？

构造器（构造方法）不能被继承，因此不能被重写，但可以被重载。

16. 两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对？

hashcode 是一种编码方式，每个对象都会有一个 hashcode。

Java 对于 eqauls 方法和 hashCode 方法是这样规定的：

(1) 如果两个对象相同（equals 方法返回 true），那么它们的 hashCode 值一定要相同;

(2) 如果两个对象的 hashCode 相同，它们并不一定相同（equals 方法返回可能为 false可能为true）。

如果你违背了上述原则就会发现在使用容器时，相同的对象可以出现在 Set 集合中，同时增加新元素的效率会大大下降（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。

补充：

  • ‘==’:关系运算符，等号两端是基本数据类型时，判断两个值内容是否相等。两端是引用类型时，比较的是地址是否相等。
  • ‘equals’:基本类型无法使用，一般情况下比较的是对象中的值。

17. 是否可以继承 String 类？

String 类是 final 类，不可以被继承。

18. 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递？

是值传递。

Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时，参数的值是：“对该对象的引用“。对象的属性可以在被调用过程中被改变，但对对象引用的改变是不会影响到调用者的。

19. String 和 StringBuilder、StringBuffer 的区别？

Java 平台提供了两种类型的字符串：String 和 StringBuffer/StringBuilder，它们可以储存和操作字符串。

  • 其中 String 是只读字符串，也就意味着 String 引用的字符串内容是不能被改变的。

  • StringBuffer/StringBuilder 类表示的字符串对象可以直接进行修改。StringBuilder 是 Java 5 中引入的，它和 StringBuffer 的方法完全相同，区别在于StringBuilder是在单线程环境下使用的，因为它的所有方面都没有被synchronized 修饰，因此它的效率也比 StringBuffer 要高。

扩展

  1. 什么情况下用 ’+‘ 运算符进行字符串连接比调用 StringBuffer/StringBuilder 对象的 append 方法连接字符串性能更好？

当操作量小时，使用‘+‘或append对程序的时间消耗可以忽略不计，当操作频繁时不要使用’+‘，这是因为上文中提到的，String是只读字符串，重新赋值会重新开辟内存进行存储，降低程序运行效率。而append和insert方法只是在原有对象存储的内存地址上进行连续操作，减少了资源开销。同时，因为StringBuilder是单线程的，未使用synchronized关键字保证线程安全，进行拼接操作时会比存在线程切换操作的StringBuffer快，因此运行环境为单线程时，StringBuilder更快。

  1. String s1 = "Programming";
String s2 = new String("Programming");
String s3 = "Program";
String s4 = "ming";
String s5 = "Program" + "ming";
String s6 = s3 + s4;
System.out.println(s1 == s2);// false
System.out.println(s1 == s5);// true
System.out.println(s1 == s6);// false
System.out.println(s1 == s6.intern());// true 
System.out.println(s2 == s2.intern());// false

必备知识：

  1. java 程序在运行的时候,　会创建一个字符串缓冲池。对于诸如 String s1 ="Programming"; String s3 = "Program"; String s4 = "ming"; 这些字符串常量，程序首先会在这个 String缓冲池 中寻找相同值的对象。若它们在池中不存在，程序则将这些字符串常量创建于池中。若在池中找到了相同值得对象，则这个找到的对象的引用，就是新变量的引用。由此可见，字符串常量池中一个给定值得对象，最多只有一个。

  2. 用操作符 new 创建的字符串对象，如 String s2 = new String("Programming"); 或者有字符串变量、操作符 '+' 参与的表达式，如 String s6 = s3 + s4; 这样得到的引用，都要放到内存 堆(heap) 中保存。故，在堆中，若有几个值相同的对象，它们分别都会有各自的地址。

  3. 字符串的一个成员方法 public String intern() 返回字符串对象的规范化表示形式。当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。

    解释：

    1. 由必备知识 1、2 所示，s1 创建于字符串缓冲池，而 s2 创建于 内存(堆) 中，尽管二者内容都是"Programming"，但地址不在一个区 ，故比较地址的结果为 false 。

    2. 至于 String s5 = "Program" + "ming"; 的操作，由于表达式的两个算子都是字符串常量，所以操作始终在池内进行。在池内找到 "Program" 和 "ming"之后，将两者连接成 "Programming" ，然后，又在池内找到了相同值的对象s1，于是就将这个地址赋予 s5。因此，比较 s1 和 s5 的地址，当然相同，结果为 true。

    3. 如预备知识 1、２ 所示，s6 的地址，存在 堆 里。而 s1 的地址存在池里。尽管两者 值相同，但地址一定不同，结果为 false。

    4. 如预备知识 3 所示，因为 s6 调用了它的成员方法 intern()，结果返回了一个在池中的、具有相同值“Programming”的 对象s1的地址 。用它和 s1的地址相比较，当然相等，结果为 true。

    5. 如预备知识3所示，s2 的地址在 堆 里，s2.intern() 的地址在 池 里。一个在堆中，一个在池内，二者比较，肯定不等，结果为 false 。

    6. 写的代码是String s5 = "Program" + "ming"; 反编译对象的class文件看到的代码其实就是String s5 = "Programming"; 这是JDK做得优化

20. 重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

  • 重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载。重载对返回类型没有特殊的要求。
  • 重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。

21. 描述一下 JVM 加载 class 文件的原理机制？

JVM 中类的装载是由 类加载器（ClassLoader） 和它的子类来实现的，Java 中的类加载器是Java运行时环境（Java Runtime Environment）的一部分，负责动态加载Java类到Java虚拟机的内存空间中。

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

1)如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；

2)如果类中存在初始化语句，就依次执行这些初始化语句。

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

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

22. char 型变量中能不能存储一个中文汉字，为什么？

char 类型可以存储一个中文汉字，因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16 比特），所以放一个中文是没问题的。

补充：使用 Unicode 意味着字符在 JVM 内部和外部有不同的表现形式，在 JVM 内部都是 Unicode，当这个字符被从 JVM 内部转移到外部时（例如存入文件系统中），需要进行编码转换。所以 Java 中有字节流和字符流，以及在字符流和字节流之间进行转换的转换流，如 InputStreamReader 和 OutputStreamReader，这两个类是字节流和字符流之间的适配器类，承担了编码转换的任务；对于 C 程序员来说，要完成这样的编码转换恐怕要依赖于 union（联合体/共用体）共享内存的特征来实现了。

23. 抽象类（abstract class）和接口（interface）有什么异同？

抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现，否则该类仍然需要被声明为抽象类。接口比抽象类更加抽象，因为抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是 private、默认、protected、public 的，而接口中的成员全都是 public 的。抽象类中可以定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法。

24. 静态嵌套类(Static Nested Class)和内部类（Inner Class）的不同？

Static Nested Class 是被声明为静态（static）的内部类，它可以不依赖 于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化，其语法看起来挺诡异的，如下所示。

public class Poker {
    public inner1 getInner1(){
        return new inner1();
    }
	// 内部类
    public class inner1{
    }
    // 静态内部类
    public static class inner2{
    }
}

public class PokerTest {
    public static void main(String[] args) {
        // 合法的，静态内部类可以直接创建，不需要外部类对象
        Poker.inner2 in2 = new Poker.inner2(); 
        
        // 不合法，需要外部类对象才行
		Poker.inner1 in1 = new Poker.inner1(); 
        
        // 这样才能获得非静态内部类对象
        Poker poker = new Poker();
        Poker.inner1 in1 = poker.getInner1(); 
    }
}

25、Java 中会存在内存泄漏吗，请简单描述

理论上 Java 因为有垃圾回收机制（GC）不会存在内存泄露问题（这也是 Java 被广泛使用于服务器端编程的一个重要原因）；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被 GC 回收，因此也会导致内存泄露的发生。例如Hibernate 的 Session（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭（close）或清空（flush）一级缓存就可能导致内存泄露。下面例子中的代码也会导致内存泄露。

public class MyStack<T> {
    private T[] elements;
    private int size = 0;
    public T pop() {
        if(size == 0)
            throw new EmptyStackException();
        return elements[--size];
    }
}

MyStack为自定义栈类，pop实现了后进先出，当调用pop方法后，返回了当前栈空间中的最后进入对象，但其实该对象并没有被清空，而是仍旧存储在elements当中，并且无法被回收。

public Object pop() {
    if (0 == size)
        throw new EmptyStackException();
    Object result = elements[--size];
    //消除过期对象引用
    elements[size] = null;
    return result;
}

通过elements[size] = null;消除过期对象引用

26. 抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法（native），是否可同时被 synchronized修饰？

都不能。

  • 抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的 ；
  • 本地方法是由本地代码（如 C 代码）实现的方法，而抽象方法是没有实现的，也是矛盾的；
  • synchronized 和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。

27. 阐述静态变量和实例变量的区别。

  • 静态变量是被 static 修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个拷贝；
  • 实例变量必须依存于某一实例，需要先创建对象然后通过对象才能访问到它；
  • 静态变量可以实现让多个对象共享内存。

补充：在 Java 开发中，上下文类和工具类中通常会有大量的静态成员。

28. 是否可以从一个静态（static）方法内部发出对非静态（non-static）方法的调用？

不可以，静态方法只能访问静态成员，因为非静态方法的调用要先创建对象，再调用静态方法时可能对象并没有被初始化。

29. 如何实现对象克隆？

有两种方式：

  1. 实现 Cloneable 接口并重写 Object 类中的 clone()方法；
    • 该种克隆方式为浅克隆，当被克隆对象中存在引用对象时，无法克隆。
  2. 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

补充： Serializable是序列化，所谓序列化即是将对象以二进制的形式保存在你所需要的介质中，让其达到永久保存的目的。有序列化那么一定就有反序列化，不然光存不能取又有什么意义呢？ 所谓反序列化即是将序列化好的二进制内容获取并转换回对象的一个过程。

30. GC 是什么？为什么要有 GC？

GC 是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java 提供的 GC 功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java 语言没有提供释放已分配内存的显示操作方法。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc() 或Runtime.getRuntime().gc() ，但 JVM 可以屏蔽掉显示的垃圾回收调用。

垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。在 Java 诞生初期，垃圾回收是 Java最大的亮点之一，因为服务器端的编程需要有效的防止内存泄露问题，然而时过境迁，如今 Java 的垃圾回收机制已经成为被诟病的东西。移动智能终端用户通常觉得 iOS 的系统比 Android 系统有更好的用户体验，其中一个深层次的原因就在于 Android 系统中垃圾回收的不可预知性。

补充：垃圾回收机制有很多种，包括：分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式。标准的 Java 进程既有栈又有堆。栈保存了原始型局部变量，堆保存了要创建的对象。Java 平台对堆内存回收和再利用的基本算法被称为标记和清除，但是 Java 对其进行了改进，采用“分代式垃圾收集”。这种方法会跟 Java对象的生命周期将堆内存划分为不同的区域，在垃圾收集过程中，可能会将对象移动到不同区域：

  • 伊甸园（Eden）：这是对象最初诞生的区域，并且对大多数对象来说，这里是它们唯一存在过的区域。

  • 幸存者乐园（Survivor）：从伊甸园幸存下来的对象会被挪到这里。

  • 终身颐养园（Tenured）：这是足够老的幸存对象的归宿。年轻代收集（Minor-GC）过程是不会触及这个地方的。当年轻代收集不能把对象放进终身颐养园时，就会触发一次完全收集（Major-GC），这里可能还会牵扯到压缩，以便为大对象腾出足够的空间。

与垃圾回收相关的 JVM 参数：

  • -Xms / -Xmx — 堆的初始大小 / 堆的最大大小
  • -Xmn — 堆中年轻代的大小
  • -XX:-DisableExplicitGC — 让 System.gc()不产生任何作用
  • -XX:+PrintGCDetails — 打印 GC 的细节第 244 页 共 485 页
  • -XX:+PrintGCDateStamps — 打印 GC 操作的时间戳
  • -XX:NewSize / XX:MaxNewSize — 设置新生代大小/新生代最大大小
  • -XX:NewRatio — 可以设置老生代和新生代的比例
  • -XX:PrintTenuringDistribution — 设置每次新生代 GC 后输出幸存者乐园中对象年龄的分布
  • -XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold：设置老年代阀值的初始值和最大值
  • -XX:TargetSurvivorRatio：设置幸存区的目标使用率

31. String s = new String(“xyz”);创建了几个字符串对象？

两个对象。

一个是静态区（方法区）的”xyz”，一个是用 new 创建在堆上的对象。

32. 接口是否可继承（extends）接口？抽象类是否可实现（implements）接口？抽象类是否可继承具体类（concreteclass）？

  • 接口可以继承接口，而且支持多重继承；
  • 抽象类可以实现(implements)接口，抽象类可继承具体类也可以继承抽象类。

33. 一个”.java”源文件中是否可以包含多个类（不是内部类）？有什么限制？

可以，但一个源文件中最多只能有一个公开类（public class）而且文件名必须和公开类的类名完全保持一致。

34. Anonymous Inner Class(匿名内部类)是否可以继承其它类？是否可以实现接口？

可以继承其他类或实现其他接口，在 Swing 编程和 Android 开发中常用此方式来实现事件监听和回调。

35. 内部类可以引用它的包含类（外部类）的成员吗？有没有什么限制

一个内部类对象可以访问创建它的外部类对象的成员，包括私有成员。

36. Java 中的 final 关键字有哪些用法？

  1. 修饰类：表示该类不能被继承；
  2. 修饰方法：表示方法不能被重写；
  3. 修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

37. 指出下面程序的运行结果

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。

创建对象时构造器的调用顺序是：先初始化静态成员，然后调用父类构造器，再初始化非静态成员，最后调用自身构造器。

38. 数据类型之间的转换：

  1. 如何将字符串转换为基本数据类型？

    • String a = "123";
Integer.parseInt(a);
Integer.valueOf(a);

  2. 如何将基本数据类型转换为字符串？

    • int a = 3;
String b = a + "";

    • int a = 3;
String.valueOf(a);

39. 如何实现字符串的反转及替换？

方法很多，可以自己写实现也可以使用 String 或 StringBuffer/StringBuilder 中的方法。

StringBuffer方法：

new StringBuffer("abc").reverse().toString();

递归实现：

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

40. 怎样将 GB2312 编码的字符串转换为 ISO-8859-1 编码的字符串？

String s1 = "你好";
String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");

41. 日期和时间

如何取得年月日、小时分钟秒？

Calendar cal = Calendar.getInstance();
System.out.println(cal.get(Calendar.YEAR)); // 年
System.out.println(cal.get(Calendar.MONTH));// 月 0-11
System.out.println(cal.get(Calendar.DATE)); // 日
System.out.println(cal.get(Calendar.HOUR_OF_DAY)); //时
System.out.println(cal.get(Calendar.MINUTE)); // 分
System.out.println(cal.get(Calendar.SECOND)); // 秒
// 或
LocalDateTime dt = LocalDateTime.now(); 
System.out.println(dt.getYear());       // 年
System.out.println(dt.getMonthValue()); // 月 1-12
System.out.println(dt.getDayOfMonth()); // 日
System.out.println(dt.getHour());       // 时
System.out.println(dt.getMinute());     // 分
System.out.println(dt.getSecond());     // 秒

如何取得从 1970 年 1 月 1 日 0 时 0 分 0 秒到现在的毫秒数？

Calendar.getInstance().getTimeInMillis(); // 方法一
System.currentTimeMillis();               // 方法二
Clock.systemDefaultZone().millis();       // 方法三 Java 8

如何取得某月的最后一天？

Calendar time = Calendar.getInstance();
time.getActualMaximum(Calendar.DAY_OF_MONTH);

如何格式化日期？

SimpleDateFormat oldFormatter = new SimpleDateFormat("yyyy/MM/dd");
Date date1 = new Date();
System.out.println(oldFormatter.format(date1));
// Java 8
DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
LocalDate date2 = LocalDate.now();
System.out.println(date2.format(newFormatter));

补充：Java 的时间日期 API 一直以来都是被诟病的东西，为了解决这一问题，Java8 中引入了新的时间日期 API，其中包括 LocalDate、LocalTime、LocalDateTime、Clock、Instant 等类，这些的类的设计都使用了不变模式，因此是线程安全的设计。

42. 打印昨天的当前时刻

Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, -1);
System.out.println(cal.getTime());
// Java8
LocalDateTime today = LocalDateTime.now();
LocalDateTime yesterday = today.minusDays(1);
System.out.println(yesterday);

43. 比较一下 Java 和 JavaSciprt

JavaScript 与 Java 是两个公司开发的不同的两个产品。Java 是原 Sun Microsystems 公司（已被甲骨文收购）推出的面向对象的程序设计语言，特别适合于互联网应用程序开发；而 JavaScript 是 Netscape 公司的产品，为了扩展 Netscape 浏览器的功能而开发的一种可以嵌入 Web 页面中运行的基于对象和事件驱动的解释性语言。JavaScript 的前身是 LiveScript；而 Java 的前身是 Oak 语言。

最重要的区别是一个是静态语言（Java），一个是动态语言（JavaScript）。目前的编程语言的发展趋势是函数式语言和动态语言。在 Java中类（class）是一等公民，而 JavaScript 中函数（function）是一等公民，因此 JavaScript 支持函数式编程，可以使用 Lambda函数和闭包（closure，将函数内部和函数外部连接起来，外部能够读取内部的变量），当然 Java 8 也开始支持函数式编程，提供了对 Lambda表达式以及函数式接口的支持。

44. 什么时候用断言（assert）？

断言在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。一般来说，断言用于保证程序最基本、关键的正确性。断言检查通常在开发和测试时开启。为了保证程序的执行效率，在软件发布后断言检查通常是关闭的。断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true；如果表达式的值为false，那么系统会报告一个 AssertionError。

要使断言生效，必须在VM Options里新增添加-ea，在idea中，run -> edit configuration -> VM Options

int i = -1;
//如果i < 0 就会抛出异常
assert i > 0 : "需要输入大于零";
System.out.println(i);

// 输出
Exception in thread "main" java.lang.AssertionError: 需要输入大于零
	at main(Hello.java:16)

45. Error 和 Exception 有什么区别？

Error 表示系统级的错误和程序不必处理的异常，是可以恢复但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况；（比如不能迅速收敛的递归）

Exception 表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况。

46. try{}里有一个 return 语句，那么紧跟在这个 try 后的finally{}里的代码会不会被执行，什么时候被执行，在 return前还是后

会执行，在方法返回调用者前执行。分以下三种情况：

  1. 如果finally中有return语句，则会将try中的return语句”覆盖“掉，直接执行finally中的return语句；
  2. 如果finally中没有return语句，也没有改变要返回值，则执行完finally中的语句后接着执行try中的return语句；
  3. 如果finally中没有return语句，但是改变了要返回的值，分以下两种情况：
    • 如果return的是基本数据类型，则在finally中对值的改变不起作用，try中的return语句依然会返回之前保留的值；
    • 如果return的是引用类型，而在finally中修改该引用类型的属性值，try中return语句返回的对象，属性值是finally中改变后的属性值。

补充：在 finally 中改变返回值的做法是不好的，因为如果存在 finally 代码块，try中的 return 语句不会立马返回调用者，而是记录下返回值待 finally 代码块执行完毕之后再向调用者返回其值，显然，如果在 finally 中返回或者修改返回值会对程序造成很大的困扰。

47. Java 语言如何进行异常处理，关键字：throws、throw、try、catch、finally 分别如何使用？

Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在 Java 中，每个异常都是一个对象，它是 Throwable 类或其子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并可以对其进行处理。Java 的异常处理是通过 5 个关键词来实现的：try、catch、throw、throws 和 finally。

一般情况下是用 try 来执行一段程序，如果系统会抛出（throw）一个异常对象，可以通过它的类型来捕获（catch）它，或通过总是执行代码块（finally）来处理；try 用来指定一块预防所有异常的程序；catch 子句紧跟在 try 块后面，用来指定你想要捕获的异常的类型；throw 语句用来明确地抛出一个异常；throws 用来声明一个方法可能抛出的各种异常（当然声明异常时允许无病呻吟）；finally 为确保一段代码不管发生什么异常状况都要被执行；try 语句可以嵌套，每当遇到一个 try 语句，异常的结构就会被放入异常栈中，直到所有的 try 语句都完成。如果下一级的try 语句没有对某种异常进行处理，异常栈就会执行出栈操作，直到遇到有处理这种异常的 try 语句或者最终将异常抛给 JVM。

48. 运行时异常与受检异常有何异同？

  • 运行时异常：表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误，只要程序设计得没有问题通常就不会发生。
  • 受检异常：跟程序运行的上下文环境有关，即使程序设计无误，仍然可能因使用的问题而引发。Java编译器要求方法必须声明抛出可能发生的受检异常，但是并不要求必须声明抛出未被捕获的运行时异常。

异常和继承一样，是面向对象程序设计中经常被滥用的东西，在Effective Java书中对异常的使用给出了以下指导原则

  • 不要将异常处理用于正常的控制流（设计良好的 API 不应该强迫它的调用者为了正常的控制流而使用异常）
  • 对可以恢复的情况使用受检异常，对编程错误使用运行时异常
  • 避免不必要的使用受检异常（可以通过一些状态检测手段来避免异常的发生）
  • 优先使用标准的异常
  • 每个方法抛出的异常都要有文档
  • 保持异常的原子性（对象仍然保持在一种定义良好的可用状态之中，这样就可以从异常中进行恢复）
  • 不要在 catch 中忽略掉捕获到的异常

49. 列出一些你常见的运行时异常？

  • ArithmeticException（算术异常，运行时异常）
  • ClassCastException （类转换异常，运行时异常）
  • IllegalArgumentException （非法参数异常，运行时异常）
  • IndexOutOfBoundsException （下标越界异常，运行时异常）
  • NullPointerException （空指针异常，运行时异常）
  • SecurityException （安全异常，受检异常）

50. 阐述 final、finally、finalize 的区别

  • final：修饰符（关键字）有三种用法：
    • 如果一个类被声明为 final，意味着它不能再派生出新的子类，即不能被继承，因此它和 abstract 是反义词；
    • 将变量声明为 final，可以保证它们在使用中不被改变，被声明为 final 的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改；
    • 被声明为 final 的方法也同样只能使用，不能在子类中被重写。
  • finally：通常放在 try…catch…的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要 JVM 不关闭都能执行，可以将释放外部资源的代码写在 finally 块中；
  • finalize：Object 类中定义的方法，Java 中允许使用 finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写 finalize()方法可以整理系统资源或者执行其他清理工作。
posted @ 2022-12-09 23:34  小拳头呀  阅读(74)  评论(0)  编辑  收藏  举报