Java面试-Java基础

 

 

JDK和JRE的区别

• JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。
• JRE：Java Runtime Environment 的简称，Java 运行环境，为 Java 的运行提供了所需环境。

       包含关系如下：

==和equals的区别是什么

==

     ==对于基本类型和引用类型的作用效果是不同的，如下所示：

• 基本类型：比较的是值是否相同
• 引用类型：比较的是引用地址是否相同

equals

      equals本质上就是==，在Object中，equals方法比较的是引用地址是否相同，如下：

public class Object{
    public boolean equals(Object obj) {
        return (this == obj);
    }
    //...
}

     但是很多类重写了equals方法，变成了值比较，比如Integer、String等。如Integer的重写的equals方法如下：

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}

面向对象的特征

封装、继承、多态、抽象

多态好处

1. 可替换性:多态对已存在代码具有可替换性.
2. 可扩充性:增加新的子类不影响已经存在的类结构.
3. 接口性:多态是超类通过方法签名,向子类提供一个公共接口,由子类来完善或者重写它来实现的.
4. 灵活性
5. 简化性

代码中如何实现多态

实现多态主要有以下三种方式: 
1. 接口实现 
2. 继承父类重写方法 
3. 同一类中进行方法重载

java 创建对象的几种方式

1. 采用new
2. 通过反射
3. 采用clone
4. 通过序列化机制

两个对象的hashCode()相同，则equals()也一定为true吗

     两个对象的 hashCode() 相同，equals() 不一定 true。在散列表中，hashCode() 相等即两个键值对的哈希值相等，然而哈希值相等，并不一定能得出键值对相等。

java当中有哪四种引用？

强引用,软引用,弱引用,虚引用.不同的引用类型主要体现在GC上:

1. 强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象
2. 软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。
3. 弱引用：具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象
4. 虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。

final在Java中有什么用

• final 修饰的类叫最终类，该类不能被继承。
• final 修饰的方法不能被重写。
• final 修饰的变量叫常量，并且常量必须初始化，初始化之后值就不能被修改。

Java中的取整函数

• Math.floor(double d)

       floor表示地板的意思，向下取最接近的整数，如:

System.out.println(Math.floor(1.4));    //1.0
System.out.println(Math.floor(1.9));    //1.0
System.out.println(Math.floor(-2.4));   //-3.0
System.out.println(Math.floor(-2.9));   //-3.0

• Math.ceil(double d)

        ceil表示天花板的意思，向上取最接近的整数，如:

System.out.println(Math.ceil(1.4));    //2.0
System.out.println(Math.ceil(1.9));    //2.0
System.out.println(Math.ceil(-2.4));   //-2.0
System.out.println(Math.ceil(-2.9));   //-2.0

• Math.round(float/double x)

         对于正数四舍五入，对于负数五舍六入。如：

System.out.println(Math.round(1.4));  //1
System.out.println(Math.round(1.5));  //2
System.out.println(Math.round(-2.5)); //-2
System.out.println(Math.round(-2.6)); //-3

Java中的基本数据类型有哪些？

    Java中的基本数据类型有8种：byte、boolean、char、short、float、double、int、long。其他的都是引用数据类型

Java中操作字符串的类都有哪些？它们之间有什么区别

       有三种：String、StringBuffer、StringBuilder。详情见：https://blog.csdn.net/qq_35507234/article/details/96476324

• String与StringBuffer、StringBuilder区别

        String声明的是不可变的对象，每次操作都会生成新的对象，然后将对象指向新的String对象。 源码使用final修饰的。StringBuffer与StringBuilder封装可变的字符串。

• StringBuffer与StringBuilder

       StringBuffer 是线程安全的（把所有修改数据的方法都加上了synchronized），而 StringBuilder 是非线程安全的，但 StringBuilder 的性能却高于 StringBuffer，所以在单线程环境下推荐使用 StringBuilder，多线程环境下推荐使用 StringBuffer。

String str="i"与 String str=new String("i")一样吗？

不一样，因为内存的分配方式不一样。

String str="i"的方式，Java 虚拟机会将其分配到常量池中；而 String str=new String("i") 则会被分到堆内存中。

如何将字符串反转？

使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。

String 类的常用方法都有那些？

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

