java （收集自用）1. 解释下什么是面向对象？面向对象和面向过程的区别？面向对象是一种基于面向过程的编程思

1. 解释下什么是面向对象？面向对象和面向过程的区别？

面向对象是一种基于面向过程的编程思想，是向现实世界模型的自然延伸，这是一种“万物皆对象”。由执行者变为指挥者，在现实生活中的任何物体都可以归为一类事物，而每一个个体都是一类事物的实例。面向对象的编程是以对象为中心，以消息为驱动。

区别：

1、编程思路不同：面向过程以实现功能的函数开发为主，而面向对象要首先抽象出类、属性及其方法，然后通过实例化类、执行方法来完成功能。

2、封装性：都具有封装性，但是面向过程是封装的是功能，而面向对象封装的是数据和功能。

3、面向对象具有继承性和多态性，而面向过程没有继承性和多态性，所以面向对象优势很明显

2. 面向对象的三大特性？分别解释下？

面向对象的三大特性：继承、封装、多态

封装：是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。通俗来说，就是将一大堆实现逻辑，放在一个盒子里面。我们使用的时候，只需要调用封装好的盒子即可。

封装的优点：

1、良好的封装能减少耦合
2、类内部的结构可以自由修改
3、可以对成员变量进行更精确的控制
4、隐藏信息，实现细节

继承：就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

多态：同一个行为具有多个不同表现形式或形态的能力。

多态存在的三个必要条件：

1、继承；
2、重写；
3、父类引用指向子类对象：Parent p = new Child();

3. JDK、JRE、JVM 三者之间的关系？

JDK（Java Development Kit）是针对Java开发员的产品，是整个Java的核心，包括了Java运行环境JRE、Java工具和Java基础类库。 Java Runtime Environment（JRE）是运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。 JVM是Java Virtual Machine（Java虚拟机）的缩写，是整个java实现跨平台的最核心的部分，能够运行以Java语言写作的软件程序。

4. 重载和重写的区别？

重载(Overloading)

方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。

重载Overloading是一个类中多态性的一种表现。

Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。

调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

父类方法被默认修饰时，只能在同一包中，被其子类被重写，如果不在同一包则不能重写。

父类的方法被protoeted时，不仅在同一包中，被其子类被重写，还可以被不同包的子类重写。

重写方法的规则：

1）、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。

2）、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。

3）、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）

4）、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：

父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

而重载的规则：

1）、必须具有不同的参数列表；

2）、可以有不同的返回类型，只要参数列表不同就可以了；

3）、可以有不同的访问修饰符；

4）、可以抛出不同的异常；

重载和重写（覆盖）的特点：

Override 特点

　　1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

　　2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

　　3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

　　4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

2.Overload 特点

　　1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)，但是不能为fun(int, int)）；

　　2、不能通过访问权限、返回类型、抛出的异常进行重载；

　　3、方法的异常类型和数目不会对重载造成影响；

　　4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

总结：

override（重写）

　　 1、方法名、参数、返回值相同。

　　 2、子类方法不能缩小父类方法的访问权限。

　　 3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。

　　 4、存在于父类和子类之间。

　　 5、方法被定义为final不能被重写。

　overload（重载）

　　1、参数类型、个数、顺序至少有一个不相同。

　　2、不能重载只有返回值不同的方法名。

　　3、存在于父类和子类、同类中。

1.重写(Override) 从字面上看，重写就是重新写一遍的意思。其实就是在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下，对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。例如：


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Son s = new Son();
        s.sayHello();
    }

    public void sayHello() {
        System.out.println("Hello");
    }
}

class Son extends Father{

    @Override
    public void sayHello() {
        // TODO Auto-generated method stub
        System.out.println("hello by ");
    }

}

2.重载(Overload)

在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同**）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。例如

public class Father {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Father s = new Father();
        s.sayHello();
        s.sayHello("wintershii");

    }

    public void sayHello() {
        System.out.println("Hello");
    }

    public void sayHello(String name) {
        System.out.println("Hello" + " " + name);
    }
}

5. Java 中是否可以重写一个 private 或者 static 方法？

java中的static方法是不可以被覆盖的，因为方法覆盖是基于运行时的动态绑定的，而static方法编译时是静态绑定的，static方法类的任何事例都不相关联。 java中也不可以覆盖private权限的方法，因为private修饰变量只能在当前类内部使用，其他类继承当前类的时候，访问不到private变量，当然不能覆盖！

6 构造方法有哪些特性？一个类的构造方法的作用是什么若一个类没有声明构造方法,该程序能正确执行吗 ?为什么?

主要作用是完成对类对象的初始化工作。可以执行。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。

特性

名字与类名相同；
没有返回值，但不能用void声明构造函数；
生成类的对象时自动执行，无需调用。

7. 在 Java 中定义一个不做事且没有参数的构造方法有什么作用？

Java程序在执行子类的构造方法之前，如果没有用super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”

因此，如果⽗类中只定义了有参数的构造⽅法，⽽在⼦类的构造⽅法中⼜没有⽤ super() 来调⽤⽗类中特定的构造⽅法，则编译时将发⽣错误，因为 Java 程序在⽗类中找不到没有参数的构造⽅法可供执⾏。解决办法是：在⽗类⾥加上⼀个不做事且没有参数的构造⽅法。
父类：

 
public class F {
    public int x = 0;
    public F(int x) {
        System.out.println("调用了父类的构造方法");
        this.x = x;
    }
}

