JAVA基础笔记（六）继承、抽象类

java面向对象三大主要特性：继承，封装，多态

继承：
1，java中只允许单继承，但是可以多层继承

2，父类中的非私有属性属于显示继承，子类可以进行操作，但是父类中的私有属性属于隐式继承，子类不可以直接进行操作，子类如果想对隐式继承进行操作必须要通过get(),set()方法来进行操作。3，在子类进行实例化构造之前会默认执行父类中的构造处理，调用构造方法，而后再执行子类的构造方法，实例化新的子类对象前一定会调用父类的无参构造方法，而构造方法一旦被调用就表示该类的对象被实例化了。4，实例化子类对象的同时一定会实例化好父类的对象。5，如果父类没有定义无参构造方法，子类可以利用super()的形式指定要调用的父类的构造。super也一定要放在子类构造函数的首行。例如父类只有一个具有String类型的构造函数，子类可以在子类构造函数里定义super("String")来进行调用父类的构造函数。

Final关键字:
1，使用final定义的关键字不允许有子类，final不允许修饰abstract类
2，使用final定义的方法不允许被重写。
3，使用final定义的变量将变成常量，final定义的常量一旦定义之后将不可以进行改变。
4，在定义常量的时候有一种成为全局常量的概念：public static final 定义。
5，一般情况下，定义常量时，名称都采用了大写字母的形式，看见大写字母就是常量。

方法的覆写（重写）：
重写一般都是因为发生了继承的关系，子类拥有父类相同的方法或者属性。
方法名相同，参数类型以及参数个数都相同的时候就叫做覆写。

1，被覆写的方法不能拥有比父类更严格的控制访问权限，如果父类的权限是public，那么子类的权限只能是public，如果父类的权限是private，那么子类是不允许覆写父类的方法的。

Overloading与override的区别：

        重载              覆写

定义上：方法的名称相同，参数的类型跟个数不同 | 方法的名称，参数类型，个数，返回值类型都相同

范围： 发生在一个类之中 | 发生在两个类之的继承中

权限： 没有权限要求，可以任意使用权限 | 被子类覆写的方法不能拥有比父类更为严格的访问权限

英文单词： Overloading | Override

如果子类想调用父类中已经写好的覆写的方法，用super().父类中的方法();

this与super的区别：

    this                                super

定义:调用本类的普通，构造方法，如果本类没有指定的名称存在，则调用父类 | 由子类直接调用父类的普通，构造方法或属性，不查找子类本身。

约定：this调用函数时必须放在构造方法首行，表示调用本类构造函数 | super调用父类构造时，必须在子类构造方法首行，一定会有super()语句

特殊：this表示当前对象，super什么都不表示，this与super不可能同时出现。

方法的覆写的核心在于：
保存父类中定义的方法名称，但是方法的实现可以由不同的子类的动态来决定；

多态性：
方法的多态性：重载和覆写
|-重载：根据不同的参数类型或者参数个数，同一个方法名称可能会实现不同的功能；
|-覆写：同一个方法根据不同的子类可以有不同的实现；
对象的多态性：父子类对像之间的转换处理，这个时候有两种处理模式
|-对象的向上转型(自动转型):父类 父类对象 = 子类实例; 最大的意义为：参数的操作类型统一；
|-对象的向下转型: 子类 子类对象 = （子类）父类实例;

如果直接向下转型会出现 Array cannot be cast to ReverseArray错误，如果非要转型的话，可以先将new出来的对象进行向上转型，然后再向下转型；
向下转型一般结合instanceof一起使用，用来判断对象是不是类的对象；

抽象类的定义与使用：
1，抽象类 = 普通类的结构 +　抽象类的方法；
2，抽象方法只能在抽象类里面，方法与类都要用abstract来修饰；
3，抽象类必须要有子类。
4，抽象类的子类（如果不是抽象类）要求覆写抽象类的全部的方法；
5，如果要实例化抽象类，可以通过子类的向上转型的方式来实现；
6，抽象类不需要用final来定义，因为抽象类必须要有子类，而final定义的类不能拥有子类；
7，抽象类可以有自己的构造方法，子类实例化对象之前还是会先去执行父类的构造方法（默认去找无参构造函数），在调用子类自己的构造方法；
8，有abstract就不可有new；
9，外部的抽象类无法直接使用static声明，但是内部的抽象类可以使用static定义，使用static定义内部类相当于外部抽象类；

abstract class A{
private String msg = “mldn”;
public static final String URL = “www.mldn.cn”;
public void print(){
System.out.println(“AAAAAAAAAAAA”);
}
static abstract class B{
public abstract void fun();
}
}
class X extends A.B{
public void fun(){
System.out.println(“Hello word!!!”);
}
}
class Test{
public static void main(String args[]){
A.B a = new X();
a.fun();
}
}

某一个抽象类的子类可能会由这个抽象类自己提供：
static方法不受本类实例化对象的限制，
抽象类里面也可以使用static方法，
在一个抽象类里实现一个static方法来放内部类，
实现抽象类自己提供子类；

abstract class A{
public abstract void print();
public static A getInstence(){
class X extends A{
public void print(){
System.out.println(“Hellow World”);
}
}
return new X();
}
}
public class TestAbstract{
public static void main(String args[]){
A a = A.getInstence();
a.print();
}
}

子类实例化的时候一定是先调用父类的构造方法在执行子类的构造方法；