关闭
您当前的位置:首页 > 职场资讯 > java后端面试秘籍

JavaSE 基础面试题

来源:商丘人才网_商丘招聘网_商丘人才市场_豫商人才网招聘平台 时间:2020-05-29 作者:admin 浏览量:

一、 Java 面向对象

1. 面向对象都有哪些特性以及你对这些特性的理解

1) 继承:继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类(超类、基类);得到继承信息的类被称为子类(派生类)。继承让变化中的软件系统有了一定的延续性,同时继承也是封装程序中可变因素的重要手段。

2) 封装:通常认为封装是把数据和操作数据的方法绑定起来,对数据的访问只能通过已定义的接口。面向对象

的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装;我们编写一个类就是对数据和数据操作的封装。可以说,封装就是隐藏一切可隐藏的东西,只向外界提供最简单的编程接口。

3) 多态性:多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调

用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务,那么运行时的多态性可以解释为:当 A 系统访问 B 系统提供的服务时, B 系统有多种提供服务的方式,但一切对 A 系统来说都是透明的。方法重载(overload)实现的是编译时的多态性(也称为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事: 1. 方法重写(子类继承父类并重写父类中已有的或抽象的方法); 2. 对象造型(用父类型引用引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为)。

4) 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。

注意:默认情况下面向对象有 3 大特性,封装、继承、多态,如果面试官问让说出 4 大特性,那么我们就把抽象加上去。

2. 访问权限修饰符 public、 private、 protected, 以及不写(默认)时的区别(2017-

11-12)该题目比较简单,不同的权限修饰符的区别见下表。


WX20200529-064237@2x.png


3. 如何理解 clone 对象

3.1 为什么要用 clone?

在实际编程过程中,我们常常要遇到这种情况:有一个对象 A,在某一时刻 A 中已经包含了一些有效值,此时可

能会需要一个和 A 完全相同新对象 B,并且此后对 B 任何改动都不会影响到 A 中的值,也就是说, A 与 B 是两个独立

的对象,但 B 的初始值是由 A 对象确定的。在 Java 语言中,用简单的赋值语句是不能满足这种需求的。要满足这种需

求虽然有很多途径,但实现 clone()方法是其中最简单,也是最高效的手段。

3.2 new 一个对象的过程和 clone 一个对象的过程区别

new 操作符的本意是分配内存。程序执行到 new 操作符时,首先去看 new 操作符后面的类型,因为知道了类型,才能知道要分配多大的内存空间。分配完内存之后,再调用构造函数,填充对象的各个域,这一步叫做对象的初始化,构造方法返回后,一个对象创建完毕,可以把他的引用(地址)发布到外部,在外部就可以使用这个引用操纵这个对象。

clone 在第一步是和 new 相似的,都是分配内存,调用 clone 方法时,分配的内存和原对象(即调用 clone 方法的对象)相同,然后再使用原对象中对应的各个域,填充新对象的域,填充完成之后, clone 方法返回,一个新的相同的对象被创建,同样可以把这个新对象的引用发布到外部。

3.3 clone 对象的使用

3.3.1 复制对象和复制引用的区别

1. Person p = new Person(23, zhang);

2. Person p1 = p;

3. System.out.println(p);

4. System.out.println(p1);

当 Person p1 = p;执行之后, 是创建了一个新的对象吗? 首先看打印结果:

1. com.itheima.Person@2f9ee1ac

2. com.itheima.Person@2f9ee1ac

可以看出,打印的地址值是相同的,既然地址都是相同的,那么肯定是同一个对象。 p 和 p1 只是引用而已,他们

都指向了一个相同的对象 Person(23, “zhang” ) 。 可以把这种现象叫做引用的复制。上面代码执行完成之后, 内

存中的情景如下图所示

WX20200529-064633@2x.png

而下面的代码是真真正正的克隆了一个对象。

1. Person p = new Person(23, zhang);

2. Person p1 = (Person) p.clone();

3. System.out.println(p);

4. System.out.println(p1);

从打印结果可以看出,两个对象的地址是不同的,也就是说创建了新的对象, 而不是把原对象的地址赋给了一个

新的引用变量:

1. com.itheima.Person@2f9ee1ac

2. com.itheima.Person@67f1fba0

以上代码执行完成后, 内存中的情景如下图所示

WX20200529-221142@2x.png

3.3.2 深拷贝和浅拷贝

上面的示例代码中, Person 中有两个成员变量,分别是 name 和 age, name 是 String 类型, age 是 int 类

型。代码非常简单,如下所示:

