Java自学-接口与继承 super

Java的super关键字

步骤 1 : 准备一个显式提供无参构造方法的父类

准备显式提供无参构造方法的父类
在实例化Hero对象的时候,其构造方法会打印
“Hero的构造方法 "

package charactor;

import property.Item;

public class Hero {

    String name; //姓名

    float hp; //血量

    float armor; //护甲

    int moveSpeed; //移动速度

    public void useItem(Item i){
        System.out.println("hero use item");
        i.effect();
    }

    public Hero(){
        System.out.println("Hero的构造方法 ");
    }

    public static void main(String[] args) {
        new Hero();
    }

}

步骤 2 : 实例化子类,父类的构造方法一定会被调用

实例化一个ADHero(), 其构造方法会被调用
其父类的构造方法也会被调用
并且是父类构造方法先调用
子类构造方法会默认调用父类的 无参的构造方法

package charactor;

public class ADHero extends Hero implements AD{

    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }

    public ADHero(){

        System.out.println("AD Hero的构造方法");
    }

    public static void main(String[] args) {

        new ADHero();

    }

}

步骤 3 : 父类显式提供两个构造方法

分别是无参的构造方法和带一个参数的构造方法

package charactor;

import property.Item;

public class Hero {

    String name; //姓名

    float hp; //血量

    float armor; //护甲

    int moveSpeed; //移动速度

    public void useItem(Item i){
        System.out.println("hero use item");
        i.effect();
    }   

    public Hero(){
        System.out.println("Hero的无参的构造方法 ");
    }

    public Hero(String name){
        System.out.println("Hero的有一个参数的构造方法 ");
        this.name = name;
    }

    public static void main(String[] args) {
        new Hero();
    }

}

步骤 4 : 子类显式调用父类带参构造方法

使用关键字super 显式调用父类带参的构造方法

package charactor;

public class ADHero extends Hero implements AD{

    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }

    public ADHero(String name){
        super(name);
        System.out.println("AD Hero的构造方法");
    }

    public static void main(String[] args) {
        new ADHero("德莱文");
    }

}

步骤 5 : 调用父类属性

通过super调用父类的moveSpeed属性
ADHero也提供了属性moveSpeed

public int getMoveSpeed(){
   return this.moveSpeed;
}

public int getMoveSpeed2(){
   return super.moveSpeed;
}
package charactor;

public class ADHero extends Hero implements AD{

    int moveSpeed=400; //移动速度

    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }

    public int getMoveSpeed(){
        return this.moveSpeed;
    }

    public int getMoveSpeed2(){
        return super.moveSpeed;
    }

    public static void main(String[] args) {
        ADHero h= new ADHero();

        System.out.println(h.getMoveSpeed());
        System.out.println(h.getMoveSpeed2());

    }

}

步骤 6 : 调用父类方法

ADHero重写了useItem方法,并且在useItem中通过super调用父类的useItem方法

package charactor;

import property.Item;
import property.LifePotion;

public class ADHero extends Hero implements AD {

    int moveSpeed = 400; // 移动速度

    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }

    public int getMoveSpeed() {
        return this.moveSpeed;
    }

    public int getMoveSpeed2() {
        return super.moveSpeed;
    }

    // 重写useItem,并在其中调用父类的userItem方法
    public void useItem(Item i) {
        System.out.println("adhero use item");
        super.useItem(i);
    }

    public static void main(String[] args) {
        ADHero h = new ADHero();

        LifePotion lp = new LifePotion();

    }

}

练习super

父类Hero提供了一个有参的构造方法:

public Hero(String name){
  this.name = name;
}

但是没有提供无参的构造方法
子类应该怎么处理?

package charactor;

public class Hero {
    public String name;
    protected float hp;

    public Hero(String name){
        this.name = name;
    }

//    故意不提供无参的构造方法
//    public Hero(){
//
//    }

    public static void main(String[] args) {

    }

}

原文地址:https://www.cnblogs.com/jeddzd/p/11518997.html

时间: 2024-09-29 05:01:15

Java自学-接口与继承 super的相关文章

Java自学-接口与继承 抽象类

Java 抽象类 在类中声明一个方法,这个方法没有实现体,是一个"空"方法 这样的方法就叫抽象方法,使用修饰符"abstract" 当一个类有抽象方法的时候,该类必须被声明为抽象类 步骤 1 : 抽象类 为Hero增加一个抽象方法 attack,并且把Hero声明为abstract的. APHero,ADHero,ADAPHero是Hero的子类,继承了Hero的属性和方法. 但是各自的攻击手段是不一样的,所以继承Hero类后,这些子类就必须提供不一样的attack