子类

    public C(int x) {
        super(x);
    }
}

如果没有调用super：会包如下错误

8. Java 中创建对象的几种方式？

创建对象的5种方式

1、new关键字


public class Main {

    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person("fsx", 18);
    }

}

2、Class.newInstance 这是我们运用反射创建对象时最常用的方法。Class类的newInstance使用的是类的public的无参构造器。因此也就是说使用此方法创建对象的前提是必须有public的无参构造器才行，否则报错如下：

// 没无参构造器报错信息
Caused by: java.lang.NoSuchMethodException: com.fsx.bean.Person.<init>()
  at java.lang.Class.getConstructor0(Class.java:3082)
  at java.lang.Class.newInstance(Class.java:412)
  ... 1 more

// 无参构造器不是public的报错信息
Exception in thread "main" java.lang.IllegalAccessException: Class com.fsx.maintest.Main can not access a member of class com.fsx.bean.Person with modifiers "private"
  at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
  at java.lang.Class.newInstance(Class.java:436)
  at com.fsx.maintest.Main.main(Main.java:13)

正常使用方式如下：

public class Main {

    public static void main(String[] args) throws Exception {
        Person person = Person.class.newInstance();
        System.out.println(person); // Person{name='null', age=null}
    }

}

3、Constructor.newInstance 本方法和Class类的newInstance方法很像，但是比它强大很多。 java.lang.relect.Constructor类里也有一个newInstance方法可以创建对象。我们可以通过这个newInstance方法调用有参数（不再必须是无参）的和私有的构造函数（不再必须是public）


public class Main {

    public static void main(String[] args) throws Exception {
        // 包括public的和非public的，当然也包括private的
        Constructor<?>[] declaredConstructors = Person.class.getDeclaredConstructors();
        // 只返回public的~~~~~~(返回结果是上面的子集)
        Constructor<?>[] constructors = Person.class.getConstructors();


        Constructor<?> noArgsConstructor = declaredConstructors[0];
        Constructor<?> haveArgsConstructor = declaredConstructors[1];

        noArgsConstructor.setAccessible(true); // 非public的构造必须设置true才能用于创建实例
        Object person1 = noArgsConstructor.newInstance();
        Object person2 = declaredConstructors[1].newInstance("fsx", 18);

        System.out.println(person1);
        System.out.println(person2);
    }

}

输出

Person{name='null', age=null}
Person{name='fsx', age=18}

4、Clone
无论何时我们调用一个对象的clone方法，JVM就会创建一个新的对象，将前面的对象的内容全部拷贝进去，用clone方法创建对象并不会调用任何构造函数。要使用clone方法，我们必须先实现Cloneable接口并复写Object的clone方法（因为Object的这个方法是protected的，你若不复写，外部也调用不了呀）。

public class Person implements Cloneable {
  ...
  // 访问权限写为public，并且返回值写为person
    @Override
    public Person clone() throws CloneNotSupportedException {
        return (Person) super.clone();
    }
    ...
}

public class Main {

    public static void main(String[] args) throws Exception {
        Person person = new Person("fsx", 18);
        Object clone = person.clone();

        System.out.println(person);
        System.out.println(clone);
        System.out.println(person == clone); //false
    }

}

输出结果

Person{name='fsx', age=18}
Person{name='fsx', age=18}
false

5 反序列化

public class Main {

    public static void main(String[] args) throws Exception {
        Person person = new Person("fsx", 18);
        byte[] bytes = SerializationUtils.serialize(person);

        // 字节数组：可以来自网络、可以来自文件（本处直接本地模拟）
        Object deserPerson = SerializationUtils.deserialize(bytes);
        System.out.println(person);
        System.out.println(deserPerson);
        System.out.println(person == deserPerson);
    }

}

输出

Person{name='fsx', age=18}
Person{name='fsx', age=18}
false

Person{name='fsx', age=18}
Person{name='fsx', age=18}
false

5种方式对是否调用了构造器的总结

这其实又可以衍生出一个面试题：Java创建实例对象是不是必须要通过构造函数？针对上面5种方式是否调用了构造函数，绘制表格如下：

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

接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。

抽象类是什么：

抽象类不能创建实例，它只能作为父类被继承。抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象。从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为其子类的模板，从而避免了子类的随意性。

(1) 抽象方法只作声明，而不包含实现，可以看成是没有实现体的虚方法 (2) 抽象类不能被实例化 (3) 抽象类可以但不是必须有抽象属性和抽象方法，但是一旦有了抽象方法，就一定要把这个类声明为抽象类 (4) 具体派生类必须覆盖基类的抽象方法 (5) 抽象派生类可以覆盖基类的抽象方法，也可以不覆盖。如果不覆盖，则其具体派生类必须覆盖它们

接口是什么：

(1) 接口不能被实例化

(2) 接口只能包含方法声明

(3) 接口的成员包括方法、属性、索引器、事件

(4) 接口中不能包含常量、字段(域)、构造函数、析构函数、静态成员

java （收集自用）