作者:
@小鱼不会骑车
专栏:
《java练级之旅》
个人简介:
一名专科大一在读的小比特,努力学习编程是我唯一的出路
作者心里话
小鱼一直都是秉承着“开开心心看博客,快快乐乐学知识的观点,虽然浏览量好低…”
前言
继承是面向对象语法的三大特征之一继承可以降低代码编写的冗余度,提高编程的效率。通过继承,子类获得了父类的成员变量和方法。一个子类如何继承父类的字段和方法,如何修改从父类继承过来的子类的方法呢
我们来写出两个类,分别是猫类和狗类
class Dog {//狗类
public String name;
public int age;
public void wangwang() {
System.out.println(name+" 汪汪叫");
}
public void eat() {
System.out.println(name+" 在吃饭");
}
}
class Cat {//猫类
public String name;
public int age;
public void mimi() {
System.out.println(name+" 咪咪叫");
}
public void eat() {
System.out.println(name+" 在吃饭");
}
}
public class Main {
public static void main(String[] args) {
Dog dog=new Dog();
System.out.println("======");
Dog dog1=new Dog();
}
}
大家看,相同的部分我都圈起来了,我们的猫类和狗类都是有名字的,那我们可以将这些共性抽取出来吗?
继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。
我们设父类为Base
上述图示中,Dog和Cat都继承了Base类,其中:Base类称为父类/基类或超类,Dog和Cat可以称为Base的子类/派生类,继承之后,子类可以复用父类中成员,子类在实现时只需关心自己新增加的成员即可。
在Java中如果要表示类之间的继承关系,需要借助extends关键字,具体如下:
修饰符 class 子类 extends 父类 {
// ...
}
下面使用继承的方式重新设计
class Base {
String name;
int age;
public void eat() {
System.out.println(name+" 在吃饭");
}
}
class Dog extends Base {
public void wangwang() {
System.out.println(name+" 汪汪叫");
}
}
class Cat extends Base {
public void mimi() {
System.out.println(name+" 咪咪叫");
}
}
public class Main {
public static void main(String[] args) {
Dog dog=new Dog();
// dog类中并没有定义任何成员变量,name和age属性肯定是从父类Base中继承下来的
dog.name="小八嘎";
dog.age=3;
System.out.println(dog.name);
System.out.println(dog.age);
dog.eat();// dog访问的eat()方法也是从Base中继承下来的
dog.wangwang();//dog自己的方法
}
}
注意
在继承体系中,子类将父类中的方法和字段继承下来了,那在子类中能否直接访问父类中继承下来的成员呢?
public class A {
public int a;
public int b;
}
class B extends A {
public int c;
}
class Main {
public static void main(String[] args) {
B p1=new B();
p1.a=10;//访问从父类继承的a
p1.b=20;//访问从父类继承的b
p1.c=30;//访问自己的c
System.out.println(p1.a);
System.out.println(p1.b);
System.out.println(p1.c);
//输出10,20,30
}
}
public class A {
public int a=10;
public int b=20;
public int c=30;
}
class B extends A {
public int a=30;//同类型同变量名
public char b=97;//不同类型相同变量名
public int d=50;
}
class Main {
public static void main(String[] args) {
B p1=new B();//实例化一个B类
//输出30,访问的是子类的a
System.out.println(p1.a);
//输出'a',访问的是子类的b,转换成ascll值就是'a'
System.out.println(p1.b);
//输出30访问的是父类的c,子类没有c
System.out.println(p1.c);
System.out.println(p1.d);
//50,只有子类有d,访问的是子类的
//System.out.println(p1.e);编译失败,子类父类都没有e这个变量
}
}
在子类方法中 或者 通过子类对象访问成员时:
public class A {
public void print(){
System.out.println("我是A类的方法");
}
}
class B extends A {
public void print1() {
System.out.println("我是B类的方法");
}
}
class Main {
public static void main(String[] args) {
B p1=new B();//实例化一个B类的对象
p1.print();//继承父类的方法,打印我是A类的方法
p1.print1();//子类自己的方法,打印我是B类的方法
// print2(); // 编译失败,在整个继承体系中没有发现方法print2()
}
}
总结
当我们成员方法没有同名时,在子类方法中或者通过子类对象访问方法时,则优先访问自己的,自己没有时
再到父类中找,如果父类中也没有则报错。
public class A {
public void printA(){
System.out.println("A类中的printfA");
}
public void printB() {
System.out.println("A类中的printfB");
}
}
class B extends A {
public void printA(int a) {
System.out.println("B类中的printA");
}
public void printB() {
System.out.println("B类中的printB");
}
}
class Main {
public static void main(String[] args) {
B p1=new B();
p1.printA(10);//调用子类的printA
p1.printA();//子类没有,调用父类的printA
p1.printB();//优先调用子类的printB
}
}
【说明】
那如果方法名或变量名相同时,我想调用父类的方法或变量,该怎么去做呢?
由于设计不好,或者因场景需要,子类和父类中可能会存在相同名称的成员,如果要在子类方法中访问父类同名成
员时,该如何操作?直接访问是无法做到的,Java提供了super关键字,该关键字主要作用:在子类方法中访问父类的成员,super暂时理解为(父类的引用)
public class A {
int a=10;
int b=20;
public void printA(){
System.out.println("A类中的printfA");
}
public void printB() {
System.out.println("A类中的printfB");
}
}
class B extends A {
int a = 30;
int b = 40;
public void printA(int a) {
System.out.println("B类中的printA");
}
public void printB() {
System.out.println("B类中的printB");
}
public void printC() {
System.out.println("B类中的printC");
}
public void printD() {
// 对于同名的成员变量,直接访问时,访问的都是子类的
System.out.println(a); // 等价于: this.a = 30;
System.out.println(b); // 等价于: this.b = 40;
// 注意:this是当前对象的引用
// 访问父类的成员变量时,需要借助super关键字
// super是获取到子类对象中从基类继承下来的部分
System.out.println(super.a);//访问父类的成员变量a
System.out.println(super.b);//访问父类的成员变量b
// 父类和子类中构成重载的方法,直接可以通过参数列表区分清访问父类还是子类方法
printA(); // 没有传参,访问父类中的printA()
printA(20); // 传递int参数,访问子类中的printA(int)
// 直接访问,则永远访问到的都是子类中的printB(),基类的无法访问到
printB();
// 如果在子类中要访问重写的基类方法,则需要借助super关键字
super.printB();
//先从子类中查找方法,查找不到再去基类,如果还是找不到就报错
printC();
}
}
class Main {
public static void main(String[] args) {
B p1 = new B();
p1.printD();
}
}
最后输出
大家不要说小鱼水博客,这样对比大家搭配注释应该很好的理解,
- super.a ,子类中访问父类成员变量
- super.printB , 子类中访问父类的方法
- 当我的父类方法名和子类方法名一样,如果参数不同就会形成方法重载,如果参数相同就会采用就近原则。
- super只能在静态的方法中使用
super(暂时理解为父类的引用)不对!
正确的理解:super只是一个关键字,最大的作用就是在写代码或读代码时体现更好的可读性
单独解释一下为什么不能在静态方法中使用super
因为被static修饰的成员数据不依赖于对象,又因为super是依赖于对象的,所以如果没有实例化对象,那么在静态方法中使用super就会报错。
父子父子,先有父再有子,即:子类对象构造时,需要先调用基类构造方法,然后执行子类的构造方法。
在继承关系上,我们在构造子类的构造方法时,一定要先帮助父类进行构造
怎么帮助?
在子类中调用父类的构造方法,用super()
大家看这块代码
class A {
public A() {//父类的构造方法
}
}
class B extends A {
public B() {//子类的构造方法
super();//调用父类的构造方法
}
public static void main(String[] args) {
B p=new B();
}
}
其实平时我们如果并没有自己创建构造方法时,我们的编译器就会和上述代码一样,给我们提供一个无参的构造方法,并且会在子类的构造方法中第一个执行super()去调用父类的构造方法。
有这几种可能
- 题一:父类没有参数的构造方法,子类没有参数的构造方法
- 题二:父类没有参数的构造方法,子类有参数的构造方法
- 题三:父类有参数的构造方法,子类没有参数的构造方法
- 题四:父类有参数的构造方法,子类有参数的构造方法
题一题二当然我们完全可以省略不写super(),只要是我们的父类构造方法无参,图二是省略之后的
图一
图二
题三题四这个时候就不可以不写super,如果不写的话编译器就会产生编译错误。相同颜色的框就是我从哪里去调用它的构造方法
图一
如果想在实例化对象的时候就初始化父类的成员方法,可以这样,内个我们学习java就是要习惯这个抽象的图…
最后打印
张三
王五
在子类构造方法中,并没有写任何关于基类构造的代码,但是在构造子类对象时,先执行基类的构造方法,然后执
行子类的构造方法,因为:子类对象中成员是有两部分组成的,基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子,所以在构造子类对象时候 ,先要调用基类的构造方法,将从基类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整
注意事项
super和this都可以在成员方法中用来访问:成员变量和调用其他的成员函数,都可以作为构造方法的第一条语
句,那他们之间有什么区别呢?
【相同点】
【不同点】
回顾一下之前讲的:
- 静态代码块先执行,并且只执行一次,在类加载阶段执行
- 当有对象创建时,才会执行实例代码块,实例代码块执行完成后,最后构造方法执行
接下来是父类和子类都有实例化代码块和静态代码块时
class A {
static {
System.out.println("父类静态的代码块");//1
}
{
System.out.println("父类实例的代码块");//2
}
public A() {
System.out.println("父类的构造方法");//3
}
}
class B extends A {
static {
System.out.println("子类的静态代码块");//4
}
{
System.out.println("子类的实例代码块");//5
}
public B() {
System.out.println("子类的构造方法");//6
}
}
public class Main {
public static void main(String[] args) {
B p =new B();
System.out.println("=======");
p=new B();
}
}
通过分析执行结果,得出以下结论:
1、父类静态代码块优先于子类静态代码块执行,且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时,父类和子类的静态代码块都将不会再执行
因为我们的后面会再学习新的知识重写,防止大家混淆这两个概念,我给大家单独再解释一下什么是重载
我们的继承关系的类也是存在构造方法的,在帮助手册中是这么形容的
名称相同,返回值无关,可以是继承关系,参数一定不同!!!
这个部分知识点其实有些多,后面会单独出一起类访问权限符的博客,在这里就大概介绍一下
验证
注意:父类中private成员变量虽然在子类中不能直接访问,但是也继承到子类中了
什么时候下用哪一种呢?
给大家举个例子
我们可以从下面四个小宠物冲提出两个类,猫类和狗类,当然,也可以都统称为动物类。
在java中支持以下几种继承方式
注意!!!
java不支持多继承
大家学过C语言都知道有一个关键字是const,用来将变量修饰为常量的,在java中也有个类似的,那就是final
关于final这个关键字其实有很多细节知识点,小鱼也会单独出一篇博客来详细讲解!!!