Java自学-接口与继承 重写

Java 重写方法 子类可以继承父类的对象方法 在继承后,重复提供该方法,就叫做方法的重写 又叫覆盖 Override 步骤 1 : 父类Item 父类Item有一个方法,叫做effect package property; public class Item { String name; int price; public void buy(){ System.out.println("购买"); } public void effect() { System.out.println

Java自学-接口与继承 多态

Java的多态 操作符的多态 +可以作为算数运算,也可以作为字符串连接 类的多态 父类引用指向子类对象 示例 1 : 操作符的多态 同一个操作符在不同情境下,具备不同的作用 如果+号两侧都是整型,那么+代表 数字相加 如果+号两侧,任意一个是字符串,那么+代表字符串连接 package charactor; public class Hero { public String name; protected float hp; public static void main(String[] ar

Java自学-接口与继承 内部类

Java 内部类 内部类分为四种: 非静态内部类 静态内部类 匿名类 本地类 步骤 1 : 非静态内部类 非静态内部类 BattleScore "战斗成绩" 非静态内部类可以直接在一个类里面定义 比如: 战斗成绩只有在一个英雄对象存在的时候才有意义 所以实例化BattleScore 的时候,必须建立在一个存在的英雄的基础上 语法: new 外部类().new 内部类() 作为Hero的非静态内部类,是可以直接访问外部类的private实例属性name的 package characto

java实现接口与继承类的区别

一个类只能继承一个类,但是可以实现多个接口. 接口里面的方法都是抽象方法,必须要重写所有的方法.接口抽象的方法都要被重写,而继承的类不必这样. 继承一般开发中用的会相比少一点,接口相比就应该会多一点.,接口主要是实现一种松耦合,便于以后的维护.升级,继承主要是提高代码的可重用性,很多东西都可以在父类中做好.子类可以直接用,用一句现在流行的话来说,继承的好处就跟拼爹是一样的. 不同的修饰符修饰(interface),(extends) 在面向对象编程中可以有多继承!但是只支持接口的多继承,不支持'

Java(接口与继承)动手动脑

1>继承条件下的构造方法调用 运行 TestInherits.java 示例,观察输出,注意总结父类与子类之间构造方法的调用关系修改 Parent 构造方法的代码,显式调用 GrandParent 的另一个构造函数,注意这句调用代码是否是第一句,影响重大 源代码: class Grandparent{ public Grandparent(){ System.out.println("GrandParent Created."); } public Grandparent(Str

【Java】接口与继承课后动手动脑

1.运行 TestInherits.java 示例,观察输出,注意总结父类与子类之间构造方法的调用关系修改Parent构造方法的代码,显式调用GrandParent的另一个构造函数,注意这句调用代码是否是第一句,影响重大! 结论: 通过 super 调用基类构造方法,必须是子类构造方法中的第一个语句. 2.思索:为什么子类的构造方法在运行之前,必须调用父类的构造方法?能不能反过来?为什么不能反过来? 构造函数的主要作用:构造函数是类的一个特殊方法,这个方法用来生成实例时由系统自动调用,程序员无法

java中接口和继承的区别

实际概念区别:区别1:不同的修饰符修饰(interface),(extends)区别2:在面向对象编程中可以有多继承!但是只支持接口的多继承,不支持'继承'的多继承哦而继承在java中具有单根性,子类只能继承一个父类区别3:在接口中只能定义全局常量,和抽象方法而在继承中可以定义属性方法,变量,常量等...区别4:某个接口被类实现时,在类中一定要实现接口中的抽象方法而继承想调用那个方法就调用那个方法,毫无压力 接口是:对功能的描述      继承是:什么是一种什么 始终记者:你可以有多个干爹(接口

java练习——接口与继承

父类与子类的构造方法: 如果父类中有一个默认无参的构造方法,那么子类的构造方法中会自动进行调用.如果父类有自己的构造方法,且这时父类没有默认无参的构造方法,那么在子类的构造方法中,必须要调用父类的某个构造方法,而且必须是在构造方法的第一个语句中进行调用,格式为super():如果放在了别的地方不能体现构造函数的作用了,程序报错. “如果没有这个约束,那么子类的某个继承自父类的方法可能会使用到父类中的一些变量,而这些变量并没有进行初始化,从而产生一些难以预料的后果,因此构造子类的对象前,必须构造父