一、继承概述
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修饰的局部变量。