一、继承
父类的成员变量和成员方法都可以被子类继承。当然父类中的成员变量必须是public 和protected的。
成员变量：
当子类中含有和父类相同名称的成员变量，则在子类中访问时，访问的是子类的成员变量。可以用super.XXX访问父类中的成员变量XXX 。用this.XXX访问子类中的成员变量
成员方法：
子类中默认含有父类的成员方法。当子类中的某个成员方法和父类的成员方法相同时（名称，参数），表示重写了父类的方法，子类调用时，调用的是覆盖后的方法。子类还可以使用父类特有的方法
public class test {
public static void main(String[] args) {
B b=new B();
b.show();//调用的是子类中的show方法，父类的被覆盖
b.display();//子类特有的方法
b.other();//子类继承下来的父类方法，没有重写
}
}
class A{
protected int a=3;
public void show(){
System.out.println("a="+a);
}
public void other(){
System.out.println("This is an other father's function");
}
}
class B extends A{
private int a=4;
public void show(){
System.out.println("A::a="+super.a);
System.out.println("B::a="+this.a);
}
public void display(){
System.out.println("display");
}
}
运行结果：
A::a=3
B::a=4
display
This is an other father's function
二、多态
1.向上转型
简单来说，向上转型就是用一个父类类型的引用变量来引用一个子类的对象。
Father son=new Son();
还是上面的例子，改成这样：
A b2=new B();
b2.show();
//b2.display();报错
b2.other();
System.out.println(b2.a);
结果：
A::a=3
B::a=4
This is an other father's function
3
需要注意的地方就是：
①子类特有的方法不能访问，如这里面的display方法
②son访问相同的成员变量时，访问的是父类的变量（如果可以访问的话）
③son可以访问父类特有的方法（因为子类继承了）
public class test {
public static void main(String[] args) {
B c=new C();
c.show(c);
A b=new B();
b.show(new A());
}
}
class A{
public void show(A a){
System.out.println("This is A");}
}
class B extends A{
public void show(B b){
System.out.println("This is B");
}
public void show(A a){
System.out.println("This is B1");}
}
class C extends B{
public void show(B b){
System.out.println("This is C1");
}
public void show(A a){
System.out.println("This is C2");
}
public void show(){};
}
运行结果：
This is C1
This is B1
看完这篇博客重新认识java（五） ---- 面向对象之多态（向上转型与向下转型），应该能很轻松的得出答案。
最重要的一个结论就是这个：
继承链中对象方法的调用的优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
向上转型有什么意义呢？
直接用Son son=new Son();也可以访问子类重写的方法啊。我的理解是，用向上转型可以方便代码的重用与修改。
比如现在有个函数要接收一个对象，void fun(className XXX);假如这是个动物类，那么狗，猫之类的对象传过来，就是一个向上转型，在函数中调用的要么是动物类（父类）特有的方法，要么是狗，猫（子类）重写覆盖的方法，狗猫自己特有的方法不能访问。假如现在多个鸡这个类，那么只要重写鸡里面的方法（覆盖父类的方法）。
如果用这种：void fun(Dog dog);这样只能传递Dog对象，如果Cat要实现这个fun,那么需要重写这个fun-->void fun(Cat cat);,代码显得十分的冗余。用向上转型可以减少代码量。
2.向下转型
向上转型是无法调用子类特有的方法，当我们需要使用子类特有的方法时，我们需要用到向下转型，在集合那块用的挺多。
例子：
import java.util.ArrayList;
import java.util.List;
public class test {
public static void main(String[] args) {
List<A> list=new ArrayList<A>();//向上转型
B b1=new B();
B b2=new B();
C c1=new C();
C c2=new C();
list.add(b1);
list.add(b2);
list.add(c1);
list.add(c2);
System.out.println("------------------向上转型------------------");
for(A e:list){
//只能调用父类有的方法
e.show();// 子类覆盖父类的方法后，调用的事覆盖后的方法
e.displayA();//没有覆盖的方法
}
System.out.println("------------------向下转型----------------------");
B b=(B)list.get(0);//强制转换成子类类型，这样可以调用子类的特有的方法
b.display();
}
}
class A{
public void show(){
System.out.println("This is A_Show");
}
public void displayA(){
System.out.println("This is A_Display");
}
}
class B extends A{
// 覆盖父类的方法
public void show(){
System.out.println("This is B_Show");
}
// 特有的方法
public void display(){
System.out.println("This is B_display");}
}
class C extends A{
// 覆盖父类的方法
public void show(){
System.out.println("This is C_Show");
}
// 特有的方法
public void reveal(){
System.out.println("This is C_Reveal");
}
}
三、总结
向上转型：只关注子类覆盖父类的方法。体现了多态（不同的儿子有不同的表现形式）
向下转型：重新获得子类特有的方法
参考资料：
1.重新认识java（五） ---- 面向对象之多态（向上转型与向下转型）
2.Java 初始化顺序
3.java向下转型的意义
