第2关:多态

简介: 第2关:多态

任务描述

   本关任务:本关主题是以手机品牌为例,理解Scala面向对象编程中方法重写和多态请仔细阅读下面“相关知识”中的内容,理解每个手机类所需完成的操作,补全huawei类中的函数,使得程序运行结果如预期输出。


相关知识


   为了完成本关任务,你需要掌握:1.如何方法重写,2.如何实现多态。

#####方法重写

   方法重写指的是当子类继承父类时,从父类继承过来的方法不能满足自身的需要,子类希望有自己的实现,这时需要对父类的方法进行重写(override),方法重写是实现多态和动态绑定的关键。Scala 语言中的方法重写与 Java 语言中的方法重写一样,也是通过override关键字对父类中的方法进行重写,从而实现子类自身处理逻辑。


class Phone(var phoneBrand:String,var price:Int){  
   //对父类Any中的toString方法进行重写  
   override def toString=s"Phone($phoneBrand,$price)"  
}
class Apple(phoneBrand:String,price:Int,var place:String)extends Phone(phoneBrand,price){  
  //对父类Phone中的toString方法进行重写  
   override def toString=s"Apple($phoneBrand,$price,$place)"  
}
object TestPhone{  
   def main(args:Array[String]){  
    //调用Apple类自身的toString方法返回结果  
      println(new Apple("iphone",5400,"Shenzhen"))  
   }  
}  


运行结果:


Apple(iphone,5400,shenzhen)

    如果不重写父类的toString方法,则返回的结果是类名加hashcode值,例如:


scala> class Phone(var phoneBrand:String,var price:Int)  
defined class Phone
scala> new Phone("HuaWei",4500)  
res1: Phone = Phone@55881f40  


多态与继承


   实现继承后,子类可以拥有父类的属性和方法,也可以在子类中添加新的类成员或重写父类中的方法。多态是在继承的基础上实现的一种语言特性,它指的是允许不同类的对象对同一消息做出响应,即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

   多态也称动态绑定或延迟绑定,指在执行期间而非编译期间确定所引用对象的实际类型,根据其实际类型调用其相应的方法,也就是说子类的引用可以赋给父类,程序在运行时根据实际类型调用相应的方法。多态主要作用就是消除类型之间的耦合关系。多态存在的三个必要条件是:要有继承;要有重写;父类引用指向子类对象。


  //定义父类Phone  
class Phone(var phoneBrand:String,var price:Int){  
    def buy():Unit=println("buy() method in Phone") //buy方法,无参数  
  //compare方法,参数为Phone类型  
    def compare(p:Phone):Unit=println("compare() method in Phone")  
}
   //定义子类Apple  
class Apple( phoneBrand:String,price:Int) extends Phone(phoneBrand,price){  
   private var AphoneNo:Int=0  
  //重写父类compare方法  
   override def compare(p:Phone):Unit={  
       println("compare() method in Apple")  
       println(this.phoneBrand+" is compared with "+p.phoneBrand)  
  }  
} 


    若创建 Apple 类对象,父类 Phone 引用指向该对象:


val p1:Phone=new Apple("iphone",6400)


   使用父类引用p1调用compare方法,则真正调用的是子类 Apple 中重写的compar方法;若父类引用p1调用buy方法,由于子类 Apple 中未重写父类中的buy方法,将毫无疑问地调用父类中的buy方法。


####编程要求


   本关的编程任务是根据预期结果补全 HuaWei 类中从 Phone 类继承的函数,考虑是否需要重写各方法。


测试说明


下面是对平台如何评测你所实现功能的说明及样例测试。

测试输入:无输入

预期结果:


buy() method in HuaWei
compare() method in HuaWei
huawei is compared with iphone
-----------------------------
buy() method in Phone
compare() method in Apple
iphone is compared with huawei
————————————————
版权声明:本文为CSDN博主「真题OK撒」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/qq_51916951/article/details/124052081


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


