Java基础——有继承关系的对象的创建过程,super关键字,多态

一、引言

Java中的多态是面向对象编程中的重要概念之一。它允许我们使用统一的接口来处理不同类型的对象,使代码更加灵活和可扩展。通过多态,我们可以在运行时根据实际对象的类型来调用相应的方法,而不需要显式地判断对象的类型。这种特性使得代码具有更好的可维护性和可扩展性,同时也提高了代码的复用性和可读性。

二、有继承关系的对象的创建过程

  1. 给父子类属性分配空间,赋默认值
  2. 给父类属性赋初始值
  3. 执行父类构造再次赋值
  4. 给子类属性赋初始值
  5. 执行子类构造再次赋值

总结: 先构建父类内容,才能构建子类内容

class ClassA{
    public ClassA(){
        System.out.println("a");
    }
}

class ClassB extends ClassA{
    ClassA ba;
    public ClassB(){
        System.out.println("b");
        ba = new ClassA();
    }
}

class ClassC extends ClassB{
    ClassB cb ;
    ClassA ca = new ClassA();
    public ClassC(){
        cb = new ClassB();
        System.out.println("c");
    }
}

public class Test {
    public static void main(String[] args) {
        ClassC cc = new ClassC();//abaaabac
    }
}

三、super关键字

  • 代表父类对象

(1)super()

作用为调用父类构造内容

使用
  1. 必须写在子类构造方法有效代码第一行

  2. 和this()无法同时显式存在

  3. 通过实参列表决定调用的是哪个父类构造

  4. 子类构造第一行默认存在无参的super()

子类有参构造写法:

public 子类类名(父类的形参列表,自己独有的属性){
 	//先调用super()给父类声明属性赋值
 	super(对应的父类的形参);
 	//再this.给自己的独有属性赋值
 	this.自己的属性名=属性名;
}
package com.by.entity;

/**
动物类-父类
*/
public class Animal {
 	//名字  年龄  性别
 	private String name;
 	private int age;
 	private boolean sex;

 	public Animal(){}
 	public Animal(String name, int age, boolean sex) {
     	this.name = name;
     	this.age = age;
     	this.sex = sex;
 	}
	//省略getter\setter
}

public class Cat extends Animal{
 	private String color;

 	public Cat(){}
 	public Cat(String name, int age, boolean sex,String color){
    	//先调用super()给父类声明属性赋值
     	super(name, age, sex);
     	//再this.给自己的独有属性赋值
     	this.color = color;
 	}
}

(2)super.

  • 用来指明调用父类的属性或方法
super.属性名
super.方法名(实参)
public class Dog extends Animal{
        //从animal继承过来了名字,年龄,性别,吃饭(),睡觉()

    //重写父类方法
    public void eat(){
        //调用父类的eat方法
        super.eat();
        System.out.println("狗吃大骨头");
    }
}

四、多态

(1)概念

父类引用指向子类对象

(2)语法

父类引用=子类对象;
父类类名 引用名=new 子类类名();
Animal a1 = new Dog();//狗对象是一个动物
Animal a2 = new Cat();//猫对象是一个动物

(3)使用

  1. 实际创建的是子类对象

  2. 优先执行子类内容

  3. 父类引用无法访问子类独有内容

    编译器关注的是引用类型

    解释器关注的是实际对象类型

  4. 右侧类型决定了是什么,左侧类型决定了能做什么

(4)引用类型间的相互转换

父类-大类型

子类-小类型

1.自动类型转换

父类引用=子类对象|子类引用

2.强制类型转换

子类类名 引用名=(子类类名)父类引用名;
//利用多态创建一个子类对象
        Animal a = new Dog();
        a.eat();
        a.sleep();
        //调用看门方法  Dog类的引用.lookDoor()
        //将a引用类型强转为Dog类型
        Dog dog = (Dog) a;
        dog.lookDoor();

在多态的前提下,必须先将父类引用强转为子类类型才能访问子类独有内容

  • 只能转向父类引用原本指向的子类类型. 编译不报错,运行报错

      Animal a=new Dog();
      Cat cat=(Cat)a;   //会报出ClassCastException异常:类型转换出错
    
  • 同级子类之间不可进行强转. 编译报错

      Dog d=new Dog();
      Cat c=(Cat)d;//错误!
    

3.强制类型转换案例

	//有Animal,Dog,Cat,JinMao四个类。
	//Dog和Cat类是Animal类的子类,JinMao类是Dog类的子类。
	//有一个测试类Test。

	public class Test{
		public static void main(String[] args){
		
			Animal a = new JinMao();//正确,子类可以为间接子类


			Animal a = new Dog();
			JinMao jm =JinMao)a;//解释器报错,a为Dog类,无法赋给他的子类JinMao



			Animal a = new JinMao ();
			Dog d =Dog)a;		//正确,相当于改变了多态的引用(间接引用->直接引用)
		}
	}