抽象类必须要有抽象方法吗？

抽象类不一定非要有抽象方法。但是抽象方法必须只能定义在抽象类中。

普通类和抽象类有哪些区别？

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

抽象类能使用 final 修饰吗？

不能，定义抽象类就是让其他类继承的，如果使用 final ，该类就不能被继承，这样就会产生矛盾，所以 final 不能修饰抽象类。如果使用final修饰，编译器会报错。

接口和抽象类有什么区别？

• 实现方式：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口。
• 构造函数：抽象类可以有构造函数；接口不能有。
• 实现数量：子类可以同时实现很多个接口，但是只能继承一个抽象类。接口可以extends多个接口，通过逗号分隔。
• 访问修饰符：接口中的方法默认使用 public abstract修饰，成员变量都是常量使用public static final修饰；抽象类中的变量和方法可以是任意访问修饰符。

讲讲类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字段，当 new 的时候， 他们的执行顺序。

此题考察的是类加载器实例化时进行的操作步骤（加载–>连接->初始化）。 顺序从上到下为：
父类静态代变量
父类静态代码块
子类静态变量
子类静态代码块
父类非静态变量（父类实例成员变量）
父类构造函数
子类非静态变量（子类实例成员变量） 
子类构造函数

请说说&与&&、|与||的区别

&&与||具有短路的效果。

• &与&&都要求运算符左右两端的布尔值都是true时，整个表达式的值才是true。但是如果&&左边的表达式的值为false时，右边的表达式就会直接被短路掉，不会进行运算了。如下所示：

public class Test {
    public static void main(String[] args) {
        int x = 1;
        if (x == 2 & ++x == 2) {} //++x==2会继续进行执行比较
        System.out.println(x);  //输出2
        int y = 1;
        if (y == 2 && ++y == 2) {}  //y==2为false，++y=2不会执行比较
        System.out.println(y);  //输出1
    }
}

• |与||同理与&和&&一样。|两端的表达式都会进行执行比较；如果||左端为true，右端表达式就不会执行比较了。如下：

public class Test {
    public static void main(String[] args) {
        int x = 1;
        if (x == 1 | ++x == 1) {} //++x==1会继续进行执行比较
        System.out.println(x);  //输出2
        int y = 1;
        if (y == 1 || ++y == 1) {}  //y==1为true，++y=1不会执行比较
        System.out.println(y);  //输出1
    }
}

 Java 中 IO 流分为几种？

• 按功能来分：输入流（input）、输出流（output）。
• 按类型来分：字节流和字符流。

throw 和 throws 的区别？

• throw：是真实抛出一个异常。
• throws：是声明可能会抛出一个异常。

final、finally、finalize 有什么区别？

• final：是修饰符，如果修饰类，此类不能被继承；如果修饰方法和变量，则表示此方法和此变量不能在被改变，只能使用。
• finally：是 try{} catch{} finally{} 最后一部分，表示不论发生任何情况都会执行，finally 部分可以省略，但如果 finally 部分存在，则一定会执行 finally 里面的代码。
• finalize： 是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法。

 try-catch-finally 中哪个部分可以省略？

try-catch-finally 其中 catch 和 finally 都可以被省略，但是不能同时省略，也就是说有 try 的时候，必须后面跟一个 catch 或者 finally。

try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

finally 一定会执行，即使是 catch 中 return 了，catch 中的 return 会等 finally 中的代码执行完之后，才会执行。

常见的异常类有哪些？

• NullPointerException 空指针异常
• ClassNotFoundException 指定类不存在
• NumberFormatException 字符串转换为数字异常
• IndexOutOfBoundsException 数组下标越界异常
• ClassCastException 数据类型转换异常
• FileNotFoundException 文件未找到异常
• NoSuchMethodException 方法不存在异常
• IOException IO 异常
• SocketException Socket 异常

如何实现对象克隆？

• 实现 Cloneable 接口并重写 Object 类中的 clone() 方法。
• 实现 Serializable 接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。

 深拷贝和浅拷贝区别是什么？

• 浅克隆：当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。
• 深克隆：除了对象本身被复制外，对象所包含的所有成员变量也将复制。

 

 

 

 

 

参考：https://gitbook.cn/books/5c6e1937c73f4717175f7477/index.html