object TestPhone{
    //定义父类Phone
    class Phone(var phoneBrand:String,var price:Int){
        def buy():Unit=println("buy() method in Huawei") //buy方法,无参数
        //compare方法,参数为Phone类型
        def compare(p:Phone):Unit=println("compare() method in Huawei")
    }
    //定义子类Apple
    class Apple( phoneBrand:String,price:Int) extends Phone(phoneBrand,price){
        private var AphoneNo:Int=0
        //重写父类compare方法
        override def buy():Unit=println("buy() method in Phone")
        override def compare(p:Phone):Unit={
            println("compare() method in Apple")
            println(this.phoneBrand+" is compared with "+p.phoneBrand)
        }
    }
    //定义子类HuaWei
    class HuaWei(phoneBrand:String,price:Int) extends Phone(phoneBrand,price){
        private var HphoneNo:Int=0
        //**************Begin*************************
        override def buy():Unit=println("buy() method in HuaWei")
        override def compare(p:Phone):Unit={
            println("compare() method in HuaWei")
            println(this.phoneBrand+" is compared with "+p.phoneBrand)
        }
        //**************Begin*************************
    }
    //运行入口
    def main(args: Array[String]){
        val p1:Phone=new HuaWei("huawei",4500)
        val p2:Phone=new Apple("iphone",6400)
        p1.buy()
        p1.compare(p2)
        println("-----------------------------")
        /*p2引用的是Apple类型的对象,Apple类未对父类中的buy方法进行重写,因此它调用的是继承自父类的buy方法*/
        p2.buy()
        //p2.compare(p1)传入的实际类型是HuaWei,调用的是Apple类重写后的compare方法
        p2.compare(p1)
    }
}
目录
相关文章
|
2月前
实现多态的多种方式
【10月更文挑战第19天】这些多态的实现方式各有特点,在不同的场景中可以灵活运用,以提高代码的灵活性、可扩展性和复用性。
107 63
|
7月前
|
Java
Java面向对象编程:就近原则与this关键字详解
Java面向对象编程:就近原则与this关键字详解
67 0
|
7月前
|
C++
C++示例(电脑组装)展现C++多态的优势以及虚函数抽象类的应用
C++示例(电脑组装)展现C++多态的优势以及虚函数抽象类的应用
|
Java
继承性和多态性实验
继承性和多态性实验
93 0
|
设计模式
26【软件基础】简单计算器的实现+工厂方法模式应用+封装、继承、多态的体现
工厂方法模式是一种常用的`创建型设计模式`,它提供了一种将对象的创建过程封装起来的方法。在工厂方法模式中,将对象的创建过程交给一个`工厂类`来完成,而不是在代码中直接调用构造函数来创建对象。这样可以使得代码更加灵活,`降低耦合度`,方便后期维护和扩展。
168 0
|
设计模式 安全 Java
设计规则之里氏替换原则
设计规则之里氏替换原则
74 0
设计规则之里氏替换原则
|
设计模式 Java
抽象类随记
当父类的某些方法不能确定时,定义为抽象方法;用abstract修饰 被abstract修饰的方法叫抽象方法,被abstract修饰的类叫抽象类;
59 0
|
编译器 C++
【C++】多态(万字详解) —— 条件 | 虚函数重写 | 抽象类 | 多态的原理(上)
【C++】多态(万字详解) —— 条件 | 虚函数重写 | 抽象类 | 多态的原理(上)
170 0
【C++】多态(万字详解) —— 条件 | 虚函数重写 | 抽象类 | 多态的原理(上)
|
Linux C++
【C++】多态(万字详解) —— 条件 | 虚函数重写 | 抽象类 | 多态的原理(下)
【C++】多态(万字详解) —— 条件 | 虚函数重写 | 抽象类 | 多态的原理(下)
146 0
【C++】多态(万字详解) —— 条件 | 虚函数重写 | 抽象类 | 多态的原理(下)
|
Java Maven
你有没有掉进去过这些 抽象类 和 接口 的 “陷阱“
你有没有掉进去过这些 抽象类 和 接口 的 “陷阱“
你有没有掉进去过这些 抽象类 和 接口 的 “陷阱“