一、继承（inheritance）
继承：基于已有类创建新的类，复用（继承）已有类的方法，可以增加一些新的字段与方法。
已存在的类称为：超类(superclass)、基类(base class)、父类（parent class）
新类为：子类（subclass），派生类（derived class）、孩子类（child class）
1、继承（extend）：
在Java中，所有继承都是公共继承。使用关键字extend继承父类的所有公共方法与公共字段。
public class Manger extends Employee
{
add mothdos and fields
}
//子类通过extends关键字继承父类Employee的所有方法
2、覆盖（override）
子类定义的方法名与父类方法重名时，将覆盖父类方法。
覆盖只是对子类的方法进行重写。
实例：Manger.java，Manger类继承Employee类，并定义私有bonus字段以getBonus()，setBonus()，getInfo()等方法
package cn.edu.abc.corejava;
public class Manger extends Employee
{
private double bonus;
public Manger(String N, double S, int Year, int month, int day)
{
super(N, S, Year, month, day);
}
public double getBonus()
{
return this.bonus;
}
public void setBonus(double bonus)
{
this.bonus = bonus;
}
public static String getInfo(Manger A[])
{
String info="";
for (Manger e:A)
info +=e.getName()+"\t"+e.getBonus()+"\n";
return info;
}
public String getName()
{
return "管理员: "+super.getName();
}
public static void main(String args[])
{
Manger[] boss = new Manger[2];
boss[0] = new Manger("张某",6000,1999,1,2);
boss[1] = new Manger("李某",6000,1999,1,2);
boss[0].setBonus(1000);
boss[1].setBonus(2000);
System.out.println(getInfo(boss));
System.out.println(boss[1].getName());
}
}
注意：
1、继承为公共继承，可以增加字段、方法或覆盖方法，继承绝对不会删除任何字段与方法。
2、可以利用：super.父类方法，格式调用父类方法。
public String getName()
{
return "管理员: "+super.getName();
}//在Manger子类中定义getName方法覆盖所继承到的父类Employee的getName方法
//super.getName()这条语句调用的是父类Employee的getName方法
public static String getInfo(Manger A[])
{
String info="";
for (Manger e:A)
info +=e.getName()+"\t"+e.getBonus()+"\n";
return info;
}//e.getName()为子类的方法
Employee A = new Employee("员工1",1211,1998,11,1);
System.out.println(A.getName());
Manger B = new Manger("管理员1",123,1322,89,88);
System.out.println(B.getName());//覆盖只是对子类的方法进行重写。A.getName()仍旧调用父类Employee的方法
3、子类构造器
由于Manger类的构造器不能访问Employee的私有字段，所有必须通过super语法调用构造器初始化这些私有字段。super()语句必须是子类构造器的第一条语句。
public class Manger extends Employee
{
private double bonus;
public Manger(String N, double S, int Year, int month, int day)
{
super(N, S, Year, month, day);
}.....
}
关键字this有两个含义：一是指示隐式参数的引用，二是调用该类的其他构造器。
类似的，关键字super有两个含义：一是调用超类的方法，二是调用超类的构造器。
4、Object类
Object类是所有类的父类，是java中最高层的类，每一个类都扩展了Object，如果没有明确指出父类，Object就被认为是这个类的父类。所有的类都是Object的子类，所有任何类都可以重写Object类中的方法。
<要点>：
1、可以使用Object类型变量引用任何类型的对象
Object obj = new Employee("管理员",1234,......);
2、Object类型的变量只能用于作为各种值的一个泛型容器，要对其进行具体的操作还需要清楚其原始的类型，并进行强制转换
Employee e = (Employee)obj;
3、在Java中只有基本类型不是对象（数值，字符，布尔型），所有的数组类型均为对象。
<方法>：
1、 equals方法
"=="运算符比较两个对象引用地址是否相等，equals方法比较的是两个对象的实际内容
5、强制类型转换
向上转型、向下转型、instanceof关键字
向上转型：利用父类描述子类，将一个具体的类转换为一个抽象的类，调用所继承的公共方法，没重写调用没重写的，重写的调用重写的。
Employee Test = new Manger("abc",12,12,1,1);
格式：父类类型 父类对象 = new 子类类型 (即为构造器)
例1、Test调用getName() 
由此可得：调用所继承的公共方法，没重写调用没重写的，重写的调用重写的。
向下转型：父类转化为子类，将抽象的类转化为具体的类，例如：某个员工就是经理
将抽象类的对象转换为具体类的对象是通常是错误的，使用instanceof关键字判断其是否能相互转转换
向下转换：
Employee Test = new Manger("abc",12,12,1,1);
Manger subTest = (Manger) Test;
前提：父类对象要先引用这个子类对象
语法格式：子类类型 子类对象 = （子类类型）父类对象
instanceof关键字：
语法格式myobject instanceof ExampleClass
例2、subTest 调用子类特有方法setBonus()、getBonus()
Employee Test = new Manger("abc",12,12,1,1);//父类对象引用子类对象
if (Test instanceof Manger)//判断Test是否属于Manger类对象
{
Manger subTest = (Manger) Test;//向下转换
subTest.setBonus(1000);
System.out.println(subTest.getName()+" "+subTest.getBonus());
}else
{
System.out.println("转换失败");
}
6、阻止继承：final关键字
凡是被final关键字修饰过的内容都是不可被改变的。简称为无法修改，无法重写，无法继承
final字段：在定义时必须赋初值，且使用后无法被修改
final方法：将方法定义为final类型，可以防止子类修改父类的定义与实现方式，其中private修饰符将其方法隐式的指定为final，自然无法覆盖其父类方法
final类：不允许扩展的类被称为final类。定义final的类不能被继承，且不允许对这个类进行任何改动。如果这个类为final，则这个类中的方法均被隐式的设置为final，但其中的字段可以被设置为final或非final。
语法格式：public final class......
7、多态
一个对象变量可以指示多种实际类型的现象称为多态。多态就是同一个接口，使用不同的实例而执行不同操作。也可以理解为同一个事件发生在不同的对象上会产生不同的结果。
例如：如Student类继承了Person类，若定义Student类的对象为Tom则Tom既是Person类又是Student类。
任何父类出现的地方，我们都可以用子类来替代。
多态存在的三个必要条件：
1、继承
2、重写
3、超类引用子类的对象
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
例1、多态性的体现 Polymorphism.java
package cn.edu.abc.corejava;
public class Polymorphism {
public static void main(String args[]) {
get_class(new Student());
get_class(new Teacher());
}
public static void get_class(Person X)
{
X.work();
}
}
class Person
{
public void work(){}
}
class Student extends Person
{
public void eat()
{
System.out.println("吃饭");
}
public void work()
{
System.out.println("Student work :学习");
}
}
class Teacher extends Person
{
public void work()
{
System.out.println("Teacher work :上课");
}
}
Person类有两个子类：Student，Teacher，均重写了父类的work方法，work()为同一事物，而同一个work方法在Student类下表现为“学习”，而在Teacher类下表现为“上课”，这就体现了同一个事件发生在不同的对象上会产生不同的结果，这就是多态。
8、抽象类
使用abstract关键字定义的类为抽象类，使用这个关键字定义的方法称为抽象方法。抽象类没有具体方法体，这个方法本身也没有任何意义，除非它被重写。实际上抽象类除了被继承无任何意义。
只要类中有一个抽象方法，此类就应该被标记为抽象类。
为什么要设置抽象类，一般类不是已经够用了吗？。一般类里定义的方法，子类也可以覆盖，没必要定义成抽象的啊。
其实不是说抽象类有什么用，一般类确实也能满足应用，但是现实中确实有些父类中的 方法确实没有必要写，因为各个子类中的这个方法肯定会有不同，所以没有必要再父类里写。当然你也可以把抽象类都写成非抽象类，但是这样没有必要。
其抽象类只能被继承，无法被实例化，即无法创建对应的实例。在抽象类中可以有非抽象方法与抽象方法，但如果有抽象方法该类只能设定为抽象类。
写成抽象类，这样别人看到你的代码，或你看到别人的代码，你就会注意抽象方法，而知道这个方法是在子类中实现的，所以，有个提示作用。
9、接口
接口是抽象方法的集合。接口中的所有方法都没有方法体，接口只是一种形式，接口自身不能做任何事情。接口修饰符为public，不能使用其他的修饰符，在接口定义的任何字段都是static和final。
语法格式：
public interface Paintable{ //定义接口方法可省略public abstract关键字
void age();
}
一个类继承父类的同时再实现一个接口：
语法格式：
public class parallelogram(子类） extends Quadrangle(超类) implements Paintale {
.........
}
1、一个类可以继承多个接口 class 类名 implements 接口1、接口...
2、一个接口可以继承另一个接口 interface intf1 extends intf2
应该注意的是继承接口的子类必须在类中实现接口中的方法。接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须宣告为抽象类（Abstract Class）。如下例
定义接口中的方法可以省略public abstract关键字
/*解释*/
我们定义一个Age接口，并且定义一个接口方法age()。
（实现接口的类）子类Student、Teacher继承超类Person与接口Age，此时子类中必须实现接口中的方法或将子类其方法设置为抽象类
/*对接口的理解*/
接口类似于招牌，如“做面的流程”（接口A），接口A中定义了“切面”这个方法。一个子类继承了接口A，就必须实现这个接口中的方法，即也要实现“切面”这个方法（可以理解为要想继承“做面的流程”就也必须学会“切面”）。虽然这个子类可以不继承该接口也能实现“切面”方法，如餐厅类也可以自己定义“切面”方法，但显然是不明显的，没有接口那么明确，也增加了代码量。
抽象类和接口的对比
