ToB企服应用市场:ToB评测及商务社交产业平台

标题: Java根本---继承 [打印本页]

作者: 大连密封材料 时间: 2024-8-21 16:00
标题: Java根本---继承
一、什么是继承

1.1、为什么要继承

在java的类的创建的时间，我们不可制止的要创建许多的对象，而某些对象之间又会存在某些接洽，
在这个时间，我们就可以把这些共性的特点抽取出来，单独设置为一个类，以此来实现代码的复用。

图中可以看出，玫瑰花和西红柿都有名字和颜色，还都可以举行生长，这个时间我们就可以把这些相同的地方抽取出来形成一个类。
面向对象思想中提出了继承的概念，专门用来举行共性抽取，实现代码复用
1.2、继承的概念

继承就是在保存原有机制的根本上，实现扩展，形成新的派生类，是实现代码复用的紧张手段，体现了由简朴到复杂的过程，继承主要解决的问题就是：共性的抽取，代码的复用。
由上图可以发现，玫瑰花和西红柿都是植物，都有本身的名字和颜色，还有相同的方法。以是我们可以单独创建一个植物类来存储这些特点。

上图即为继承的过程，其中Plant类被称为父类、超类、基类，Rose和Tomato类被称为子类或派生类。
1.3、继承的语法

在Java中要表现类之间的继承关系，需extends关键字，如下：

修饰符 class 子类 extends 父类 {
//......
}

复制代码

对上面例子的继承：

class Plant {
public String name;
public String color;
public Plant(String name, String color) {
this.name = name;
this.color = color;
}
public void togrow() {
System.out.println("种" + this.name);
}
}
class Rose extends Plant{
public Rose(String name, String color) {
super(name,color);
}
public void tolove() {
System.out.println("给你爱的人");
}
}
class Tomato extends Plant{
public Tomato(String name, String color) {
super(name,color);
}
public void toeat() {
System.out.println("给你爱的人吃");
}
}

复制代码

留意：
1.子类会将父类的成员变量和成员方法继承过来
2.子类继承父类后，要添加本身的成员方法或成员变量，否则就没必要继承了
二、父类的访问

在继承体系中，子类将父类中的成员变量和方法继承下来了，那在子类中可否直接访问父类中继承下来的成员呢？
2.1、子类中访问父类的成员变量

2.2.1、子类和父类不存在同名变量

class Father {
public int a = 10;
public int b = 20;
}
class Son extends Father {
public int c = 30;
public void main(String[] args) {
a = 1;//访问父类的a
b = 2;//访问父类的b
c = 3;//访问子类自己的c
}
}

复制代码

2.2.2、子类和父类成员变量同名

class Father {
public int a = 10;
public int b = 20;
public int c = 30;
}
class Son extends Father {
public int a;//同名，类型相同
public char b;//同名，类型不同
public void show() {
a = 1;//访问父类继承的a？还是子类的a？
b = 2;//访问父类继承的b？还是子类的b？
c = 3;//子类没有c，访问的是父类继承的c
//d = 4;//编译失败，父类和子类中都没有d
}
}

复制代码

在子类方法或通过子类对象访问父类成员时：
1.假如访问的成员变量子类中没有，而父类有，访问的是父类中继承下来的
2.假如访问的成员变量子类中有，优先访问本身的
3.假如访问的成员变量在父类和子类中都没有，编译报错
4.假如访问的成员变量与父类的同名，优先访问子类本身的。
2.2、子类中访问父类的成员方法

class Father {
public void showA() {
System.out.println("访问的是父类的showA");
}
public void showB() {
System.out.println("访问的是父类的showB");
}
}
class Son extends Father {
public void showA(int n) {
System.out.println("访问的是子类的showA");
}
public void showB() {
System.out.println("访问的是子类的showB");
}
public void test() {
showA();//没有参数，访问的是父类showA
showA(1);//有参数，访问的是子类showA
showB();//直接访问的是子类的showB
}
}

复制代码

总结：
1.通过子类对象访问不同名的成员方法时，假如子类中有就访问本身的，否则在父类中找，找到就访问，否则编译报错## 标题
2.通过子类对象访问同名的成员方法时，假如父类和子类的方法构成了重载，就按照传递的参数举行访问
假如子类中存在与父类中相同的成员时，那怎样在子类中访问父类相同名称的成员呢？
这个时间就需要我们的super关键字了
三、关键字

