目录
今天这篇文章给大家介绍一下继承在Java中的运用👀👀
1.继承的定义
继承就是将父类的特性继承给子类,表明子类是一种特殊的父类,并且具有父类所不具有的 一些属性或方法。定义一个继承的语法:修饰符 class 子类类名 extends 父类名{//类定义部分},这就是一个继承的一个语法模式,记住关键字extends。
2.继承的特点
当父类子类没有同名变量时
class Daddy{//父类
public int money = 1000000000;
public int house = 5;
}
class Baby extends Daddy{//子类
public int car = 1;
public int girlfriend = 2;
public void test(){
System.out.println(car);
System.out.println(girlfriend);
System.out.println(money);
System.out.println(house);
}
}
public class Test2 {
public static void main(String[] args) {
Baby baby = new Baby();
baby.test();
}
}
我们访问子类变量时,也可以同时访问到子类变量从父类处继承来的变量,也即子类是一种带有自己变量的父类。
当子类父类有同名变量时
class Daddy{//父类
public int money = 1000000000;
public int house = 5;
public int girlfriend = 10;
}
class Baby extends Daddy{//子类
public int car = 1;
public int girlfriend = 2;
public void test(){
System.out.println(car);
System.out.println(girlfriend);
System.out.println(money);
System.out.println(house);
}
}
public class Test2 {
public static void main(String[] args) {
Baby baby = new Baby();
baby.test();
}
}
在这段代码中,子类有girlfriend,父类也有girlfriend。子类继承的时候不会继承到父类的girlfriend。所以访问的时候,子类还是只有一个girlfriend。
也就是说,当子类与父类有同名变量时,若访问子类变量,显示的是子类的变量。
那有的人会说,我就想通过子类访问父类的成员变量,那么只能使用super.成员变量来访问
这时候访问到的就是父类的成员变量,那么你就可以知道父类有几个女朋友啦。
调用方法也是同理
static的方法中,不能有super,它们是水火不容的
3.super调用父类构造方法
当我们的子类继承了父类后,一旦想要构造子类的构造方法,就一定要在子类的构造方法中显示父类的构造方法,来初始化子类从父类继承过来的父类的构造方法,那么怎么用super调用父类的构造方法呢?
class Daddy{//父类
public int money = 1000000000;
public int house = 5;
public int girlfriend = 10;
public Daddy(int money,int house) {
this.money = money;
this.house = house;
}
}
class Baby extends Daddy{//子类
public int car = 1;
public int girlfriend = 2;
public Baby(int money,int house,int car){
super(money, house);
this.car = car;
}
}
super代表调用父辈的方法,他必须放在子类构造方法的第一行才可以不报错。子类构造方法一定要确保先调用了父辈的构造方法,将父类继承下来的成员构造完整,然后再调用子类自己的构造方法。
super.data;访问父类的成员变量
super.func;访问父辈的成员方法
super();访问父辈的构造方法
4.super和this
相同点
1.都是Java的关键字
2.只能在类的非静态方法中使用,用来访问非静态的成员方法和字段
3.在构造方法中调用时,必须是构造方法中的第一条语句,并且不能同时存在。
不同点
1. this是当前对象的引用,当前对象即调用实例方法的对象,super相当于是子类对象中从父类继承下来部分成员的引用
2. 在非静态成员方法中,this用来访问本类的方法和属性,super用来访问父类继承下来的方法和属性
3. this是非静态成员方法的一个隐藏参数,super不是隐藏的参数
4. 在构造方法中:this(...)用于调用本类构造方法,super(...)用于调用父类构造方法,两种调用不能同时在构造 方法中出现
5. 构造方法中一定会存在super(...)的调用,用户没有写编译器也会增加,但是this(...)用户不写则没有
父类大于子类,静态大于实例,且静态只执行一次
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("构造方法执行");
}
{
System.out.println("实例代码块执行");
}
static {
System.out.println("静态代码块执行");
}
}
public class TestDemo {
public static void main(String[] args) {
Person person1 = new Person("bit",10);
System.out.println("============================");
Person person2 = new Person("Clavin",20);
}
}
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age; System.out.println("Person:构造方法执行");
}
{
System.out.println("Person:实例代码块执行");
}
static {
System.out.println("Person:静态代码块执行");
}
}
class Student extends Person{
public Student(String name,int age) {
super(name,age); System.out.println("Student:构造方法执行");
}
{
System.out.println("Student:实例代码块执行");
}
static {
System.out.println("Student:静态代码块执行");
}
}
public class Test {
public static void main(String[] args) {
Student student1 = new Student("张三", 19);
System.out.println("===========================");
Student student2 = new Student("Calvin", 20);
}
}
由此可知
1. 静态代码块先执行,并且只执行一次,在类加载阶段执行
2. 当有对象创建时,才会执行实例代码块,实例代码块执行完成后,最后构造方法执行
1、父类静态代码块优先于子类静态代码块执行,且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时,父类和子类的静态代码块都将不会再执行
5.继承与组合
如果一个类可以包含另外几个类,那么我们也可以将它们包含在一个组合中
class Student {
}
class Teacher {
}
class school {
private Student[] student;
private Teacher[] teachers;
}
往后的学习中,优先使用组合。