Java根本---继承
一、什么是继承1.1、为什么要继承
在java的类的创建的时间，我们不可制止的要创建许多的对象，而某些对象之间又会存在某些接洽，
在这个时间，我们就可以把这些共性的特点抽取出来，单独设置为一个类，以此来实现代码的复用。
https://i-blog.csdnimg.cn/direct/cf8e2d83ef4f4db39c6b206cc5b406a6.png#pic_center
图中可以看出，玫瑰花和西红柿都有名字和颜色，还都可以举行生长，这个时间我们就可以把这些相同的地方抽取出来形成一个类。
面向对象思想中提出了继承的概念，专门用来举行共性抽取，实现代码复用
1.2、继承的概念
继承就是在保存原有机制的根本上，实现扩展，形成新的派生类，是实现代码复用的紧张手段，体现了由简朴到复杂的过程，继承主要解决的问题就是：共性的抽取，代码的复用。
由上图可以发现，玫瑰花和西红柿都是植物，都有本身的名字和颜色，还有相同的方法。以是我们可以单独创建一个植物类来存储这些特点。
https://i-blog.csdnimg.cn/direct/fb8ec11054d6487fb666329d3e5f4bfa.png#pic_center
https://i-blog.csdnimg.cn/direct/c1f1f258735f4f6ba79d98462ee44709.png#pic_center
上图即为继承的过程，其中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企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]