继承性：继承性严格来讲就是指扩充一个类已有的功能。
class 子类 extends 父类 {}
1）对于extends而言，应该翻译为扩充，但是为了方便理解方便，统一将其称为继承；
2）子类又被称为派生类
3）父类又被称为超类(super class).
继承的限制：
1）java不允许多重继承（一个人只能有一个父亲，不能有多个父亲），但是允许多层继承（最多三层）。
多层继承：
class A{}
class B extends A {} //B类继承A类
class C extends B {} //C类继承B类
2）子类在继承父类时，严格来讲会继承父类中的全部操作，但是对于所有的私有操作属于隐式继承，而所有的非私有操作属于显示继承。
class A{
private String msg;
public void setMsg(String msg){
this.msg = msg;
}
public String getMsg(){
return this.msg;
}
}
class B extends A{
}
public class Demo{
public static void main(String args[]){
B b = new B();
b.setMsg("Hello");
System.out.print(b.getMsg());
}
}
B类里面不能针对msg属性进行直接访问，因为它在A类中属于私有声明，只能利用getter或setter方法间接地进行私有属性的访问。
3）在子类对象构造前进行一定会默认调用父类的构造（默认使用无参构造），以保证父类的对象先实例化，子类对象化后实例化。（我们每一个人都有自己的父母，在正常情况下，父母一定都要比我们先出生。在程序中，实例化就表示对象的出生，所以子类前（实例化前）父类对象一定要先出生（默认调用父类构造，实例化父类对象）。
覆写：当子类定义了和父类的方法名称、返回值、参数类型及个数完全相同的方法时，就称为方法的覆写。
class A {
public void fun(){ //在父类中定义的方法
System.out.println("A类中的fun()方法。");
}
}
class B extends A { //定义子类，此时没有覆写任何方法
public void fun(){ //此处为覆写
System.out.println("B类中的fun()方法。");
}
}
public class TestDemo {
public static void main(String args[]){
B b = new B(); //实例化子类对象
b.fun(); //调用fun方法，此时方法被覆写，所以调用被覆写过的方法
}
}
程序执行结果：B类中的fun方法。
本程序在B类中定义了一个与A类完全一样的fun方法，所以当实例化B子类对象，调用fun()方法时，将不再执行父类的方法，而是直接调用已经被子类覆写过的方法。
一个类可能会产生多个子类，每个子类都可能会覆写父类中的方法，这样一个方法就会根据不同的子类有不同的实现效果。
1）什么时候会使用到方法覆写？
当子类发现功能不足时可以考虑覆写。
如果现在发现父类中的方法名称功能不足（不适合本子类对象操作），但是又必须使用这个方法名称是，就需要采用覆写这个概念。
就好比动物都有一个跑的动作，但是狗是四条腿跑，而人是两条腿跑。这个时候父类定义此功能时假设值考虑了两条腿跑，则狗这个类对于跑的功能就会出现不足，那么狗的类自然会需要对这一方法进行功能上的扩充，这个时候自然就需要使用到覆写这一概念。
2）被子类所覆写的方法不能拥有比父类更严格的访问控制权限。
权限：public <default(默认，什么都不写）<private（最严格）,父类public ，那么子类只能是public，父类default,子类public和public。
3）方法重载和覆写的区别？
1.名字，重载：Overloading,覆写Override
2.发生范围，重载发生在一个类里面，覆写发生在继承关系中
3.定义，重载是方法名称相同，参数类型及个数不同。 覆写是方法名称相同、参数的类型、个数相同、方法的返回值相同。
4.权限，重载没有权限限制，被覆写的方法不能拥有比父类更为严格的访问控制权限。
4）一旦有了覆写后会发现，默认情况下子类所能调用的一定是被覆写过的方法。为了能够明确地由子类调用父类中已经被覆写的方法，可以使用super.方法()来进行访问。
this与super的区别：
this ：调用本类构造、本类方法、本类属性，表示当前对象，super：子类调用父类构造、父类方法、父类属性
final关键字
1）使用final定义的类不能再有子类，即：任何类都不能继承以final声明的父类。
2）使用final定义的方法不能被子类所覆写。在一些时候，由于父类中的某些方法具备一些重要特征，并且这些特征不希望被子类破坏（不能够覆写），就可以在方法的声明处加上final，意思是子类不要去破坏这个方法的原本作用。
3）使用final定义的变量就成了常量，常量必须在定义的时候设置好内容，并且不能修改。常量名称要用大写字母，约定俗成。
多态性：
方法的多态性：重载和覆写
对象的多态性：父子类对象的转化
向上转型：子类对象变为父类对象，格式：父类 父类对象 = 子类实例，自动转换；
（对象向上转型的特点，不要看类名称，而要看实例化对象的类，整个操作中根本不需要关心对象的声明类型，关键在于实例化新对象时所调用的是哪个子类的构造，如果方法被子类所覆写，调用的就是被覆写过的方法，否则就调用父类中定义的方法。这一点与方法覆写的执行原则是完全一致的。
向下转型：父类对象变成子类对象，格式：子类 子类对象 = （子类）父类实例，强制转换；
向下转型必须发生向上转型后，才可以发生向下转型。
对象多态有什么用？
在实际开发过程中，对象的向上转型的主要意义在于参数的统一，也是最为主要的用法，而对象的向下转型指的是调用子类的个性化操作方法。
抽象类：
抽象类就是指在普通类的结构里面增加抽象方法的组成部分，抽象方法指的是没有方法体的方法，同时抽象方法还必须使用abstract关键字进行定义。拥有抽象方法的类一定属于抽象类，抽象类要使用abstract声明。
抽象类只是比普通类多了抽象方法的定义，其他结构与普通类完全一样。
如果想使用抽象类必须遵守如下原则：
1）抽象类必须有子类，即每一抽象类一定要被子类所继承（使用extends关键字），但是在java中每一个子类只能够继承一个抽象类。
2）抽象类的子类（子类不是抽象类）必须覆写抽象类中的全部抽象方法（强制子类覆写）；
3）依靠对象的向上转型概念，可以通过抽象类的子类完成抽象类的实例化对象操作。
4）抽象类中依然可以定义内部的抽象类，而实现的子类也可以根据选择是否定义内部类来继承抽象内部类。
abstract class A{
abstract class B{ //前半句的意思，抽象类里面还可以定义抽象类
public abstract void print();
}
}
class X extends A{ //继承static内部抽象类
public void print(){
System.out.prrint("更多课程请访问：www.yootk.com");
}
class Y extends B{ //定义内部的抽象类的子类此类不是必须编写，后半句话
public void print(){
//方法覆写
}
}
}
5）外部抽象类不允许使用static声明，而内部的抽象类允许使用static声明，使用static声明的内部抽象类就相当于是一个外部类，继承的时候使用"外部类.内部类"的形式表示类的名称。
abstract class A{ //定义一个抽象类
static abstract class B { //static 定义的内部类属于外部类
public abstract void print();
}
}
class X extends A.B{ //继承static内部抽象类
public void print(){
System.out.print("更多课程请访问：www.yootk.com");
}
}
public class TestDemo{
pulic static void main(String args){
A.B ab = new X(); //向上转型
ab.print();
}
}
程序执行结果：更多课程请访问：www.yootk.com
6)在抽象类中，如果定义了static属性或者方法时，就可以在没有对象的时候直接调用。
