java基础--继承上
一、继承概述
1 、特点：
1> 提高了代码的复用性。
2> 继承的出现让类与类之间产生了关系，提供了多态性的前提。
2、 Java中的继承。
1> java只支持单继承，不支持多继承。为啥呢？
因为继承了多个父类如果有相同方法时，子类对象不确定运行哪一个。
容易带来安全隐患。
2> java支持多层继承。A-->B--->C 原来可以形成继承体系。
3> java中继承的使用
a)想要使用体系，先查阅父类的功能，父类的由来其实是由事物中的共性内容不断向上抽取而来的,所以父类中定义的是该体系中共性功能。
b)那么在具体调用时，要创建最子类的对象，为什么呢？
一是因为有可能父类不能创建对象，
二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
简单一句话：查阅父类功能，创建子类对象使用功能。
注意：千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系 is a。
二 子父类出现后，类成员的特点：
类中成员：变量 ， 函数 ，构造函数
1> 变量
如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，
用this，子类要访问父类中的同名变量，用super。
当访问某个变量（只在父类中定义），用this，或super。
super的使用和this的使用几乎一致：
this代表的是本类对象的引用。
super代表的是父类对象的引用。
代码演示：
class Parent {
int num = 8;
public void setNum(int num) {
this.num = num;
}
public int getNum() {
return num;
}
}
class Child extends Parent {
// int num = 5;一般不会这么定义，父类已经定义
// 子类中的变量num只从父类获取
void show() {
System.out.println("省略了this 的 num = " + num);
System.out.println("子类从父类继承的 num = " + this.num);
System.out.println("获取父类的 num = " + super.num);
}
}
class ExtendsDemo2 {
public static void main(String[] args) {
Child child = new Child();
child.show();
// System.out.println(child.num+"...."+child.num);
}
}
2> 子父类中的函数。
A) 当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子 类函数的内容。
如同父类的函数被覆盖一样。这种情况是函数的另一个特 性：重写(覆盖)
B)当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能， 但是功能的内容却和父类不一致，
这时，没有必要定义新功能，而是使用 覆盖特殊，保留父类的功能定义，并重写功能内容。
3> 子父类中的构造函数。
在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句 super();
super():会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super(),同样是因为初始化要先执行。
4>为什么子类一定要访问父类中的构造函数 ?
因为父类中的数据子类可以直接获取，而且子类在自己定义一些变量、属性时，应该先先参考父类的初始化动作，再考虑自己是否要进行重新初始化。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
当父类中没有空参数的构造函数，就必须用super来指定。
注意：super语句一定定义在子类构造函数的第一行，（和this道理一样，先按照父类的方式进行初始化，再通过自己的方式初始化），子类必须要访问父类。
三 子类的实例化过程
结论：
1> 子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
2> 因为子类每一个构造函数内的第一行都有一句隐式super();
3> 当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
4> .当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。
代码演示：
class Fu // extends Object
{
int num;
// 只访问空参数的构造函数
Fu() {
// super(); //继承Object
num = 60;
System.out.println("fu run");
}
Fu(int x) {
System.out.println("fu ...." + x);
}
}
class Zi extends Fu {
Zi() {
super();
// super(4);
System.out.println("zi run");
}
Zi(int x) {
this(); /*在第一行，this和super只能出现一个,所以就没有super（）了，但是这条语句会去访问
本类构造函数Child(),而Child()会去访问父类的构造函数，所以子类中至少有一个会访问父类*/
// super(); //隐式super
// super(3); //当父类中没有空参数的构造函数，必须手动指定访问的构造函数
System.out.println("zi..." + x);
}
}
class ExtendsDemo4 {
public static void main(String[] args) {
Zi z = new Zi(0);
System.out.println(z.num);
}
}
//super的应用
/*
class Person {
private String name;
Person(String name) {
this.name = name;
}
void show(){}
}
class Student extends Person {
Student(String name) {
super(name); //父类已经定义的方法，子类没必要重新定义，子类直接通过super使用 }
//只是构造函数的调用是super（），一般函数调用的super.()
void method() {
super.show();
}
}
*/
四、 重载 与 覆盖
重载：Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。、
重载时应注意的几点：
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
5、如果两个方法的参数列表完全一样，不可以通过使它们的返回值不同来实现重载Overload
假设某个类中有两个名称和参数列表完全相同的方法，仅仅是返回类型不同，java就无法确定编程者倒底是想调用哪个方法了，因为它无法通过返回结果类型来判断。
覆盖(重写)：Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现
最熟悉的覆盖就是对接口方法的实现，在接口除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。
在覆盖要注意以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。
4、子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。
五 、final 关键字
1> 可以修饰类，函数，变量。
2> 被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3> 被final修饰的方法不可以被复写。
4> 被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修 饰局部变量。当在描述事物时，一些数据的出现值是固定的，
那么这时为了增 强阅读性，都给这些值起个名字。方便于阅读。而这个值不需要改变，所以加 上final修饰。作为常量：常量的书写规范
所有字母都大写，如果由多个单词 组成，单词间通过 "_" 连接。
5> 内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。
