精华内容
下载资源
问答
  • java继承和多态
    千次阅读
    2021-06-27 09:48:26

    第1关:学习-Java继承和多态之super关键字


    任务描述

    本关任务:根据要求补全 Salary 类,实现输出员工基本信息和薪水的功能。

    相关知识

    对于继承父类的子类而言,有时我们需要在子类中访问父类的方法,此时便可以使用 super 关键字。

    在 Java 里面,对于 super 关键字的用法:

    1. 子父类存在着同名的成员(包括变量和方法)时,在子类中默认是访问子类的成员,可以通过 super 关键字指定访问父类的成员;

    2. 创建子类对象时,默认会先调用父类无参的构造方法,可以通过 super 关键字指定调用父类的构造方法。

      • 如果在子类的构造方法上没有指定调用父类的构造方法,那么 Java 编译器会在子类的构造方法内加上 super() 语句;
      • super 关键字调用父类的构造函数时,该语句必须要是子类构造函数中的第一个语句;
      • super 与 this 关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要是第一个语句。

    super 关键字主要存在于子类方法中,用于指向子类对象中的父类对象;可以访问父类的属性、函数以及构造函数。

    例子:使用 super 调用父类的构造方法。

     
    
    1. class People{
    2. int number; // 证号
    3. String name; // 名称
    4. // 无参构造
    5. People(){
    6. }
    7. // 有参构造
    8. People(int number,String name){
    9. this.number=number;
    10. this.name=name;
    11. System.out.println("我的名字是"+name+",证号是:"+number);
    12. }
    13. }
    14. // 继承 People 类
    15. class Adult extends People{
    16. boolean a; // 是否为成年人
    17. Adult(int number,String name,boolean b){
    18. // 调用父类的构造方法
    19. super(number,name);
    20. a=b;
    21. System.out.println("是否成年="+a);
    22. }
    23. }
    24. public class Test {
    25. public static void main(String[] args) {
    26. Adult adult = new Adult(9901, "张三", false);
    27. }
    28. }

    执行结果:

     
    
    1. 我的名字是张三,证号是:9901
    2. 是否成年=false

    例子:子类使用 super 访问和调用被子类隐藏的成员变量和方法。

     
    
    1. class Sum {
    2. int n;
    3. // 计算 1+2+...+n 的值
    4. float f() {
    5. float sum=0;
    6. for(int i=1;i<=n;i++){
    7. sum=sum+i;
    8. }
    9. return sum;
    10. }
    11. }
    12. // 继承 Sum 类
    13. class Average extends Sum{
    14. int n;
    15. // 计算 1+2+...+n 的平均值
    16. float f() {
    17. float c;
    18. super.n=n;
    19. // 调用父类的计算 1+2+...+n 的方法
    20. c=super.f();
    21. return c/n;
    22. }
    23. // 计算 (1+2+...+n)/2 的值
    24. float g() {
    25. float c;
    26. c=super.f();
    27. return c/2;
    28. }
    29. }
    30. public class Test {
    31. public static void main(String[] args) {
    32. Average aver=new Average();
    33. aver.n=100;
    34. float resultOne=aver.f();
    35. float resultTwo=aver.g();
    36. System.out.println("resultOne="+resultOne);
    37. System.out.println("resultTwo="+resultTwo);
    38. }
    39. }

    执行结果:

     
    
    1. resultOne=50.5
    2. resultTwo=2525.0

    编程要求

    仔细阅读右侧编辑区内给出的代码框架及注释,按照提示编写程序代码。

    测试说明

    平台将使用测试集运行你编写的程序代码,若全部的运行结果正确,则通关。 可在右侧“测试结果”区查看具体的测试集详情。


    开始你的任务吧,祝你成功!

    /*
    * 根据要求补全 Salary 类,实现输出员工基本信息和薪水的功能。
     */
    class Employee {
        private String name;// 员工姓名
        private String birth;// 出生年月
        private String position;// 职位
    
        // 使用有参构造方法初始化Employee
        public Employee(String name, String birth, String position) {
            this.name = name;
            this.birth = birth;
            this.position = position;
        }
        // 定义 introduction 方法输出员工信息
        public void introduction() {
            System.out.println("员工姓名:" + name + "\n出生年月:" + birth + "\n职位:" + position);
        }
    
    }
    
    public class Salary extends Employee {
        private double salary; // 薪水
        // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
        /********* Begin *********/
        // 定义Salary的有参构造方法,同时在子类中指代父类构造器
    public Salary(String name,String birth,String position,double salary){
        super(name,birth,position);
        this.salary=salary;
    }
    
        // 重写introduction方法,使用super保留父类原有的功能,新添输出员工薪水的功能
    public void introduction(){
        super.introduction();
        System.out.print("薪水:"+salary);
    }
        /********** End **********/
    }

    更多相关内容
  • java继承和多态

    千次阅读 多人点赞 2021-10-08 21:38:20
    继承多态 文章目录继承多态继承多态 继承 多态

    继承和多态

    继承

    继承的概念

    继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。
    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。
    生活中也有许多继承的例子,如图:
    在这里插入图片描述

    继承的基本语法

    class 子类 extends  父类{
    }
    

    注意:

    1. 使用 extends 指定父类.
    2. Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).
    3. 子类会继承父类的所有 public 的字段和方法.
    4. 对于父类的 private 的字段和方法, 子类中是无法访问的.
    5. 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用

    继承的好处

    当我不使用继承时,代码如下:

    class Animal {
        public String name;
    
        public Animal(String name) {
            this.name = name;
        }
    
        public void eat(String food) {
            System.out.println(this.name+"正在干饭,并表示"+food+"很不错");
        }
    }
    // Cat.java 
    class Cat {
        public String name;
    
        public Cat(String name) {
            this.name = name;
        }
        public void eat(String food) {
            System.out.println(this.name+"正在干饭,并表示"+food+"很不错");
        }
    }
    // Bird.java 
    class Bird {
        public String name;
    
        public Bird(String name) {
            this.name = name;
        }
    
        public void eat(String food) {
            System.out.println(this.name+"正在干饭,并表示"+food+"很不错");
        }
    
        public void fly() {
            System.out.println(this.name + "正在飞 ︿( ̄︶ ̄)︿");
        }
    }
    

    由上面代码可以发现,该代码存在大量的冗余代码,如:Animal类,Cat类,Bird类相比较可以发现该3个类都具备相同的eat方法,而且行为完全是 一样的,都有相同的属性name而且意义相同,这种代码维护性不高(维护性主要是后期需要修改的时候,就需要修改很多的代码,容易出错),所以要从根本上解决这代码的问题,就需要继承,以达到代码重用的效果。
    使用继承后的代码:

    class Animal {
        public String name;
    
        public Animal(String name) {
            this.name = name;
        }
    
        public void eat(String food) {
            System.out.println(this.name+"正在干饭,并表示"+food+"很不错");
        }
    }
    // Cat.java
    class Cat extends Animal{
        public Cat(String name) {
        // 使用 super 调用父类的构造方法.
            super(name);
        }
    }
    // Bird.java
    class Bird extends Animal{
        public Bird(String name) {
            super(name);
        }
        public void fly() {
            System.out.println(this.name + "正在飞 ︿( ̄︶ ̄)︿");
        }
    }
    

    多态

    什么是多态

    多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口,使用不同的实例而执行不同操作。

    向上转型

    通常来说,向上转型表示往父类的方向转
    在之前代码的基础上,写一个例子

    Bird bird = new Bird("圆圆"); 
    Animal bird2 = bird; 
    // 或者写成下面的方式
    Animal bird2 = new Bird("圆圆");
    

    此时 bird2 是一个父类 (Animal) 的引用, 指向一个子类 (Bird) 的实例. 这种写法称为 向上转型.

    动态绑定

    当子类和父类中出现同名方法的时候, 再去调用会对前面的代码稍加修改,如以下代码:

    class Animal {
        public String name;
    
        public Animal(String name) {
            this.name = name;
        }
    
        public void eat(String food) {
            System.out.println("我是一只小动物");
            System.out.println(this.name+"正在干饭,并表示"+food+"很不错");
        }
    }
    // Cat.java
    class Cat extends Animal{
        public Cat(String name) {
            super(name);
        }
    
        @Override
        public void eat(String food) {
            System.out.println("我是一只小猫");
            System.out.println(this.name+"正在干饭,并表示"+food+"很不错");
        }
    }
    // Bird.java
    class Bird extends Animal{
        public Bird(String name) {
            super(name);
        }
        @Override
        public void eat(String food) {
            System.out.println("我是一只小鸟");
            System.out.println(this.name+"正在干饭,并表示"+food+"很不错");
        }
    
        public void fly() {
            System.out.println(this.name + "正在飞 ︿( ̄︶ ̄)︿");
        }
    }
    public class Main{
    public static void main(String[] args){
    		Animal animal1 = new Animal("圆圆");
            animal1.eat("谷子");
            System.out.println("====================");
            Animal animal2 = new Bird("扁扁");
            animal2.eat("谷子");
    }
    }
    


    我们发现:
    animal1 和 animal2 虽然都是 Animal 类型的引用, 但是 animal1 指向 Animal 类型的实例, animal2 指向Bird 类型的实例.
    针对 animal1 和 animal2 分别调用 eat 方法, 发现 animal1.eat() 实际调用了父类的方法, 而animal2.eat() 实际调用了子类的方法.
    因此, 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为动态绑定

    向下转型

    向上转型是子类对象转成父类对象, 向下转型就是父类对象转成子类对象. 相比于向上转型来说, 向下转型没那么常见,但是也有一定的用途.

    class Animal {
        public String name;
        public Animal(String name) {
            this.name = name;
        }
        public void eat(String food) {
            System.out.println("我是一只小动物");
            System.out.println(this.name+"正在干饭,并表示"+food+"很不错");
        }
    }
    // Cat.java
    class Cat extends Animal{
        public Cat(String name) {
            super(name);
        }
        @Override
        public void eat(String food) {
            System.out.println("我是一只小猫");
            System.out.println(this.name+"正在干饭,并表示"+food+"很不错");
        }
    }
    // Bird.java
    class Bird extends Animal{
        public Bird(String name) {
            super(name);
        }
        @Override
        public void eat(String food) {
            System.out.println("我是一只小鸟");
            System.out.println(this.name+"正在干饭,并表示"+food+"很不错");
        }
    
        public void fly() {
            System.out.println(this.name + "正在飞 ︿( ̄︶ ̄)︿");
        }
    }
    public class Main {
        public static void main(String[] args) {
            Animal animal2 = new Bird("扁扁");
            animal2.fly();
        }
    }
    

    在这里插入图片描述
    注意:
    编译过程中, animal 的类型是 Animal, 此时编译器只知道这个类中有一个 eat 方法, 没有 fly 方法.
    虽然 animal 实际引用的是一个 Bird 对象, 但是编译器是以 animal 的类型来查看有哪些方法的。如果需要引用fly方法则需要对它进行向下转型
    操作如下

    Bird bird = (Bird)animal2; 
    bird.fly(); 
    

    在这里插入图片描述

    展开全文
  • 精选文库 PAGE PAGE 2 西 安 邮 电 大 学 计算机学院 课内实验报告 实验名称 继承...通过编程上机实验理解 Java 语言的继承和多态特性掌握变量的隐藏方法的覆盖重载掌握抽象类接口的使用 二实验要求 1.编写体现类的
  • 学习-Java继承和多态之子类继承性

    千次阅读 2021-06-27 09:38:58
    第1关:学习-Java继承和多态之子类继承性 任务描述 相关知识 编程要求 测试说明 任务描述 本关任务:定义一个 Dog 类,继承 Animal 类(Animal 类已经定义),定义自己的性别属性,并定义获取设置性别属性的...

    第1关:学习-Java继承和多态之子类继承性


    任务描述

    本关任务:定义一个 Dog 类,继承 Animal 类(Animal 类已经定义),定义自己的性别属性,并定义获取和设置性别属性的方法和 sleep 方法。

    相关知识

    继承是 Java 面向对象编程技术的一块基石,因为它允许创建分等级层次的类。

    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

    图 1

    如上图 1 所示,动物继承生物类,老虎又继承动物类。从这个例子中可以明显看出:越往上的类越抽象,越往下的类越具体。而在我们在设计的时候,父类也往往是比较抽象的类。接下来我们来看看如何使用继承。

    类的继承格式 在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:

     
    
    1. class 父类 {
    2. }
    3. class 子类 extends 父类 {
    4. }

    例子:

     
    
    1. class Animal {
    2. }
    3. class Tigger extends Animal {
    4. }

    表示的就是 Tigger 类继承了 Animal 类,我们可以说 Tigger 是 Animal 的子类,也可以说 Animal 是 Tigger 的超类或父类。Tigger 会继承 Animal 的域和方法,也就是说 Tigger 的实例对象可以调用 Anaimal 的方法和属性。

    事实上,我们每创建出一个类,都会隐式地继承根类 Object。这也就解释了为什么我们创建的新类,在实例化它之后我们就能调用 equals、getClass 等方法。比如 Animal 就隐式地继承了 Object 类。

    那为什么要使用继承呢?

    我们现在来看一个例子:

     
    
    1. class Anaimal {
    2. private String type; // 动物种类
    3. private int age; // 年龄
    4. // 设置和获取动物属性
    5. public String getType() {
    6. return type;
    7. }
    8. public void setType(String type) {
    9. this.type = type;
    10. }
    11. public int getAge() {
    12. return age;
    13. }
    14. public void setAge(int age) {
    15. this.age = age;
    16. }
    17. }
    18. class Tigger {
    19. private String name; // 老虎名称
    20. private int age; // 老虎年龄
    21. private String type; // 老虎种类
    22. // 设置和获取老虎属性
    23. public String getName() {
    24. return name;
    25. }
    26. public void setName(String name) {
    27. this.name = name;
    28. }
    29. public int getAge() {
    30. return age;
    31. }
    32. public void setAge(int age) {
    33. this.age = age;
    34. }
    35. public String getType() {
    36. return type;
    37. }
    38. public void setType(String type) {
    39. this.type = type;
    40. }
    41. }

    从这两段代码可以看出来,代码存在重复了,导致后果就是代码量大且臃肿,而且维护性不高(维护性主要是后期需要修改的时候,就需要修改很多的代码,容易出错),要从根本上解决这两段代码的问题,就需要使用继承。

    这个 Animal 类就可以作为一个父类,然后 Tigger 类继承这个类之后,就具有父类当中的属性和方法,子类就不会存在重复的代码,便于后期维护,代码也更加简洁,提高了代码的复用性(复用性主要是可以多次使用,不用再多次写同样的代码) ,使用继承的代码如下:

     
    
    1. class Anaimal {
    2. private String type;
    3. private int age;
    4. public Anaimal(String type, int age) {
    5. this.type = type;
    6. this.age = age;
    7. }
    8. public String getType() {
    9. return type;
    10. }
    11. public void setType(String type) {
    12. this.type = type;
    13. }
    14. public int getAge() {
    15. return age;
    16. }
    17. public void setAge(int age) {
    18. this.age = age;
    19. }
    20. }
    21. // 老虎类继承动物类
    22. class Tigger extends Anaimal{
    23. // 定义自己的名称属性
    24. private String name;
    25. // 如果子类没有覆盖父类的构造方法则默认调用父类的构造方法
    26. public Tigger(String type, int age) {
    27. super(type, age);
    28. }
    29. public String getName() {
    30. return name;
    31. }
    32. public void setName(String name) {
    33. this.name = name;
    34. }
    35. public static void main(String[] args) {
    36. Tigger tigger = new Tigger("老虎",18);
    37. tigger.setName("旺财");
    38. System.out.printf("动物品种:%s\t名称:%s\t年龄:%d",tigger.getType(),tigger.getName(),tigger.getAge());
    39. }
    40. }

    执行结果:

     
    
    1. 动物品种:老虎 名称:旺财 年龄:18

    继承的特性:

    • 子类拥有父类非 private 的属性、方法,实现了代码复用;
    • 本质上来说子类会继承父类的所有属性(包括 private),只是私有属性和方法无法直接使用;
    • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展;
    • 子类可以用自己的方式实现父类的方法,即重写/覆写(Override);
    • Java 的类继承是单继承,不支持多继承,单继承就是一个子类只能继承一个父类,但是一个父类可以被多个子类继承,而子类却不可以继承多个父类;
    • 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)。

    编程要求

    仔细阅读右侧编辑区内给出的代码框架及注释,按照提示编写程序代码。

    测试说明

    平台将使用测试集运行你编写的程序代码,若全部的运行结果正确,则通关。 可在右侧“测试结果”区查看具体的测试集详情。


    开始你的任务吧,祝你成功!

    /**
     * 任务:定义一个 Dog 类,继承 Animal 类,定义自己的性别属性,并定义获取和设置性别属性的方法和 sleep 方法。
     * 类名为:Dog
     */
    
    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
    /********** Begin **********/
    // 定义一个Dog的公开类,并继承Animal类
    public class Dog extends Anaimal{
    
    
        //定义小狗的性别sex,字符串类型
    private String sex;
    
        // 定义获取和设置小狗性别的方法。
        public String getSex(){
            return sex;
        }
        public void setSex(String sex){
            this.sex=sex;
        }
        public Dog(String type,String name,int age){
            super(type,name,age);
        }
    
        //定义小狗的睡觉方法,实现输出:一只名为xx性别为xx的小狗,现在xx岁,它正在睡觉
        public void sleep(){
            System.out.printf("一只名为%s性别为%s的小狗,现在%d岁,它正在睡觉",this.getName(),sex,this.getAge());
        }
    }
    /********** End **********/
    public class Anaimal {
        private String type;
        private String name;
        private int age;
    
        public Anaimal(String type, String name, int age) {
            this.type = type;
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getType() {
            return type;
        }
    
        public void setType(String type) {
            this.type = type;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    
    

    展开全文
  • 学习-Java继承和多态之子类对象特点

    千次阅读 2021-06-27 09:55:48
    第1关:学习-Java继承和多态之子类对象特点 任务描述 相关知识 子类对象的特点 instanceof 运算符 编程要求 测试说明 任务描述 本关任务:使用 instanceof 运算符判断所指对象是否为特定类的一个...

    第1关:学习-Java继承和多态之子类对象特点


    任务描述

    本关任务:使用 instanceof 运算符判断所指对象是否为特定类的一个实例。

    相关知识

    为了完成本关任务,你需要掌握:1. 子类对象的特点;2. instanceof 运算符。

    子类对象的特点

    在 Java 中一切都以对象的形式进行处理,在继承的机制中,创建一个子类对象,同样会创建一个父类子对象,这个对象与父类创建的对象是一样的。两者的区别在于后者来自外部,而前者来自子类对象的内部。当实例化子类对象时,父类对象相应被实例化。换句话说,在实例化子类对象时,Java 编译器会在子类的构造方法中自动调用父类的无参构造方法。

    例子:

    1. class Person {
    2. // 父类无参构造方法
    3. Person() {
    4. System.out.println("调用父类的构造方法");
    5. }
    6. }
    7. // 子类继承父类
    8. class Students extends Person{
    9. // 子类无参构造方法
    10. Students() {
    11. System.out.print("调用子类的构造方法");
    12. }
    13. }
    14. class Demos{
    15. public static void main(String[] args) {
    16. // 实例化一个子类对象
    17. Students s = new Students();
    18. }
    19. }

    执行结果:

    1. 调用父类的构造方法
    2. 调用子类的构造方法

    我们发现实例化子类对象时,会先实例化父类对象,然后再实例化子类对象,所以在子类构造方法访问父类的构造方法之前,父类已经完成实例化操作。

    在实例化子类对象时,父类无参构造方法将被自动调用。有参构造方法不能被自动调用,用户只能使用 super 关键字显示地调用父类的构造方法。

    当用子类的构造方法创建一个子类的对象时,不仅子类中声明的成员变量被分配了内存,而且父类的成员变量也都被分配了内存空间,但只将其中子类继承的那部分成员变量为分配给子类的变量。但为什么要将未继承的变量分配内存呢?因为,子类也许有一部分方法从父类继承,而这部分方法却可以操作继承的变量。所以我们需要。

    1. class Person {
    2. // 定义腿属性,并设置为 2
    3. private int leg = 2;
    4. int money; // 定义钱属性
    5. // 定义 action 方法,设置腿的数量为 5,并输出相关信息
    6. void action(){
    7. leg = 5;
    8. System.out.print(leg);
    9. }
    10. }
    11. // Man 类继承 Person 类
    12. class Man extends Person{
    13. int height;
    14. }
    15. class human{
    16. public static void main(String args[]){
    17. Man you = new Man(); /*这条语句的执行意味着:money,leg,height,action 都被分配了空间*/
    18. you.action(); //这条语句的执行说明了子类可以通过继承的方法来操作没继承来的变量
    19. }
    20. }

    执行结果:

    1. 5

    instanceof 运算符

    Java 中的 instanceof 运算符是用来在运行时判断对象是否是特定类的一个实例。instanceof 通过返回一个布尔值来指出,这个对象是否是这个特定类或者是它的子类的一个实例。

    用法:

    1. boolean result = Object instanceof Class;

    名词介绍:

    • result:布尔类型;
    • Object:必选项。任意对象表达式;
    • Class:必选项。任意已定义的对象类。 说明: 如果 Object 是 Class 的一个实例,则 instanceof 运算符返回 true;如果 Object 不是指定类的一个实例,或者 Object 是 null,则返回 false。

    需要注意的是 instanceof 在 Java 的编译状态和运行状态是有区别的:

    在编译状态中,Class 可以是 Object 对象的父类、自身类、子类。在这三种情况下 Java 编译时不会报错。

    在运行转态中,Class 可以是 Object 对象的父类,自身类,不能是子类。在前两种情况下 result 的结果为 true,最后一种为 false。但是 class 为子类时编译不会报错,运行结果为 false。

    例子:

    1. class instanceOfDemo{
    2. public static void main(String []args){
    3. instanceOfDemo t=new instanceOfDemo();
    4. if(t instanceof instanceOfDemo){
    5. System.out.println("t是instanceOfDemo的实例");
    6. }
    7. }
    8. }

    执行结果:

    1. tinstanceOfDemo的实例

    编程要求

    仔细阅读右侧编辑区内给出的代码框架及注释,按照提示编写程序代码。

    测试说明

    平台将使用测试集运行你编写的程序代码,若全部的运行结果正确,则通关。 可在右侧“测试结果”区查看具体的测试集详情。


    开始你的任务吧,祝你成功!

    /**
     * 任务:使用 instanceof 运算符判断指定对象是否为特定类的一个实例
     */
    class Person{}
    class Students extends Person{}
    class Sch extends Students{}
    public class Demos{
        public static void main(String[] args) {
            // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
            /********* Begin *********/
            // 创建一个Students对象,判断该对象是否是Person类的实例
            //如果是输出:true,否则为false
        Students students=new Students();
        if(students instanceof Person){
            System.out.println("true");
        }else System.out.println("false");
            // 创建一个Sch对象,判断该对象是否是Person类的实例
            // 输出判断结果
        Sch sch=new Sch();
        if(sch instanceof Person){
            System.out.println("true");
        }else System.out.println("false");
            // 创建一个Person对象,判断该对象是否是Students类的实例
            // 输出判断结果
        Person person = new Person();
        if(person instanceof Students){
            System.out.println("true");
        } else System.out.println("false");
            /********** End **********/
        }
    }
    

    展开全文
  • 父类属性方法的继承 面向对象传参机制 get()set()方法的使用 public class Dog extends Animal{ //继承父类 private String sex; public String getSex(){ return sex; } public Dog(String type, ...
  • 第1关:学习-Java继承和多态之对象类型的转换 任务描述 相关知识 向上转型 向下转型 编程要求 测试说明 任务描述 本关任务:使用对象类型的转换,根据编程提示,完成猫类动物类的转换,以及彼此方法...
  • 继承性 通关源码 public class Triangle extends Shape{ // 定义一个area方法,实现计算矩形面积的功能。 public double area(){ double s = this.getHeight() * this.getWidth() * 0.5; return s; } } ...
  • 学习-Java继承和多态之abstract类

    千次阅读 2021-06-27 10:44:20
    第1关:学习-Java继承和多态之abstract类 任务描述 相关知识 编程要求 测试说明 任务描述 本关任务:根据所学知识,完成抽象类的定义与使用。 相关知识 Java 语言提供了两种类,分别为具体类抽象类。前面...
  • 学习-Java继承和多态之final关键字

    千次阅读 2021-06-27 09:45:34
    第1关:学习-Java继承和多态之final关键字 任务描述 相关知识 final 关键字的使用 final 关键字修饰类、成员变量成员方法 编程要求 测试说明 任务描述 本关任务:调试代码,对代码进行增添、删除修改...
  • 学习-Java继承和多态之方法重写

    千次阅读 2021-06-27 09:50:58
    第1关:学习-Java继承和多态之方法重写 任务描述 相关知识 编程要求 测试说明 任务描述 本关任务:重写 Cat 类中的 toString 方法,返回 Cat 类的基本信息。 相关知识 在子类中如果创建了一个与父类中相同...
  • Rectangle.java /** * 任务:定义一个矩形 Rectangle 类,继承 Shape 类, * 在这个类中分别定义一个名为 area 的方法,实现计算该形状面积的功能。 * 类名为:Rectangle */ // 定义一个Rectangle的公开类,并...
  • 掌握知识点[1,2] 接口基本知识 构造器的使用 通关源码[1] /** * Create By 刘鸿涛 * 2021/12/15 10:44 */ interface Compute { public int sum(); //接口中方法public 可以省略 public int max(int m,int n);...
  • 第1关:学习-Java继承和多态之成员变量隐藏之优惠促销价格计算 任务描述 相关知识 编程要求 测试说明 任务描述 本关任务:计算商品打折后的价格。 相关知识 在编写子类的时候,我们仍然可以声明一些新的成员...
  • 练习-Java继承和多态之方法重写

    千次阅读 2021-06-27 10:27:04
    第1关:练习-Java继承和多态之方法重写 任务描述 编程要求 测试说明 任务描述 本关任务:计算球的表面积。 编程要求 仔细阅读右侧编辑区内给出的代码框架及注释,按照提示编写程序代码。 测试说明 平台将...
  • 练习-Java继承和多态之方法重载

    千次阅读 2021-06-27 10:49:29
    第1关:练习-Java继承和多态之方法重载 任务描述 编程要求 测试说明 任务描述 本关任务:定义名为 print 的静态方法,携带一个参数,无论该参数是 int 型、double 型还是字符串型,都可以将该参数进行打印。 ...
  • 练习-Java继承和多态之final关键字

    千次阅读 2021-06-27 09:42:29
    第1关:练习-Java继承和多态之final关键字 任务描述 编程要求 测试说明 任务描述 本关任务:按照代码文件中提供的注释完成 Demo 类的编写,使得程序正常输出。 编程要求 仔细阅读右侧编辑区内给出的代码框架及...
  • 本关任务:定义一个矩形 Rectangle 类 三角形 Triangle 类,都继承 Shape 类,在这两个类中分别定义 一个名为 area 的方法,实现计算该形状面积的功能(Shape 类已经定义完成,可以在 Shape.java 文件查看相应代码...
  • 练习-Java继承和多态之abstract类

    千次阅读 2021-06-27 10:38:21
    第1关:练习-Java继承和多态之abstract类 任务描述 编程要求 测试说明 任务描述 本关任务:通过图形类的计算面积的方法,计算矩形三角形的面积。 编程要求 仔细阅读右侧编辑区内给出的代码框架及注释,在 ...
  • 掌握知识点 intanceof运算符语法 子类对象特点 通关源码 /** * 任务:使用 instanceof 运算符判断指定对象是否为特定类的一个实例 */ class Person{ ...class Students extends Person{ ... Students stu = n
  • 任务描述 编程要求 测试说明 任务描述 本关任务:定义名为 print 的静态方法,携带一个参数,无论该参数是 int 型、double 型还是字符串型,都可以将该参数进行打印。 编程要求 仔细阅读右侧编辑区内给出的代码...
  • Java继承和多态——子类继承性

    千次阅读 2022-04-25 15:55:01
    Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下: class 父类 { } class 子类 extends 父类 { } 例子: class Animal { } class Tigger extends Animal { } 表示的...
  • 第1关:学习-Java继承和多态之子类继承性 任务描述 本关任务:定义一个 Dog 类,继承 Animal 类(Animal 类已经定义),定义自己的性别属性,并定义获取设置性别属性的方法 sleep 方法。 相关知识 继承是 Java ...
  • 实验项目名称 继承多态 所属课程 Java 语言程序设计 院 系 专业班级 ...2. 实验内容 1模拟编写程序理解类的继承多态继承多态规则 2 独立编程实现类的继承多态 3. 实验作业 设计一个类 Shape 图形包含求面积周长
  • 任务描述 本关任务:判断梨类、苹果类水果类的关系,并通过对象类型转换调用彼此的属性方法。 /** * 判断梨类、苹果类水果类的关系,并通过对象类型转换...// 苹果类继承水果类 class Apple extends Fruits {
  • * 任务:定义一个 Dog 类,继承 Animal 类,定义自己的性别属性,并定义获取设置性别属性的方法 sleep 方法。 * 类名为:Dog */ // 定义一个Dog的公开类,并继承Animal类 class Dog extends Animal{ //定义...
  • 练习-Java继承和多态之成员变量隐藏

    千次阅读 2022-02-11 12:32:43
    本关任务:定义一个 NewWeight 的公开类,并继承 OldWeight 类(该类已定义),在该类中实现计算身高的标准体重。 计算公式:体重 = 身高 - 105; /** * 任务:定义一个 NewWeight 的公开类,并继承 OldWeight ...
  • 本关任务:定义一个矩形 Rectangle 类 三角形 Triangle 类,都继承 Shape 类,在这两个类中分别定义 一个名为 area 的方法,实现计算该形状面积的功能(Shape 类已经定义完成,可以在 Shape.java 文件查看相应代码...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 197,765
精华内容 79,106
关键字:

java继承和多态

友情链接: Calc in C v5.2.rar