java面试官想要听到的回答-java基础面试题

本人不是面试官，也是一个要经历一个又一个面试官的菜鸡。有时候你在刚回答完面试官的问题，是否有下面的灵魂三问？

我的回答有错么？
我的回答够了么？
是面试官想听的结果么？

如果你能看到这篇文章，可能说明不够。所以我是从面试官的博客，结合自己的知识，来重新回答一个面试官给你加分的答案。一次绝对写不完，我会持续更新自己的这篇博客，希望和大家一起学习，也希望大家看到错误可以指正小弟一下我。

java基础问题

1.重载和重写的区别？

重载和重写其实都是实现多态的方式，区别在于重载体现在编译时的多态，而重写体现在运行时的多态。
重载发生在一个类中，同名的方法根据参数不同（参数的个数，参数的类型，参数的排序），达到重载的目的，注意重载对返回参数没有要求，不能通过返回参数来区别重载。
而重写发生在子类和父类之间，子类重写父类相同参数列表，有兼容的返回类型的方法，同时子类的访问权限必须>=父类的访问权限，比如那四种访问修饰符。

2.接口和抽象类的区别？

接口和抽象类都不能实例化，如果要实例化，接口需要有实现类实现接口的所有抽象方法。而抽象类需要子类继承并且实现抽象类的所有抽象方法，如果不全部实现，就还是抽象类。
接口和抽象类的方式，一个实现，一个继承，单继承，多实现
接口中只能定义抽象方法和静态常量，而抽象类中可以存在抽象方法，也可以存在普通方法，同时也可以存在普通变量。
由上面也可以看出接口的抽象程度比较高。
通常接口用来抽象功能，而抽象类用来抽象类别，比如spring中的BeanFactory抽象工厂模式生产不同类别的Bean对象。

3.什么是面向切面？

面试官：解释出什么是面向切面，加分，讲解出代理的原理，加分
我：对于系统的业务逻辑和反复使用的系统服务，业务逻辑作为切面，在切面的前后添加系统服务。就比如Spring AOP,方法是最小粒度，可以在方法前后添加@Before和@After添加反复使用的逻辑，比如日志，事务。其实aop就是使用的动态代理。

java中有jdk动态代理Implement InvocationHandler和cglib动态代理implements MethodInterceptor。代理类都是实现这两个接口，内部有返回代理方法和invoke方法。

jdk动态代理原理（被代理类必须有实现接口）：通过拿到的被代理对象，反射获取其所有的接口，重新生成一个类，并且实现被代理类所有的接口，然后动态生成java代码，编译形成class文件，重新加载到jvm中。以上就是字节码重组。
cglib动态代理：采用继承被代理类的方式。

两者都是通过运行时动态生成字节码的方式来实现。

4.什么是序列化？什么情况下需要序列化？

序列化：把java对象转化成字节流的过程。 反序列化：把字节流转化成java对象的过程。
场景：当java对象需要在网络上传输或者需要持久化到文件中，写到数据库中，就需要对java对象序列化处理。
实现：类实现Serializable 接口即可。
注意：

1. 某个类可以被序列化，则其子类也可以被序列化
2. 声明为 static 和 transient 的成员变量，不能被序列化。static 成员变量是描述类级别的属性，transient 表示临时数据
3. 反序列化读取序列化对象的顺序要保持一致

5.java创建对象都有哪几种方式？

1. 使用new关键字，可以调用想要调用的构造方法（包括无参和有参构造方法）。
2. 使用Class类 的newInstance()方法，将调用无参构造方法。

Employee emp2 = (Employee) Class.forName("com.xiaodeng.pojo.Employee").newInstance();

3. 使用Constructor类的newInstance（）方法，可以调用有参构造方法和私有的构造方法。

Constructor constructor = Employee.class.getConstructor(); 
Employee emp3 = constructor.newInstance();

4. 使用clone()方法，该方法不会调用任何构造方法，注意深克隆和浅克隆！

