金三银四正是跳槽涨薪的好时节，波哥给大家整理了很多面试高频的问题，助力大家找到更好的工作哦，点点关注，感谢支持。

面向对象面试题

1.谈谈你对面向对象思想的理解?

面向过程编程(POP)：是一种以过程为中心的编程思想

面向对象编程(OOP)：相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式

2. 谈谈你对面向对象的特征的理解

封装

即把对象的属性和方法包裹起来，只能通过约定好的接口实现访问

封装是一种信息隐藏技术，在java中通过关键字private实现封装。

package com.bobo.interview0001.domain;/*** 属性+方法*/
public class User {// 将age设置为私有属性private int age;public String name;/*** 提供给外界设置age属性的方法* @param age*/public void setAge(int age){if(age < 0 || age > 120){System.out.println("age的设置不合法!!!");age = 0;}this.age = age;}/*** 提供给外界获取age属性的方法* @return*/public int getAge(){return age;}}

封装的好处：可以将私有数据和公共数据分离，保护私有数据，提高了程序的安全性!!!

继承

继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
为什么要继承呢：

反映现实的真实关系
减少代码冗余
对父类的属性和方法进行扩展和重写

继承中，子类不可以选择性的继承父类的东西，而是全部继承父类的属性和方法。其中父类又叫超类或基类，子类又叫派生类。父类是子类的一般化，子类是父类的特化（具体化)。java中不支持多继承，一个类最多只能有一个父类。而在java中多继承是通过接口实现的。

public class Person {private String userName;private int age;private String sex;private String address;private String idCard;public void show(){System.out.println("父类中的方法");}
}

public class Doctor extends Person{@Overridepublic void show() {System.out.println("Doctor ... show");}
}

public class Student  extends Person{private String ClassNum;private String stuNo;// ....public void learn(){}@Overridepublic void show() {System.out.println("Student ... show");}
}

多态