1. public class Person implements Cloneable{

2. privatint age ;

3. private String name;

4. public Person(int age, String name) {

5. this.age = age;

6. this.name = name;

7. }

8. public Person() {}

9. public int getAge() {

10. return age;

11. }

12. public String getName() {

13. return name;

14. }

15. @Override

16. protected Object clone() throws CloneNotSupportedException {

17. return (Person)super.clone();

18. }

19. }

由于 age 是基本数据类型, 那么对它的拷贝没有什么疑议,直接将一个 4 字节的整数值拷贝过来就行。但是 name

是 String 类型的, 它只是一个引用, 指向一个真正的 String 对象,那么对它的拷贝有两种方式: 直接将原对象中

的 name 的引用值拷贝给新对象的 name 字段, 或者是根据原 Person 对象中的 name 指向的字符串对象创建一个

新的相同的字符串对象,将这个新字符串对象的引用赋给新拷贝的 Person 对象的 name 字段。这两种拷贝方式分别

叫做浅拷贝和深拷贝。深拷贝和浅拷贝的原理如下图所示:

WX20200529-221309@2x.png

下面通过代码进行验证。如果两个 Person 对象的 name 的地址值相同, 说明两个对象的 name 都指向同一个

String 对象,也就是浅拷贝, 而如果两个对象的 name 的地址值不同, 那么就说明指向不同的 String 对象, 也就

是在拷贝 Person 对象的时候, 同时拷贝了 name 引用的 String 对象, 也就是深拷贝。验证代码如下:

1. Person p = new Person(23, zhang);

2. Person p1 = (Person) p.clone();

3. String result = p.getName() == p1.getName()

4. ? clone 是浅拷贝的 : clone 是深拷贝的;

5. System.out.println(result);

打印结果为:

6. clone 是浅拷贝的

所以, clone 方法执行的是浅拷贝, 在编写程序时要注意这个细节。

如何进行深拷贝:

由上一节的内容可以得出如下结论:如果想要深拷贝一个对象,这个对象必须要实现 Cloneable 接口,实现 clone

方法,并且在 clone 方法内部,把该对象引用的其他对象也要 clone 一份,这就要求这个被引用的对象必须也要实现

Cloneable 接口并且实现 clone 方法。那么,按照上面的结论,实现以下代码 Body 类组合了 Head 类,要想深拷贝

Body 类,必须在 Body 类的 clone 方法中将 Head 类也要拷贝一份。代码如下:

1. static class Body implements Cloneable{

2. public Head head;

3. public Body() {}

4. public Body(Head head) {this.head = head;}

5. @Override

6. protected Object clone() throws CloneNotSupportedException {

7. Body newBody = (Body) super.clone();

8. newBody.head = (Head) head.clone();

9. return newBody;

10. }

11. }

12. static class Head implements Cloneable{

13. public Face face;

14. public Head() {}

15. @Override

16. protected Object clone() throws CloneNotSupportedException {

17. return super.clone();

18. } }

19. public static void main(String[] args) throws CloneNotSupportedException {

20. Body body = new Body(new Head(new Face()));

21. Body body1 = (Body) body.clone();

22. System.out.println(body == body1 :+ (body == body1) );

23. System.out.println(body.head == body1.head :+ (body.head == body1.head));

24. }

打印结果为:

1. body == body1 : false

2. body.head == body1.head : false

二、 JavaSE 语法( 2017-11-12-wl)

1. Java 有没有 goto 语句? (2017-11-12-wl)

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

2. & 和 && 的区别(2017-11-12-wl)

&运算符有两种用法: (1)按位与; (2)逻辑与。

&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的,虽然二者都要求运算符左右两端的布尔值都是

true 整个表达式的值才是 true。&&之所以称为短路运算是因为,如果&&左边的表达式的值是 false,右边的表达式会被直接短路掉,不会进行运算。很多时候我们可能都需要用&&而不是&,例如在验证用户登录时判定用户名不是 null 而且不是空字符串,应当写为 username != null &&!username.equals(),二者的顺序不能交换,更不能用&运算符,因为第一个条件如果不成立,根本不能进行字符串的 equals 比较,否则会产生 NullPointerException 异常。注意:逻辑或运算符(|)和短路或运算符(||)的差别也是如此。

3. 在 Java 中,如何跳出当前的多重嵌套循环(2017-11-14-wl)

在最外层循环前加一个标记如 A,然后用 break A;可以跳出多重循环。(Java 中支持带标签的 break 和 continue语句,作用有点类似于 C 和 C++中的 goto 语句,但是就像要避免使用 goto 一样,应该避免使用带标签的 break和 continue,因为它不会让你的程序变得更优雅,很多时候甚至有相反的作用) 。