//使用clone对象时，该对象需要实现Cloneable接口，并实现clone方法，如果直接返回super.clone方法，
//复制出来的对象虽不一样，但对象中的字段用的还是之前的对象的属性字段，叫浅克隆
Employee emp4 = (Employee) emp2.clone();

5. 使用序列化和反序列化创建对象，可以解决浅克隆的问题，JVM不使用构造函数创建一个独立的对象。

ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj")); 
Employee emp5 = (Employee) in.readObject();

6.什么是反射？反射创建class对象的三种方式，反射都有哪些方法？

反射：反射在运行状态中，对于任何一个类，都能知道这个类的所有属性和方法，对于任何一个对象，都可以调用它的任意属性和方法。

//创建class对象的三种方式：
Class<?> clazz1 = Class.forName("test.Counter");//全包名
		Class<?> clazz2 = Counter.class;//类名.class
		Counter counter = new Counter();
		Class<?> clazz3 = counter.getClass();//对象.getclass()
//反射创建对象
		clazz1.newInstance();//调用无参构造方法
		clazz1.getConstructor().newInstance(1);//可以调用有参和私有的构造方法
//获取对象的属性
		clazz.getFields();//获得某个类的所有的公共（public）的字段，包括父类中的字段。
		clazz.getDeclaredFields();//获得某个类的所有声明的字段，但是不包括父类的声明字段.
//通过class对象获得一个方法对象
		clazz.getMethod(“方法名”,参数类型);//只能获取公共的）
		clazz.getDeclareMethod(“方法名”);//获取任意修饰的方法，但是此时还不能执行私有）
		M.setAccessible(true);//让私有的方法可以执行
		Method.invoke(obj实例对象,obj可变参数);//执行对象的某个方法，可以返回参数

7. 谈谈你对单例模式的理解？

在一个系统中，单例模式可以确保一个类只有一个实例。比如Spring,在容器启动时，完成对BeanDefine的定位加载注册，之后getBean默认返回单例模式的对象Bean（当然这个Bean不是直接new的对象，而是返回的代理对象）。

同时既然一个类只有一个实例，使用单例模式的初衷就是是资源共享，一个容器中共同使用一个对象，但是资源共享就要注意线程安全的问题！
比如：而单例模式的实现我知道3种：
其中1.懒汉式单例：就是容器启动默认不创建对象，只有用到的时候在创建对象，比如经典的双重检查单例模式，因为new对象的有序性问题，就会是线程不安全的。

public class Singleton {
  static Singleton instance;
  static Singleton getInstance(){
    if (instance == null) {
      synchronized(Singleton.class) {
        if (instance == null)
          instance = new Singleton();//这里存在线程安全问题
        }
    }
    return instance;
  }
}

使用匿名内部类完美实现懒加载

在调用getinstance方式时，再会加载内部类。
public class LazyThree {
	public static final LazyThree getinstance() {		
		return LazyHolder.lazy;// 在返回内部类前，一定会先加载内部类
	}
	private static class LazyHolder {// 默认这个内部类不加载
		private static final LazyThree lazy = new LazyThree();
	}
}

2. 饿汉式，就是不管用不用实例对象，我都先创建出来，之后用的时候返回之前创建的对象。
3. 注册式单例模式，Sping的ioc(控制反转)就是用的这种模式，其实ioc就是一个存放BeanDefined的容器，在内部就是一个线程安全的ConcurrentHashMap。如果用一个对象，从该容器中找，没有就创建一个对象返回，并且放到容器中，下次再用的时候直接直接从容器中取出。

8. 实参和形参的区别？

实参在方法外部定义好，调用方法时，传入实参，调用方法，此时才会为形参变量分配内存，调用方法结束时，释放所分配的内存，形参只能在方法函数内有效，方法结束后不能再使用该形参。

今天就到这里，如果有疑问可以在评论区留言，谢谢。

更多：邓新