1、面向对象的基本要素：封装、继承和多态。
封装的目的是隐藏事务内部的实现细节，以便提高安全性和简化编程。封装提供了合理的边界，避免外部调用者接触到内部的细节。从另一个角度看，封装这种隐藏，也提供了简化的界面，避免太多无意义的细节浪费调用者的精力。
继承是代码复用的基础机制，类似于我们对于马、白马和黑马的归纳总结。但要注意，继承可以看做是非常紧耦合的一种关系，父类代码修改，子类行为也会变动。在实践中，过度滥用继承，可能会起到反效果。
多态，你可能立即会想到重写（override）和重载（overload）、向上转型。简单说，重写是父子类中相同名字和参数的方法，不同的实现；重载则是相同名字的方法，但是不同的参数，本质上这些方法的签名是不一样的。
多态的存在有三个前提:
1.要有继承关系
2.子类要重写父类的方法
3.父类引用指向子类对象
多态成员访问的特点：
1）成员变量
编译看左边(父类)，运行看左边(父类)
2）成员方法
编译看左边(父类)，运行看右边(子类)
3）静态方法
编译看左边(父类)，运行看左边(父类)
只有非静态的成员方法，编译看左边，运行看右边
对于创建的对象是向上转型还是向下转型：
向上转型：只能调用与父类引用中父类相同的方法，不能调用子类中自己定义的方法；如果在子类中重写了，则调用的是子类中的方法；
向下转型：可以调用父类中的方法，也可以调用子类中自己定义的方法；如果子类中重写了父类的方法，调用的是子类中重写的方法；
那么多态有什么弊端呢？有的，即多态后不能使用子类特有的属性和方法。
如果想使用子类特有的属性和方法，则可以进行向下转型，将父类的引用强制转为子类型。
2、Java中为什么静态方法不能被重写？
首先理解重写的意思，重写就是子类中对父类的实例方法进行重新定义功能，且返回类型、方法名以及参数列表保持一致，且对重写方法的调用主要看实际类型。实际类型如果实现了该方法则直接调用该方法，如果没有实现，则在继承关系中从低到高搜索有无实现。那么问题又来了，为什么只能对实例方法才能重写？我头好晕，这两个问题在这互相推脱责任。
为了满足里式替换原则，重写有有以下两个限制：
* 子类方法的访问权限必须大于等于父类方法；
* 子类方法的返回类型必须是父类方法返回类型或为其子类型。
使用 @Override 注解，可以让编译器帮忙检查是否满足上面的两个限制条件。
理解三个概念：静态类型，实际类型，方法接受者。
Person student= new Student();
student.work();
静态类型就是编译器编译期间认为对象所属的类型，这个主要根据声明类型决定，所以上述Person就是静态类型
实际类型就是解释器在执行时根据引用实际指向的对象所决定的，所以Student就是实际类型。
方法接受者就是动态绑定所找到执行此方法的对象，比如student。
还要理解类编译的class文件中字节码的方法调用指令。
（1）invokestatic：调用静态方法
（2）invokespecial：调用实例构造器方法，私有方法。
（3）invokevirtual：调用所有的虚方法。
（4）invokeinterface：调用接口方法，会在运行时再确定一个实现此接口的对象。
（5）invokedynamic：先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法。
非虚方法：不能被重写或者说覆盖的方法，指的是构造方法、静态方法、私有方法和final 修饰的方法。
虚方法：则是能被重写的方法，一般指的是实例方法。
栗子：
class Demo01{
public void method1(){
System.out.println("This is father non-static");
}
public static void method2(){
System.out.println("This is father static");
}
}
public class Demo02 extends Demo01{
public void method1(){
System.out.println("This is son non-static");
}
public static void method2(){
System.out.println("This is son static");
}
public static void main(String[] args){
Demo01 d1= new Demo01();
Demo02 d2= new Demo02();
Demo01 d3= new Demo02(); //父类引用指向子类对象
d1.method1();
d1.method2();
d2.method1();
d2.method2();
d3.method1();
d3.method2();
}
}
运行结果：
对于这样的运行结果前5行应该没什么疑问，用常规的思维就能理解，可是最后一条，what?说好的动态绑定呢，Are you kidding
me？No,这里没有发生动态绑定了，问题又来了，为什么静态方法不发生动态绑定？动态绑定到底发生了什么？简直是头脑风暴，说实话我也是蒙蒙的，接下来可能正确也可能不正确，但是八九不离十。
分析
首先看看上面main 方法的字节码：
// access flags 0x9
public staticmain([Ljava/lang/String;)V
L0
LINENUMBER 19 L0
NEW com/learn/pra06/Demo01
DUP
INVOKESPECIAL com/learn/pra06/Demo01. ()V
ASTORE 1
L1
LINENUMBER 20 L1
NEW com/learn/pra06/Demo02
DUP
INVOKESPECIAL com/learn/pra06/Demo02. ()V
ASTORE 2
L2
LINENUMBER 21 L2
NEW com/learn/pra06/Demo02
DUP
INVOKESPECIAL com/learn/pra06/Demo02. ()V
ASTORE 3
L3
LINENUMBER 22 L3
ALOAD 1
INVOKEVIRTUAL com/learn/pra06/Demo01.method1 ()V
L4
LINENUMBER 23 L4
INVOKESTATIC com/learn/pra06/Demo01.method2 ()V
L5
LINENUMBER 24 L5
ALOAD 2
INVOKEVIRTUAL com/learn/pra06/Demo02.method1 ()V
L6
LINENUMBER 25 L6
INVOKESTATIC com/learn/pra06/Demo02.method2 ()V
L7
LINENUMBER 26 L7
ALOAD 3
INVOKEVIRTUAL com/learn/pra06/Demo01.method1 ()V
L8
LINENUMBER 27 L8
INVOKESTATIC com/learn/pra06/Demo01.method2 ()V
L9
LINENUMBER 28 L9
RETURN
L10
L+number 对应就是main方法体中每一行，我们可以清晰的看见代码执行的指令，简直大爱，有种相见恨晚的赶脚。
Demo01 d1= new Demo01();这个语句将会在运行期发生什么呢？结合我们前期准备学的那几个指令集。查看以上的字节码发现：INVOKESPECIAL
com/learn/pra06/Demo01.<init> ()V 请问将会调用Demo01的构造函数，这个毋庸置疑。同理L1也是如此。
Demo01 d3= new Demo02();虽然声明类型为父类，但实际new的时候是子类，同样字节码也对应如此。INVOKESPECIALcom/learn/pra06/Demo02. ()V
d1.method1();这个语句是应该是对象调用其实例方法，字节码也很好说明了这一点：INVOKEVIRTUAL
com/learn/pra06/Demo01.method1 ()V此处用了INVOKEVIRTUAL，则代表调用虚方法，并且此方法的引用存在方法表中（这个待会再说），只用INVOKEVIRTUAL指令会去方法表寻找要调用方法的引用。
d1.method2();这句是对象调用静态方法，字节码为：INVOKESTATIC com/learn/pra06/Demo01.method2 ()V此方法则是直接调用方法区中静态方法，无需经过方法表，这也就解释了静态方法的执行只看静态类型，而与实际类型无关，又因为重写的方法调用看的是实际类型，所以静态方法不能被重写。d2的两个方法调用解释与d1相同。
重点是d3方法的调用过程，d3.method1();字节码：INVOKEVIRTUAL
com/learn/pra06/Demo01.method1 ()V运用了INVOKEVIRTUAL指令，说明运行期间会到方法表中去调用真实指向的方法，因为method01可能被重写，所以编译器期间标明运行时应调用method1所在的方法表中位置存的真正方法的引用。因为method01方法被Demo02重写，所以方法表中原先存父类method01方法的引用被改写成子类的method01方法的引用，所以在运行时根据INVOKEVIRTUAL指令找到的method01的方法是子类的。
那么d3.method2();通过查看字节码发现：INVOKESTATIC com/learn/pra06/Demo01.method2 ()V用到INVOKESTATIC ，不能访问方法表，而是直接访问的父类的method2的，所以运行时调用就是父类的静态方法。
编译时把对象的静态类型（声明类型）作为该方法的接受者。运行时则根据指令集再进行更改。
INVOKEVIRTUAL指令流程：
package com.learn.pra06;
public class ClassReference {
static class Person {
@Override
public String toString(){
return "I'm a person.";
}
public void eat(){
System.out.println("Personeat");
}
public void speak(){
System.out.println("Personspeak");
}
}
static class Boy extends Person{
@Override
public String toString(){
return "I'm a boy";
}
@Override
public void speak(){
System.out.println("Boyspeak");
}
public void fight(){
System.out.println("Boyfight");
}
}
static class Girl extends Person{
@Override
public String toString(){
return "I'm a girl";
}
@Override
public void speak(){
System.out.println("Girlspeak");
}
public void sing(){
System.out.println("Girlsing");
}
}
public static void main(String[] args) {
Person boy = new Boy();
Person girl = new Girl();
System.out.println(boy);
boy.eat();
boy.speak();
System.out.println(girl);
girl.eat();
girl.speak();
}
}
执行结果：
由于Boy 和Girl 没有重写父类Person eat方法，所以会调用父类的eat方法。
字节码：
public static main([Ljava/lang/String;)V
L0
LINENUMBER 47 L0
NEW com/learn/pra06/ClassReference$Boy
DUP
INVOKESPECIAL com/learn/pra06/ClassReference$Boy. ()V
ASTORE 1
L1
LINENUMBER 48 L1
NEW com/learn/pra06/ClassReference$Girl
DUP
INVOKESPECIAL com/learn/pra06/ClassReference$Girl. ()V
ASTORE 2
L2
LINENUMBER 49 L2
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 1
INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
L3
LINENUMBER 50 L3
ALOAD 1
INVOKEVIRTUAL com/learn/pra06/ClassReference$Person.eat ()V
L4
LINENUMBER 51 L4
ALOAD 1
INVOKEVIRTUAL com/learn/pra06/ClassReference$Person.speak ()V
L5
LINENUMBER 53 L5
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
ALOAD 2
INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
L6
LINENUMBER 54 L6
ALOAD 2
INVOKEVIRTUAL com/learn/pra06/ClassReference$Person.eat ()V
L7
LINENUMBER 55 L7
ALOAD 2
INVOKEVIRTUAL com/learn/pra06/ClassReference$Person.speak ()V
L8
LINENUMBER 57 L8
RETURN
L9
很明显在L2处，编译器会将根类Object的toString 方法的引用写入class文件，说明编译器会将祖先的方法引用写入，而非近亲。
L3,L4,L6,L7都用到了INVOKEVIRTUAL，到底流程是怎么样的呢？
首先看看方法表在内存的模型：
通过看Girl和Boy方法表可以看出继承的方法从头到尾开始排列，并且方法引用在子类的中都有固定索引，即都有相同的偏移量；若子类重写父类某个方法，就会使子类方法表原先存父类的方法引用变成重写后方法的引用，到这就应该理解为什么可以根据对象类型而调用到正确的方法，关键就在于方法表。
下面以girl.speak为例，看看INVOKEVIRTUAL指令流程。
解说图：
1. 首先INVOKEVIRTUAL
com/learn/pra06/ClassReferencePerson.speak()V中，根据com/learn/pra06/ClassReferencePerson.speak ()V在常量池中找到该方法的偏移量
2. 查看Person的方法表，得到speak方法在该方法表的偏移量（假设为15），这样就得到该方法的直接引用。
3. 根据this判断出该引用指的是Girl实例
4. 然后去找Girl实例的方法表，根据上面的偏移量在方法表中找到该方法引用，因为该方法引用的值在类加载根据是否重写了方法已经确定了正确的方法引用，所以我们这里就可以直接调用该方法。
为什么静态方法不能隐藏实例方法？
静态方法的调用的是通过在编译器静态绑定的，而实例方法的调用是在运行时动态绑定的，2者的调用的方式不同，所以二者只能存在其一，否则会存在歧义！
总结
总体流程就是：编译器将类编译成class文件，其中方法会根据静态类型从而将对应的方法引用写入class中，运行时，JVM会根据INVOKEVIRTUAL 所指向的方法引用在常量池找到该方法的偏移量，再根据this找到引用类型真实指向的对象，访问这个对象类型的方法表，根据偏移量找出存放目标方法引用的位置，取出这个引用，调用这个引用实际指向的方法，完成多态！
3、接口和抽象类
抽象类：
要注意一个问题：在《JAVA编程思想》一书中，将抽象类定义为“包含抽象方法的类”，但是后面发现如果一个类不包含抽象方法，只是用abstract修饰的话也是抽象类。也就是说抽象类不一定必须含有抽象方法。个人觉得这个属于钻牛角尖的问题吧，因为如果一个抽象类不包含任何抽象方法，为何还要设计为抽象类？所以暂且记住这个概念吧，不必去深究为什么。
包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别：
1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。
2）抽象类不能用来创建对象；
3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。
抽象类大多用于抽取相关Java类的共用方法实现或者是共同成员变量，然后通过继承的方式达到代码复用的目的。
接口：
接口是对行为的抽象，它是抽象方法的集合，利用接口可以达到API定义和实现分离的目的。
接口不能实例化；
接口中可以含有变量和方法。但是要注意，接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关键字，比如private、protected、static、final等修饰会报编译错误）。
Java8在接口中引入了默认方法，通过在方法前加上default关键字就可以在接口中写方法的默认实现。这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类。
两者的区别：
语法层面上的区别：
1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract方法； ---在java8中接口已经支持默认方法
2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
4）一个类只能继承一个抽象类，使用extends关键字；而一个类却可以实现多个接口，使用implements关键字。
设计层面上的区别
1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。
2）设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。
3）抽象类提供了一种 IS-A 关系，那么就必须满足里式替换原则，即子类对象必须能够替换掉所有父类对象。而接口更像是一种 LIKE-A 关系，它只是提供一种方法实现契约，并不要求接口和实现接口的类具有 IS-A 关系。
使用选择：
使用接口：
需要让不相关的类都实现一个方法，例如不相关的类都可以实现 Compareable 接口中的 compareTo() 方法；
需要使用多重继承。
使用抽象类：
需要在几个相关的类中共享代码。
需要能控制继承来的成员的访问权限，而不是都为 public。
需要继承非静态和非常量字段。
在很多情况下，接口优先于抽象类。因为接口没有抽象类严格的类层次结构要求，可以灵活地为一个类添加行为。并且从 Java 8 开始，接口也可以有默认的方法实现，使得修改接口的成本也变的很低。
4、内部类
广泛意义上的内部类一般来说包括这四种：成员内部类、静态内部类、局部内部类和匿名内部类。
成员内部类的定义为位于另一个类的内部，作为另一个类的成员：
1）成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
2）当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
外部类.this.成员变量
外部类.this.成员方法
3）在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问，而创建成员内部类的对象，前提是必须存在一个外部类的对象：
Outter outter = new Outter();
Outter.Inner inner = outter.newInner(); //必须通过Outter对象来创建
inner.成员变量
inner.成员方法
4）内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。
静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法。
Outter.Inner inner = new Outter.Inner();
局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
匿名内部类基本语法：
一个匿名类由以下几个部分组成：
1）new操作符
2）Runnable：接口或类名称。这里还可以填写抽象类、普通类的名称。
3）()：这个括号表示构造函数的参数列表。由于Runnable是一个接口，没有构造函数，所以这里填一个空的括号表示没有参数。
4）{...}：大括号中间的代码表示这个类内部的一些结构。在这里可以定义变量名称、方法。跟普通的类一样。
例如在多线程实现Runnable接口时经常使用：
public static void main(String[] args) throwsInterruptedException
{
for (int i = 0; i < 4; i++) {
service.execute(new Runnable() {
@Override
public void run() {
......
}
}
}
}
