虽然说java中的面向对象的概念不多，但是具体的细节还是值得大家学习研究，java中的继承实际上就是子类拥有父类所有的内容（除私有信息外），并对其进行扩展。下面是我的笔记，主要包含以下一些内容点：
- 构造方法
- 重写和重载
- final关键字
- new的背后（内存分析）
- 理解方法调用
1. 构造方法
正如我们所知道的，构造方法的方法名与类名相同，主要的作用是实现对实例对象的初始化工作，实际上每个子类的构造方法中的第一行默认是调用了父类的构造函数，而父类继续向上调用直至Object类，然后返回。
/*这是父类*/
public class Base {
public Base(){
System.out.println("i am the base");
}
}
/*这是子类*/
public class Child extends Base {
public Child(){
//super();隐式调用父类默认无参构造器
System.out.println("i am the child");
}
}
/*执行程序*/
public class Test {
public static void main(String[] args){
Child c = new Child();
}
}输出结果：
i am the base
i am the child当然，super这个关键字还有第二个作用，显式调用父类方法（不只是构造方法，普通实例方法也是可以直接调用的）。
public class Base {
//父类中有个sayHello方法
public void sayHello(){
System.out.println("hello base");
}
}
public class Child extends Base {
//子类通过super关键字显式调用
public void show(){
super.sayHello();
}
}那如果我们想要显式调用子类中的其他的构造方法该怎么办呢？
可以使用this 关键字 或者显示使用super
public class Child extends Base {
private String name;
private int age;
private String address;
//一个参数的构造方法
public Child(String name){
this.name = name;
}
//三个参数的构造方法
public Child(String name,int age,String address){
this(name);//显式调用其他构造方法 super(name)
this.age = age;
this.address = address;
}
}为什么要这么做呢？因为不是每个实例对象都需要传所有的参数，例如，大家在注册qq账号时候，有些是必填的信息，有的是可选填的，这样不同的人在注册时就会调用不同的构造函数，这样调用参数多的构造方法就没必要再为每个变量赋值，可以使用this调用其他的构造方法，减轻代码的冗余程度。
2. 重载和重写
下面说说方法的重载和重写的区别。首先大家需要了解什么是方法的签名，方法的名字和参数列表叫做方法的签名。方法的重载就是指两个或以上具有相同方法名但方法的参数存在某些差异的方法之间的这种关系叫做方法的重载。
所谓方法的参数列表的差异，主要是参数的类型差异和参数的个数差异。
1、public void sayHello(){}
2、public void say(){}
3、public void sayHello(String name){}
4、public void sayHello(int age){}
5、public void sayHello(String name,int age){}
如上所示，1和2肯定不会构成重载，构成重载的前提是具有相同的方法名，1和3和4和5构成函数重载，他们之间要么参数类型不同，要么参数个数不同。
函数的重载可能和继承关系并不大，但方法的重写和继承关系密切。方法的重写就是指两个方法之间具有相同的签名，也就是两个方法一模一样，只是一个出现在父类中一个出现在子类中
public class Base {
//父类中的sayHello方法
public void sayHello(){
System.out.println("hello base");
}
}
public class Child extends Base {
//子类中的sayHello方法
public void sayHello(){
System.out.println("hello child");
}
}
public class Test {
public static void main(String[] args){
Base b = new Child();
b.sayHello();
}
}输出结果：
hello child本例中涉及多态相关知识，初学者不懂可以跳过，但是需要知道，本例中父类的sayHello方法和子类的sayHello方法是一模一样的，子类继承过来之后觉得不理想又将其重写，重写完之后子类中就相当于覆盖了父类的这个方法，每次调用时就直接调用了自己重写的方法，看不见父类的方法。
总结一下：方法的重载，方法与方法之间是不一样的，而方法的重写实际上是一种方法的覆盖，子类覆盖父类的方法使父类方法在子类中不可见（实际上是可以使用super显式调用的，本节暂时不讨论）。
3.final关键字
final关键字既可以修饰类也可以修饰方法，也能修饰变量，但是具有不同的意义。被final修饰的类表示为不可继承特性，不允许子类继承，也就是不让子类再对其进行扩展。例如，jdk中的String类就是被final修饰的，不可变类有很多好处，譬如它们的对象是只读的，可以在多线程环境下安全的共享，不用额外的同步开销等等。
被final修饰的方法表示此方法在被子类继承之后是不允许重写的，例如有些方法不希望被子类重写修改就可以使用final修饰他，在java中常量也是使用final来修饰的，例如：public final String name;，此变量一旦被赋值就不能再改变其内容了。
我们介绍了java中的构造方法，了解了关键字this和super在继承中所起到的作用，this可以显式调用重载的构造方法，super可以显式的调用父类中的任意可见方法。了解方法重载和重写的区别，知道了关键字final的作用，本篇将以一段代码介绍实例化对象时内存的状态。
如果你能看懂以下代码，那本篇你就不用浪费时间了。
/*这是父类*/
public class Base {
public Base(){
print();
}
public void print(){
}
}
//这是子类
public class Child extends Base {
private int a = 2;
public void print(){
System.out.println(a);
}
}
//main函数
public class Test2 {
public static void main(String[] args){
Base b = new Child();
b.print();
}
}输出结果：
0
24. new关键字的背后
我们知道在java中所有的方法都是在类中的，包括main方法。所以程序开始做的第一件事情是：加载类，就是将类的信息加载到内存中，一个类的信息主要有：
- 静态变量
- 静态初始化代码块
- 静态方法
- 实例变量
- 实例初始化代码块
- 实例方法
- 对继承自父类的信息的引用
类的加载过程如下：
- 首先在内存堆中开辟内存以存放当前类
- 对类中的属性赋默认初始值(int默认为0，boolean默认为false，引用类型默认为null)
- 调用构造函数进行对象初始化（首先默认执行super调用父类构造函数）
- 父类构造函数初始化完成之后回到子类完成子类的显式初始化
- 最后将该对象赋值给引用对象
下面就介绍一下，Base b = new Child();这条语句，内存的实时状态。
内存主要有栈和堆构成，栈中主要存放局部变量，b这个引用就存放其中，堆中主要存放引用的实际内容
首先将Base加载到堆中的方法区，这就相当于一个模板，以后new对象时候就按照此模板来创建对象，然后将变量名b存放到栈中，
执行new语句，发现Child类并未加载到方法区，于是加载Child类到方法区，然后根据方法区中的Child类的模板new出child类的实例对象，它具有模板中所有信息，
接着执行child对象的构造方法，默认创建父类对象并执行父类的构造方法实现父类初始化，完成之后回到子类实现子类的初始化
最终完成对象的创建，将b引用堆中对象。
以上便是Base b = new Child();背后所做的事情
5. 方法调用的细节
如果没有继承的概念，方法的调用就是非常简单的，但是有了继承的概念之后，就需要搞清楚检索方法的过程，jvm是怎么找到我们想要调用的方法的，然后执行的呢？
/*这是父类*/
public class Base {
private String name = "walker";
public void sayHello(){
System.out.println("hello child");
}
public void showName(){
System.out.println("my name is " + this.name);
}
}
//这是子类
public class Child extends Base {
public void sayHello(){
System.out.println("hello child");
}
}
//调用main函数
public class Test2 {
public static void main(String[] args){
Base b = new Child();
b.sayHello();
b.showName();
}
}输出结果：
hello child
my name is walker这下我们从b.sayHello()说起，首先查看b的实际类型（发现是child类型），于是从child实例对象中查找此方法，找到了，然后直接执行输出hello child本条语句执行完成，接下来执行b.showName();，依然从child对象中查找，没有找到，于是jvm深入到父类对象中，找到并执行输出结果。
总结下，java中总是从当前对象的实际类型出发搜索方法，子类中没有找到的话就会深入父类中搜索，如果父类中也没有找到就会报错
之后为了改进这种搜索效率，使用了虚方法表，也就是将每个类的所有方法（包含父类的方法引用）存放到一张虚拟表中，每次调用方法时候，查找表以加快效率。
最后我们根据以上所有内容，解析本文刚开始的一段代码。
第一句：Base b = new Child();，加载Base类，创建局部变量b存放栈中，发现child类未加载于是去加载child类，按照以上介绍的加载过程，首先开辟了内存以存放类的内容，将private int a;初始化为0。执行new操作，并调用child类的构造方法,转去调用Base类的构造方法，调用函数print,于是判断出此对象的实际类型是child，在child类中查找print找到并执行输出还未显式初始化的a=0，然后返回Base构造方法中，结束父类构造方法，转回执行child构造方法，结束child构造方法完成属性的显式初始化，a=2，结束本条语句。
第二句：b.print();再次搜索print执行输出2，结束。
理解 初始化顺序和原理，Base b = new Child(); b.print(); 初始化完成后 先会在 Child 里找print 方法 如果没有就找Base 类，但在new Child时初始化Base时调用print 方法就会打印出Base 中的数。
