面向对象特点

继承：

解决类的重用问题，在已有类的功能上继续进行扩充。

实现：

Class 子类（派生类） extends 父类（超类）{}
子类能操作父类的属性和方法，但是本质上子类和父类是分开放的。创建子类对象的同时创建了父类的对象。如下图：

实例化子类之前系统一定会先自动实例化父类对象，相当于子类的构造方法隐含了
super()表示的就是子类调用父类构造方法的语句。该语句只允许放在子类构造方法的首行。如果父类中没有无参的构造方法，必须调用明确调用有参构造。

继承相关的限制：

1.java不允许多重继承，只允许多层继承。（只能继承一个，不能继承多个）对于继承而言，理论上不应该超过三层。
2.在继承关系的定义时，实际上子类可以继承父类中所有的操作结构，对私有操作是隐式继承，private类/方法不能直接访问，需要间接访问。

覆写：

当子类与父类方法名称，参数类型，个数完全相同的时候（跟父类一模一样），就称为方法的覆写。

意义：

优化父类的功能。

限制：

覆写的访问控制权限不能超过父类的访问控制权限。
父类方法如果是private，子类的覆写方法不会进行覆写操作而是相当于重新创建了一个方法。

final关键字：

定义不能被继承的类、定义不能被覆写的方法/常量。（常量一旦被定义则不可修改。）
常用于 public static final来定义全局常量。

String a = "111";
String b = "1" + "1" + "1";
String tmp = "1";
final String tmp2 = "1";
String c = "1" + tmp + "1";
String d = "1" + tmp2 + "1";
System.out.println(a==b);//true
System.out.println(a==c);//false -> tmp是变量
System.out.println(a==d);//true

面试题：

解释override和overloading的区别：

属性覆盖：父类与子类定义了相同名字的属性。本质上是子类定义了一个全新的属性，想要访问父类需要调用。

面试题：

解释super与this的区别：
this先从本类查找方法/属性，如果本类不存在查找父类。super直接查找父类。
this与super都可以进行构造方法的调用，但是this()调用的是本类构造，super()调用的是父类构造。
this与super都必须放在首行，所以不能同时出现。
this可以表示当前对象。

多态：

在继承的基础之上扩展的概念，实现父子类之间的相互转换处理。
java中多态有两种实现模式：
1.方法的多态性
-> 方法的重载
-> 方法的覆写
2.对象的多态性：父子实例的转换处理。
-> 对象的向上转型： 父类 父类实例 = 子类实例。（自动完成转换）
-> 对象的向下转型：子类 子类实例 = （子类）父类实例。（强制完成转换）子类对父类的功能进行扩充时采用向下转型。

向上转型（接收和返回的统一性）

class A{
    void print(){
        System.out.println("A");
    }
}
class B extends A{
    void print(){
        System.out.println("B");
    }
}
class C extends A{
    void print(){
        System.out.println("C");
    }
}    
public class Main{
    public static void main(String args[]){
        //上转型，优势：对参数统一设计。
        func(new B());//B
        func(new C());//C
    }
    public static void func(A a){
        a.print();
    }
}

向下转型：

在创立父类对象的基础上，将父类对象通过强制转换变成子类对象。

class A{
    void print(){
        System.out.println("A");
    }
}
class B extends A{
    void differentPrint(){
        System.out.println("B");
    }
}
public class Main{
    public static void main(String args[]){
        A a = new B();//上转型
        a.print();
        B b = (B)a;//下转型
        b.differentPrint();
    }
}

instanceof关键字

向下转型有报错的危险，所以转型前为了保证正确应该先判断，这个需要instanceof语法实现。

class A{
    void print(){
        System.out.println("A");
    }
}
class B extends A{
    void differentPrint(){
        System.out.println("B");
    }
}
public class Main{
    public static void main(String args[]){
        A a = new A();
        System.out.println(a instanceof A);//true
        System.out.println(a instanceof B);//false
        A b = new B();
        System.out.println(b instanceof A);//true
        System.out.println(b instanceof B);//true
    }
}