3.1、super关键字

由于设计或场景需要，子类和父类可能存在同名变量，这个时间，假如我们需要在子类中访问父类的成员变量，我们应该怎么做呢。
直接访问是无法做到的，Java提供了super关键字，该关键字的作用就是在子类中访问父类的成员。

class Super {
public int a = 1;
public int b = 2;
public Super(int a, int b) {
this.a = a;
this.b = b;
}
public void func() {
System.out.println("调用的是父类中的func");
}
}
class Base extends Super {
public int a = 10;//同名同类型
public char b = 'b';//同名不同类型
public Base(int a, int b, int a1, char b1) {
super(a, b);
this.a = a1;
this.b = b1;
}
public void func() {
System.out.println("调用的是子类中的func");
}
public void test() {
//对于同名变量，直接访问都是访问子类的变量
System.out.println(a);//结果会是10,不能直接访问到父类的a
System.out.println(super.a);//结果会是1
//对于重写的方法，也要通过super关键字
func();//子类的
super.func();//父类的
}
}
public class Test1 {
public static void main(String[] args) {
Base bs = new Base(1,2,10,'B');
bs.test();
}
}
//运行结果：
10
1
调用的是子类中的func
调用的是父类中的func

复制代码

留意：
1.super只能非静态方法中利用
2.在子类方法中访问父类的成员变量和方法
3.2、super和this

super和this都可以在成员方法中用来访问成员变量和调用其他成员方法，都可以作为构造语句的第一条语句，那他们之间有什么区别呢？
相同点：
1.都是Java的关键字
2.在构造方法中都要放在第一条语句
3.都只能在非静态的成员方法中利用，用来访问非静态的成员变量和字段
不同点：
1.this是当前对象的引用，当前对象指代调用该实例方法的对象，super是子类从父类继承下来的部分成员的引用
2.在非静态方法中，this用来访问本类的成员方法和变量，super用来访问从父类继承下来的方法和变量
3.在构造方法中，this(…)用来调用本类的构造方法，super(…)用来调用父类的构造方法，两者不能同时在构造方法中出现
4.在子类的构造方法中，肯定会存在super(…)的调用，就算不写，编译器也会默认天生，但是this(…)不写则没有
3.3、final关键字

final关键字可以用来修饰变量，成员方法以及类
1.修饰变量或字段表现常量，既不能被修改
2.修饰成员方法，表现该成员方法不能被重写
3.修饰类，表现该类不能被继承
四、再谈初始化

4.1、子类父类构造方法的关系

在给子类举行初始化前，必须先给父类举行初始化
如上文代码块中的：

public Base(int a, int b, int a1, char b1) {
super(a, b);//给父类进行初始化
this.a = a1;
this.b = b1;
}

复制代码

4.2、执行顺序

public class Test2 {
public static void main(String[] args) {
Students p2 = new Students("李四",7);
}
}
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("父类的构造方法被执行了");
}
public static void fj() {
System.out.println("父类的静态方法被执行了");
}
static {
System.out.println("父类的静态代码块被执行了");
}
{
System.out.println("父类的实例代码块被执行了");
}
}
class Students extends Person{
public Students(String name, int age) {
super(name, age);
System.out.println("子类的构造方法被执行了");
}
public static void zj() {
System.out.println("子类的静态方法被执行了");
}
static {
System.out.println("子类的静态代码块被执行了");
}
{
System.out.println("子类的实例代码块被执行了");
}
}
//执行结果：
父类的静态代码块被执行了
子类的静态代码块被执行了
父类的实例代码块被执行了
父类的构造方法被执行了
子类的实例代码块被执行了
子类的构造方法被执行了

复制代码

通过以上的执行结果，可以有以下结论：
1.静态代码块先执行，父类的静态代码块优先于子类
2.父类的实例代码块和构造方法紧接着执行
3.子类的实例代码块和构造方法紧接着这些
留意：
1.子类和父类的静态代码块只执行一次，第二次创建对象时不在执行
2.当有对象创建时，会执行实例代码块，再然后才是构造方法

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)