4. 两个对象值相同 (x.equals(y) == true) , 但却可有不同的 hashCode, 这句

话对不对?(2017-11-14-wl)

不对,如果两个对象 x 和 y 满足 x.equals(y) == true,它们的哈希码(hashCode)应当相同。

Java 对于 eqauls 方法和 hashCode 方法是这样规定的: (1)如果两个对象相同(equals 方法返回 true),那

么它们的 hashCode 值一定要相同; (2)如果两个对象的 hashCode 相同,它们并不一定相同。当然,你未必要按照要求去做,但是如果你违背了上述原则就会发现在使用容器时,相同的对象可以出现在 Set 集合中,同时增加新元素的效率会大大下降(对于使用哈希存储的系统,如果哈希码频繁的冲突将会造成存取性能急剧下降)。

关于 equals 和 hashCode 方法,很多 Java 程序员都知道,但很多人也就是仅仅知道而已,在 Joshua Bloch

的大作《Effective Java》(很多软件公司,《Effective Java》、《Java 编程思想》以及《重构:改善既有代码质量》是 Java 程序员必看书籍,如果你还没看过,那就赶紧去买一本吧)中是这样介绍 equals 方法的。

首先 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 方法的诀窍包括: 1. 使用==操作符检查参数是否为这个对象的引用; 2. 使用 instanceof 操作符检查参数是否为正确的类型; 3. 对于类中的关键属性,检查参数传入对象的属性是否与之相匹配; 4. 编写完 equals 方法后,问自己它是否满足对称性、传递性、一致性; 5. 重写 equals 时总是要重写 hashCode; 6. 不要将 equals 方法参数中的 Object 对象替换为其他的类型,在重写时不要忘掉@Override 注解。

5. 是否可以继承 String (2017-11-14-wl)

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

继承 String 本身就是一个错误的行为,对 String 类型最好的重用方式是关联关系(Has-A)和依赖关系(UseA)而不是继承关系(Is-A)。

6. 当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并

可返回变化后的结果,那么这里到底是值传递还是引用传递?(2017-11-14-wl)

是值传递。 Java 语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变,但对对象引用的改变是不会影响到调用者的。 C++和 C#中可以通过传引用或传输出参数来改变传入的参数的值。说明: Java 中没有传引用实在是非常的不方便,这一点在 Java 8 中仍然没有得到改进,正是如此在 Java 编写的代码中才会出现大量的 Wrapper 类(将需要通过方法调用修改的引用置于一个 Wrapper 类中,再将 Wrapper 对象传入方法),这样的做法只会让代码变得臃肿,尤其是让从 C 和 C++转型为 Java 程序员的开发者无法容忍。

7. 重载(overload)和重写(override)的区别? 重载的方法能否根据返回类型进行区分?(2017-11-15-wl)

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

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

方法重载的规则:

1.方法名一致,参数列表中参数的顺序,类型,个数不同。

2.重载与方法的返回值无关,存在于父类和子类, 同类中。

3.可以抛出不同的异常,可以有不同修饰符。

方法重写的规则:

1.参数列表必须完全与被重写方法的一致,返回类型必须完全与被重写方法的返回类型一致。

2.构造方法不能被重写,声明为 final 的方法不能被重写,声明为 static 的方法不能被重写,但是能够被再次

声明。

3.访问权限不能比父类中被重写的方法的访问权限更低。

4.重写的方法能够抛出任何非强制异常(UncheckedException,也叫非运行时异常),无论被重写的方法是

否抛出异常。但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常,反之则

可以。

8. 为什么函数不能根据返回类型来区分重载? (2017-11-15-wl)

该道题来自华为面试题。

因为调用时不能指定类型信息,编译器不知道你要调用哪个函数。

例如:

1. float max(int a, int b);

2. int max(int a, int b);

当调用 max(1, 2);时无法确定调用的是哪个,单从这一点上来说,仅返回值类型不同的重载是不应该允许的。

再比如对下面这两个方法来说,虽然它们有同样的名字和自变量,但其实是很容易区分的:

1. void f() {}

2. int f() {}

若编译器可根据上下文(语境)明确判断出含义,比如在 int x=f()中,那么这样做完全没有问题。然而,

我们也可能调用一个方法,同时忽略返回值;我们通常把这称为“为它的副作用去调用一个方法” ,因为我

们关心的不是返回值,而是方法调用的其他效果。所以假如我们像下面这样调用方法: f(); Java 怎样判断 f()的具体调