五、结语:

多态是Java中一个强大而灵活的特性,它使得我们能够以统一的方式处理不同类型的对象,并且能够根据实际对象的类型来调用相应的方法。通过合理地运用多态,我们可以写出更加优雅和简洁的代码,同时也能够更好地应对需求变化和扩展。掌握多态的概念和使用方法,对于成为一名优秀的Java开发者来说是至关重要的。通过不断地学习和实践,我们可以发挥多态的优势,写出高质量的、可维护的Java代码。

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: super关键字Java中用于访问父类成员的关键字。在继承中,子类可以继承父类的属性和方法,但有时子类需要访问父类的属性或方法,这时就可以使用super关键字。 使用super关键字可以调用父类的构造方法、访问父类的属性和方法。在调用父类的构造方法时,需要在子类的构造方法中使用super关键字,并传递相应的参数。 在多态中,子类可以重写父类的方法,当调用该方法时,会根据对象的实际类型来确定调用哪个方法。如果子类需要调用父类的方法,可以使用super关键字。 总之,super关键字Java中用于访问父类成员的重要关键字,在继承多态中都有重要的应用。 ### 回答2: Java继承是指子类从其父类继承属性和方法的过程。在Java中,父类是可以被子类继承的。当子类继承父类时,它继承了父类的方法、属性和结构。同时,子类可以使用父类的方法和属性,并且可以在父类的方法和属性的基础上进行扩展或修改,这就是Java继承的核心。 在Java继承中,子类除了要继承父类的属性和方法外,还可以继承父类的构造方法。在调用父类的构造方法时,需要使用super关键字super关键字用于在子类中调用父类的被重写的方法、属性或构造方法。子类可以使用super关键字来访问父类中的属性或方法,同时,在调用父类的构造方法时,也可以使用super关键字多态是指同一种对象,在不同情况下,所表现出来的不同状态或表现形式。在Java中,多态可以通过继承和接口实现。 当子类继承父类并重写父类的方法时,这种行为被称为运行时多态,即在运行时决定使用哪个方法。在Java中,使用父类引用变量来引用子类对象时,就可以实现多态。例如,定义一个父类变量p,将其指向子类对象,就可以使用父类中定义的方法来操作子类对象。 综上所述,super关键字Java继承中起着重要的作用,它可以用于在子类中访问父类中的属性和方法,并且可以在调用父类的构造方法时使用。同时,多态的实现方式也是Java继承的重要应用之一,通过多态,可以实现同一种对象在不同情境下表现出不同的状态和行为。掌握好Java继承多态的基本特性,能够帮助我们更好地理解和运用Java编程语言。 ### 回答3: Java是一种功能强大的编程语言,在Java编程中,继承多态是非常重要的概念。而在这两个概念中,使用super关键字也是不可或缺的。 super关键字Java语言中的一个保留关键字,主要用于访问祖先类(父类或祖先接口)中已经被覆盖的方法或实例变量。在继承中,如果派生类继承了一个父类,那么在派生类中可以使用super关键字来调用父类中的方法或变量。 super关键字可以有以下两种用法: 1. 在子类中调用父类的构造方法。 使用super关键字可以调用父类的构造方法,即实例化父类的对象。这种用法一般用于子类需要在实例化时初始化父类的状态的情况。 例如,以下代码创建一个子类,其中调用了父类的构造函数: ``` public class Child extends Parent{ public Child() { super(); } } ``` 2. 在子类中访问父类的方法或实例变量。 使用super关键字可以访问父类中被覆盖的方法或实例变量。这种用法一般用于在子类中需要使用父类中的方法或变量的情况。 例如,以下代码创建一个子类,其中调用了父类的方法: ``` public class Child extends Parent{ public Child() { super(); } public void doSomething() { super.doSomething();//调用父类的方法 } } ``` 在使用super关键字时,需要注意以下几点: 1. super关键字必须是第一条语句。 在使用super关键字调用父类的构造方法时,必须放在子类构造方法的第一行。这是因为子类在实例化时需要先实例化父类。 2. super关键字只能访问父类中被覆盖的方法或实例变量。 在子类中使用super关键字只能访问父类中已被覆盖的方法或实例变量,否则会出现编译期间的错误。 3. super关键字只能用于访问父类中的方法或实例变量。 在使用super关键字时,只能访问父类中已被覆盖的方法或实例变量,不能访问父类中未被覆盖的方法或实例变量。 总之,在Java编程中,继承多态是非常重要的概念。使用super关键字可以方便地调用父类中的方法或变量,从而实现更灵活的编程。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值