Java对象的多种状态，多态主要是基于继承和重写，最终可以实现相同的类型调用相同的方法，结果不相同

    public static void main(String[] args) {// 多态的体现Person p1 = new Student();p1.show();Person p2 = new Doctor();p2.show();}

3.介绍下访问权限修饰符

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

重点注意protected和default，protected相比较default多了一个不同包下面的子类可见

4. String是基本数据类型吗？

Java中的8个基本数据类型：

byte
short
int
long
float
double
char
boolean

String类型显然不在8个基本数据类型之中，String类型是我们讲的引用类型

5. float f=6.6这样写是否正确?

不正确的，6.6默认是双精度类型，将double类型赋值给float类型，属性向下转型，会造成精度丢失

public class Demo01 {public static void main(String[] args) {// 小数 默认的是 double类型 双精度类型 向下转型  精度丢失float f2 = 1.1;float f = 6.6F;float f1 = 7.7F;}
}

6 程序题1

short s1 = 1;
s1 = s1 + 1; // 此处需要强制类型转换

有错吗? – 有错

short s1 = 1;
s1 += 1; // s1 = (short) ( s1 + 1 )

有错吗？-- 没有错

7. 程序题2

以下程序的输出结果是：

    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

原因解释：

IntegerCache中的定义

    private static class IntegerCache {static final int low = -128;static final int high;static final Integer cache[];static {// high value may be configured by propertyint 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_VALUEh = Math.min(i, Integer.MAX_VALUE - (-low) -1);} catch( NumberFormatException nfe) {// If the property cannot be parsed into an int, ignore it.}}high = h;// 创建了一个缓存的数组 长度256cache = new Integer[(high - low) + 1];int j = low;// 循环256次for(int k = 0; k < cache.length; k++)// 一次创建 -128 到 127 对应的Integer对象，并保存到数组中cache[k] = new Integer(j++);// range [-128, 127] must be interned (JLS7 5.1.7)assert IntegerCache.high >= 127;}private IntegerCache() {}}

valueOf(int)中的源码

    public static Integer valueOf(int i) {// 如果 i 在 -128 到 127之间if (i >= IntegerCache.low && i <= IntegerCache.high)// 就从缓存的数组中返回之前创建的 Integer对象return IntegerCache.cache[i + (-IntegerCache.low)];// 否则创建一个新的Integer对象return new Integer(i);}

提醒：越是貌似简单的面试题，其中的玄机就越多，要求面试者需要相对深厚的功力。

8. &和&&的区别

&：按位与

int a = 5;   //  101
int b = 3;   //  011
int c = a & b;// 001

逻辑与:都为true结果才为true，左边如果为false，右边表达式还是会运行

&&：短路与：都为true结果才为true，左边如果为false，右边表达式不会运行

    public static void main(String[] args) {int a = 5;   //  101int b = 3;   //  011int c = a & b;// 001System.out.println("c = " + c);// 逻辑与 & 左右两边都为true 那么结果才为true//  左边为false，结果为false，但是右边的表达式还是会进行运算if(a == 0 & a ++ > 0){System.out.println("------");}System.out.println("a = " + a);// && 短路与  左边如果为false，那么整体的结果也为false，而且右边的表达式不会运算if(a == 0 && a ++ > 0){System.out.println("------");}System.out.println("a = " + a);String name = null;// 短路与在实际使用的时候还是很有使用场景的if(name != null & !name.equals("")){}}
}

9. switch可以使用的数据类型

JDK5之前：byte，short，int，char

JDK5之后：Java中引入了枚举类型，枚举类型也可以

JDK7之后：可以使用String，但是long类型一直是不可以的

10. 用最有效的方法计算2乘以8？

2 << 3（左移3位，相当于乘以2的3次方）

11. 构造器是否可以被重写？

构造器不能被继承，因此是不能被重写的，但是我们可以重载构造器

12. 是否可以继承String类？

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

13. 重载和重写的区别

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

重载：在同一个类中，同名的方法如果有不同的参数列表(参数类型，参数个数，顺序)视为重载

package com.bobo.interview0006;public class Demo01 {public static void main(String[] args) {A a = new A();a.show1();a.show1(18);a.show1("a",18);a.show1(18,"aaa");}
}class A{/*** 方法的重载：在同一个类中  方法名称相同  参数列表不同*/public void show1(){}public void show1(String name){}public void show1(int a){}public void show1(String name,int a){}public void show1(int a,String name){}
}

重写：发生在父子关系类中，子类重写父类的方法，有相同的返回类型或子类

class B extends A{/*** 重写，子类重写父类中的方法*/@Overridepublic void show1() {// super.show1();System.out.println("show1 --- B");}/*** 重写的返回类型必须相同或者是父类返回类型的子类* @param n* @return*/@Overridepublic Integer fun1(Number n) {return 666;}
}

14. 抽象类和接口的区别

接口和抽象类都不能实例化
抽象类相比于普通类多的限制是可以添加抽象方法
接口中只能声明常量和抽象方法且访问修饰符必须都为public，在JDK8之后可以定义default方法和static方法

package com.bobo.interview0007;public class Demo01 {public static void main(String[] args) {}
}/*** 抽象类*   不能被实例化*   可以声明普通的属性和方法*   还可以定义抽象方法*/
abstract class A{private int a;public int b;public void fun1(){}public abstract  void fun2();}/*** 接口*   不能被实例化*   属性只能是常量*   方法只能是抽象方法*      JDK1.8之后可以有 default和static方法*/
interface B{public final  int a = 9;// public abstract 方法默认的类型 可以不添加public abstract void show1();/*** default方法*/public default void fun1(){}/*** 静态方法*/public static void fun2(){}
}

15. 静态内部类和内部类的区别

静态内部类是被声明为static的内部类，它可以不依赖外部类的实例被实例化，而通常我们的内部类是需要通过外部类的实例才能实例化。

public class OutterClass {/*** 普通内部类*/class InnerClass{public void show(){System.out.println("InnerClass ...");}}/*** 静态内部类*/static class StaticInnerClass{public void show(){System.out.println("StaticInnerClass ...");}}
}

测试代码

    public static void main(String[] args) {// 获取普通内部类对象OutterClass.InnerClass innerClass = new OutterClass().new InnerClass();innerClass.show();// 获取静态内部类对象OutterClass.StaticInnerClass staticInnerClass = new OutterClass.StaticInnerClass();staticInnerClass.show();}

16. 抽象方法是否可以同时是静态的本地方法及被synchronized修饰？

抽象方法所在的类肯定是抽象类，

不能被static修饰，因为静态不能被重写，而抽象方法必须要被子类重写，所以矛盾。
不能被native修饰，本地方法是由C代码实现的，而抽象方法没有实现，也是矛盾的
不能被synchronized修饰，同步是和方法的实现的细节有关系的，而抽象方法没有具体的实现，也是相互矛盾的

17. 静态变量和实例变量的区别

静态变量：是被static所修饰的变量，也称为类变量，它是属性类对象的，不属于类的任何一个对象。静态变量是对象间共享的

实例变量：数据具体的某个对象，必须要先创建对象，然后通过该对象来访问实例变量，

18.静态方法中是否可以访问普通方法

肯定不可以，静态方法是在类加载阶段就创建的，而普通方法是属性对象的，在类加载阶段还没有对象，所以是矛盾的，静态方法只能访问静态成员，普通方法必须要先创建对象，然后通过对象来调用普通方法。

public class Person {static void show(){// 静态方法中不可以调用 普通方法//  speak();}void speak(){// 普通方法可以调用静态方法show();}
}

19.如何实现克隆

原型模式	说明
浅克隆	只是拷贝本对象,其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址
深度克隆	深复制把要复制的对象所引用的对象都复制了一遍

package com.dpb.prototype;import java.io.Serializable;
import java.util.Date;/*** 原型类：被克隆的类型* @author dengp**/
public class User implements Cloneable,Serializable{private String name;private Date birth;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public Date getBirth() {return birth;}public void setBirth(Date birth) {this.birth = birth;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}/*** 实现克隆的方法*/public Object clone() throws CloneNotSupportedException{return super.clone();}
}

深度克隆

package com.dpb.prototype;import java.io.Serializable;
import java.util.Date;/*** 原型类：被克隆的类型* 深度克隆测试* @author dengp**/
public class User2 implements Cloneable,Serializable{private String name;private Date birth;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public Date getBirth() {return birth;}public void setBirth(Date birth) {this.birth = birth;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}/*** 实现克隆的方法* 深度克隆(deep clone)*/public Object clone() throws CloneNotSupportedException{Object object = super.clone();// 实现深度克隆(deep clone)User2 user = (User2)object;user.birth = (Date) this.birth.clone();return object;}
}

序列化和反序列化

public static void main(String[] args) throws CloneNotSupportedException, Exception {Date date =  new Date(1231231231231l);User user = new User();user.setName("波波烤鸭");user.setAge(18);user.setBirth(date);System.out.println("-----原型对象的属性------");System.out.println(user);System.out.println(user.getName());System.out.println(user.getBirth());//使用序列化和反序列化实现深复制ByteArrayOutputStream bos = new ByteArrayOutputStream();ObjectOutputStream    oos = new ObjectOutputStream(bos);oos.writeObject(user);byte[] bytes = bos.toByteArray();ByteArrayInputStream  bis = new ByteArrayInputStream(bytes);ObjectInputStream    ois = new ObjectInputStream(bis);//克隆好的对象！User user1 = (User) ois.readObject();   // 修改原型对象的值date.setTime(221321321321321l);System.out.println(user.getBirth());System.out.println("------克隆对象的属性-------");System.out.println(user1);System.out.println(user1.getName());System.out.println(user1.getBirth());
}

20.介绍下final关键字

final修饰	描述
类	该类不能被继承
方法	该方法不能被重写
成员变量	变量变常量，不能被修改

21.程序运行题

以下程序的输出结果是：

public class Hello {/*** Class 对象* Object 普通对象* Java的类加载机制要比较清楚* @param args*/public static void main(String[] args) {A ab = new B(); // 普通对象是根据 Class对象来创建的  1a2bab = new B(); // 因为 B的类对象已经被加载了，这时静态变量初始化就不会执行了 2b// 1a2b2b}
}
class A {static {System.out.print("1");}public A() {System.out.print("2");}
}class B extends A{static {System.out.print("a");}public B() {super();System.out.print("b");}
}

输出结果为:

1a2b2b

程序执行的顺序：

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

22.数据类型之间的转换

字符串–》基本数据类型
基本数据类型–》字符串

    public static void main(String[] args) {String s1 = "99";// 转换为int类型// 1.通过int对应的包装类 Integer 中提供的 parseXXX(String) 方法int i = Integer.parseInt(s1);// 2.通过int 对应的包装来 Integer 中的 valueOf(String) 方法Integer i2 = Integer.valueOf(s1);// 将一个基本数据类型转换为 String类型int age = 18;String s2 = age + "";String s3 = String.valueOf(age);}

23.return和finally的执行顺序问题

分析如下的代码程序，给出输出结果，并给出原因

public class Demo02 {public static void main(String[] args) {Demo02 demo02 = new Demo02();System.out.println(demo02.getName("bobo"));}public String getName(String name){String res = "";try {res = name;return  res;}finally {res = "波波烤鸭";}}
}

输出的结果是：bobo

原因：通过指令分析我们可以发现在 return 代码执行的时候会将局部变量保存在栈帧的顶部，然后在finally中修改的还是原来的栈帧位置的局部变量，最终返回的信息还是栈帧顶部的变量，所以finally代码块在return关键字之后会执行，但是不会改变栈帧顶部的信息。

还有一种情况需要注意，如果finally和try块中都有return关键字会怎么样呢？

public class Demo02 {public static void main(String[] args) {Demo02 demo02 = new Demo02();System.out.println(demo02.getName("bobo"));}public String getName(String name){String res = "";try {res = name;return  res;}finally {res = "波波烤鸭";return res; // 指令中返回的就不是栈帧顶部的数据了 而是 res 对应的栈帧位置}}
}

通过指令我们可以看到在finally中的return关键字的指令返回的就是finally中的局部变量的信息，可以理解为finally中的return会覆盖掉try块中的return逻辑。

[金三银四面试季]Java面向对象高频面试题相关推荐

金三银四面试季来临，最新BAT面试资料分享给大家
已经到3月中了,职场的金三银四跳槽季又来了,不同的是今年比往年「冷」一些,形式更加严峻一些,大家多多少少可能都听到或看到一些信息,就是好多公司在优化裁员,代表的就是滴滴.京东这种大型互联网公司,已经官 ...
Java 专项练习【1 - 10】，突围金三银四面试季
A 假设 A 类有如下定义,设 a 是 A 类同一个包下的一个实例,下列语句调用哪个是错误的?() class A{ int i; static String s; void method1() { ...
正式加入字节跳动！突围金三银四面试季！Java面试题及解析
前言这些算法,都是小编一点一点看的大佬们的方法,自己积累的. 如果有什么描述的不对的地方还望大佬赐教多交流才能进步,加油,冲冲冲!!! 1.1. 操作系统简介我通过以下四点介绍什么是操作系统: ...
金三银四面试季—20道精选JVM重点面试问题！
JVM 是小白 Java 程序员成长路上的一道坎也是很多工作2到3年程序员的一个重点面试问题之一,学习JVM之前,只需要知道代码编译成 Class,虚拟机加载 Class 运行就可以了,学习 JVM ...
2022金三银四面试总结-Java高级篇
Java面试总结 1.你用过哪些集合类? 大公司最喜欢问的Java集合类面试题 40个Java集合面试问题和答案 java.util.Collections 是一个包装类.它包含有各种有关集合操作的静 ...
2021金三银四面试季！2021Java者未来的出路在哪里？值得一看
前言本以为两三天就能搞定这篇文章,现在才知道是我想的太天真了,从构思到整理资料差不多用了一个星期的时间,现在也是终于搞定了. 我看很多人都说想要一份系统化的学习路线,现在它终于来了!!!整个路线概括 ...
2021年 Android面试知识点总结 (备战金三银四面试季)，程序员翻身之路
FLAG_ACTIVITY_NEW_TASK和FLAG_ACTIVITY_CLEAR_TOP一起使用,并且要启动的activity的taskAffinity和当前activity的taskAffini ...
【金三银四跳槽季】Java工程师如何在1个月内做好面试准备？
点击上方"蓝字", 右上角选择"设为星标" 周一至周五早11点半!精品文章准时送上! 本文来自石杉的架构笔记目录一.写在前面二.技术广度的快速准备三.技 ...
【金三银四跳槽季】Java工程师的面试之路，需要“解锁”哪些技术盲点？
春节长假转眼已过,即将迎来的是一年一度的金三银四跳槽季. 相信大家在应聘一些中大型互联网公司的Java工程师岗位时遇到了不少困惑. 举个例子:有朋友说他在面试前其实也做了精心准备,网上搜集了不少Jav ...

[金三银四面试季]Java面向对象高频面试题