继承机制：是面向对象程序设计是代码可以复用的最重要手段，允许程序员在保持原有类特性的基础上进行扩展，增加新的功能，产生的新类，成为派生类/子类。继承主要解决的问题是：共性的抽取，实现代码的复用。
表示类与类的继承关系，需要借助关键字extends，语法如下：
修饰符 class 子类/派生类 extends 父类/基类/超类{
//…………
}
public class Base {
int a;
int b;
int c;
}
public class Derived extends Base{
int a; // 与父类中成员a同名，且类型相同
char b; // 与父类中成员b同名，但类型不同
public void method(){
a = 100; // 访问父类继承的a，还是子类自己新增的a？
b = 101; // 访问父类继承的b，还是子类自己新增的b?
c = 102; // 子类没有c，访问的肯定是从父类继承下来的c
}
}如果父类和子类同名方法的参数列表不同（重载），根据调用方法时传递的参数选择合适的方法访问。
如果父类和子类的同名方法原型一致，则访问子类的
super关键字的主要作用是：在子类方法中访问父类的同名成员。（只能在非静态方法中使用）
public class Base {
int a;
int b;
public void methodA(){
System.out.println("Base中的methodA()");
}
public void methodB(){
System.out.println("Base中的methodB()");
}
public class Derived extends Base{
int a;
char b;
// 与父类中methodA()构成重载
public void methodA(int a) {
System.out.println("Derived中的method()方法");
}
// 与父类中methodB()构成重写
public void methodB(){
System.out.println("Derived中的methodB()方法");
}
public void methodC(){
a = 100; // 等价于： this.a = 100;
b = 101; // 等价于： this.b = 101;
// 访问父类的成员变量时，需要借助super关键字
// super是获取到子类对象中从基类继承下来的部分
super.a = 200;
super.b = 201;
methodA(); // 没有传参，访问父类中的methodA()
methodA(20); // 传递int参数，访问子类中的methodA(int)
methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
super.methodB(); // 访问基类的methodB()
}
}子类对象构造时，需要先调用父类的构造方法，然后执行子类的构造方法。
public class Base {
public Base(){
System.out.println("Base()");
}
}
public class Derived extends Base{
public Derived(){
// super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
// 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
// 并且只能出现一次
System.out.println("Derived()");
}
}super和this都可以在成员方法中用来访问成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那么它们之间的区别是什么？
（1）相同点
（2）不同点
【普通类】
【继承关系上的执行顺序】
【注】Java中不支持多继承
组合和继承都能实现代码的复用。组合没有涉及到特殊的语法（如extend关键字），仅仅是将一个类的实例作为另一个类的属性。
一般建议：能用组合尽量用组合
通过父类类型的引用调用子类对象，向上转型是安全的
【发生向上转型的时机】
public class TestAnimal {
// 2. 函数传参：形参为父类引用，可以接收任意子类的对象
public static void eatFood(Animal a) {
a.eat();
}
// 3. 作返回值：返回任意子类对象
public static Animal buyAnimal(String var) {
if ("狗" == var) {
return new Dog("狗狗", 1);
} else if ("猫" == var) {
return new Cat("猫猫", 1);
} else {
return null;
}
}
public static void main(String[] args) {
Animal cat = new Cat("元宝", 2); // 1. 直接赋值：子类对象赋值给父类对象
Dog dog = new Dog("小七", 1);
}
}优缺点：
函数名相同、参数列表相同、返回值相同或是【协变类型】（父子类关系）
【方法重写的规则】
【动态绑定和静态绑定】
一个引用调用同一个方法，可以表现出不同的形式，这种思想称为多态。在父类的构造方法中不要调用重写的方法。
【多态实现的条件】
public class Animal(){
String name;
int age;
public Animal(String name, int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println(name + "吃饭");
}
}
public class Cat extends Animal{
public Cat(String name, int age){
super(name, age);
}
@Override
public void eat(){
System.out.println(name+"吃鱼~~~");
}
}
public class Dog extends Animal {
public Dog(String name, int age){
super(name, age);
}
@Override
public void eat(){
System.out.println(name+"吃骨头~~~");
}
}
public class TestAnimal {
// 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
// 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
// 注意：此处的形参类型必须时父类类型才可以
public static void eat(Animal a){
a.eat();
}
public static void main(String[] args) {
Animal animal1 = new Cat("元宝",2);
Animal animal2 = new Dog("小七", 1);
eat(animal1);
eat(animal2);
}
}【注】Java中所有的类默认继承Object类