用方式呢?而且别人如何识别并理解代码呢?由于存在这一类的问题,所以不能。

函数的返回值只是作为函数运行之后的一个“状态”,他是保持方法的调用者与被调用者进行通信的关键。并不能

作为某个方法的“标识”。

9. char 型变量中能不能存储一个中文汉字,为什么?(2017-11-16-wl)

char 类型可以存储一个中文汉字,因为 Java 中使用的编码是 Unicode(不选择任何特定的编码,直接

使用字符在字符集中的编号,这是统一的唯一方法),一个 char 类型占 2 个字节(16 比特),所以放一个中

文是没问题的。

补充:使用 Unicode 意味着字符在 JVM 内部和外部有不同的表现形式,在 JVM 内部都是 Unicode,当这个字符被

从 JVM 内部转移到外部时(例如存入文件系统中),需要进行编码转换。所以 Java 中有字节流和字符流,以及在字

符流和字节流之间进行转换的转换流,如 InputStreamReader 和 OutputStreamReader,这两个类是字节流和字符

流之间的适配器类,承担了编码转换的任务;对于 C 程序员来说,要完成这样的编码转换恐怕要依赖于 union(联合

体/共用体)共享内存的特征来实现了。

10. 抽象类(abstract class)和接口(interface)有什么异同?(2017-11-16-wl)

不同:

抽象类:

1.抽象类中可以定义构造器

2.可以有抽象方法和具体方法

3.接口中的成员全都是 public 的

4.抽象类中可以定义成员变量

5.有抽象方法的类必须被声明为抽象类,而抽象类未必要有抽象方法

6.抽象类中可以包含静态方法

7.一个类只能继承一个抽象类

接口:

1.接口中不能定义构造器

2.方法全部都是抽象方法

3.抽象类中的成员可以是 private、默认、 protected、 public

4.接口中定义的成员变量实际上都是常量

5.接口中不能有静态方法

6.一个类可以实现多个接口

相同:

1.不能够实例化

2.可以将抽象类和接口类型作为引用类型

3.一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现,否则该类仍然需要

被声明为抽象类

11. 抽象的(abstract)方法是否可同时是静态的(static), 是否可同时是本地方法

(native),是否可同时被 synchronized(2017-11-16-wl)

都不能。抽象方法需要子类重写,而静态的方法是无法被重写的,因此二者是矛盾的。本地方法是由

本地代码(如 C 代码)实现的方法,而抽象方法是没有实现的,也是矛盾的。 synchronized 和方法的实现细节有关,

抽象方法不涉及实现细节,因此也是相互矛盾的。

12. 阐述静态变量和实例变量的区别?(2017-11-16-wl)

静态变量: 是被 static 修饰符修饰的变量,也称为类变量,它属于类,不属于类的任何一个对象,一个类不

管创建多少个对象,静态变量在内存中有且仅有一个拷贝;

实例变量: 必须依存于某一实例,需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对

象共享内存。

13. ==和 equals 的区别?(2017-11-22-wzz)

equals 和== 最大的区别是一个是方法一个是运算符。

==:如果比较的对象是基本数据类型,则比较的是数值是否相等;如果比较的是引用数据类型,则比较的是对象

的地址值是否相等。

equals():用来比较方法两个对象的内容是否相等。

注意: equals 方法不能用于基本数据类型的变量,如果没有对 equals 方法进行重写,则比较的是引用类型的变

量所指向的对象的地址。

14. break 和 continue 的区别?(2017-11-23-wzz)

break 和 continue 都是用来控制循环的语句。

break 用于完全结束一个循环,跳出循环体执行循环后面的语句。

continue 用于跳过本次循环,执行下次循环。

15. String s = Hello;s = s +world!;这两行代码执行后,原始的 String 对象

中的内容到底变了没有?(2017-12-1-lyq)

没有。因为 String 被设计成不可变(immutable)类,所以它的所有对象都是不可变对象。在这段代码中, s 原先指

向一个 String 对象,内容是 Hello,然后我们对 s 进行了“+” 操作,那么 s 所指向的那个对象是否发生了改变呢?

答案是没有。这时, s 不指向原来那个对象了,而指向了另一个 String 对象,内容为Hello world!,原来那个对象还


分享到:
相关推荐
暂无相关推荐
微信公众号
手机浏览

Copyright © 2019 All Rights Reserved 版权所有 豫商人才网 豫ICP备19004769 豫公网安备号:41140302000096

地址:河南省商丘市睢阳区神火大道176号联合大厦13楼 EMAIL:postmaster@37jobs.com

用微信扫一扫