Scala面向对象编程之继承下篇、Scala中使用模式匹配进行类型判断、Scala中protected、Scala中调用父类的constructor、匿名内部类、抽象类、抽象field 12

悠悠 2022-01-31 08:15 205阅读 0赞

# 1. Scala中使用模式匹配进行类型判断 #

*  在实际的开发中，比如spark源码中，大量的地方使用模式匹配的语法进行类型的判断，这种方式更加地简洁明了，而且代码的可维护性和可扩展性也非常高；
 *  **使用模式匹配，功能上来说，与isInstanceOf的作用一样，主要判断是否为该类或其子类的对象即可，不是精准判断。**
 *  等同于 **java中的switch case语法**；
 *  代码如下

class Person5{ }
    class Student5 extends Person5
    object Student5{ 
    	def main(args:Array[String]){ 
    		val p:Person5 = new Student5
    		p match{ 
    			//匹配是否为Person类或其子类对象
    			case per:Person5 => println("This is a Person5's Object")
    			//匹配所有剩余情况
    			case _ => println("Unknown type!")
    		}
    	}
    }

# 2. Scala中的protected关键字 #

*  跟java一样，Scala中同样适用**protected关键字**来修饰field和method。在子类中，可直接访问父类的field和method，而不需要适用super关键字；
 *  还可以使用**protected\[this\]关键字**：访问权限的保护范围，**只允许在当前子类中**访问父类的field和method，不允许通过其他子类对象访问父类的field和method。
 *  代码如下

class Person6{ 
    	protected var name:String = "tom"
    	protected[this] var hobby:String = "game"
    	protected def sayBye = println("Byebye...")
    }
    class Student6 extends Person6{ 
    	//父类使用protected关键字来修饰field可以直接访问
    	def sayHello = println("Hello" + name)
    	//父类使用protected关键字来修饰method可以直接访问
    	def sayByeBye = sayBye
    	def makeFriends(s:Student6) = { 
    		println("My hobby is "+hobby+", your hobby is UnKnown")
    	}
    }
    
    object Student6{ 
      def main(args: Array[String]) { 
        val s:Student6=new Student6
        s.sayHello
        s.makeFriends(s)
        s.sayByeBye
      }
    }

# 3. Scala中调用父类的constructor #

*  Scala中，每个类都可以有一个主constructor和任意多个辅助constructor，而且每个辅助constructor的第一行都必须调用其他辅助constructor或者主constructor代码；**因此子类的辅助constructor是一定不可能直接调用父类的constructor的**；
 *  只能在子类的主constructor中调用父类的constructor。
 *  如果父类的构造函数已经定义过的 field，比如name和age，子类再使用时，就不要用 val 或 var 来修饰了，否则会被认为，子类要覆盖父类的field，且要求一定要使用 override 关键字。
 *  代码如下

class
     Person7(val name:String,val age:Int){ 
    	var score:Double = 0.0
    	var address:String = "beijing"
    	def this(name:String,score:Double) = { 
    		//每个辅助constructor的第一行都必须调用其他辅助constructor或者主constructor代码
    		//主constructor代码
    		this(name,30)
    		this.score = score
    	}
    	//其他辅助constructor
    	def this(name:String,address:String) = { 
    		this(name,100.0)
    		this.address = address
    	}
    class Student7(name:String,score:Double) extends Person7(name,score)
    }

# 4. Scala中匿名内部类 #

*  在Scala中，匿名内部类是非常常见的，而且功能强大。Spark的源码中大量的使用了匿名内部类；
 *  **匿名内部类，就是定义一个没有名称的子类，并直接创建其对象，然后将对象的引用赋予一个变量，即匿名内部类的实例化对象。然后将该对象传递给其他函数使用**。
 *  代码如下

class Person8(val name:String) { 
      def sayHello="Hello ,I'm "+name
    }
    class GreetDemo{ 
      //接受Person8参数，并规定Person8类只含有一个返回String的sayHello方法
      def greeting(p:Person8){ 
          def sayHello:String})={ 
              println(p.sayHello)
      }
    }
    object GreetDemo { 
      def main(args: Array[String]) { 
        //创建Person8的匿名子类对象
        val p=new Person8("tom")
        val g=new GreetDemo
        g.greeting(p)
      }
    }

# 5. Scala中的抽象类 #

*  如果在父类中，有某些方法无法立即实现，而需要依赖不同的子类来覆盖，重写实现不同的方法。此时，可以将父类中的这些方法编写成只含有方法签名，不含方法体的形式，这种形式就叫做抽象方法;
 *  **一个类中，如果含有一个抽象方法或抽象field，就必须使用abstract将类声明为抽象类，该类是不可以被实例化的;**
 *  在子类中覆盖抽象类的抽象方法时，**可以不加override关键字;**
 *  举例说明：

abstract class Person9(val name：String){ 
    	//必须指出返回类型，不然默认返回Unit
    	def sayHello：String
    	def sayBey:String
    }
    class Student9(name:String) extends Person9(name){ 
    	//必须指出返回类型，不然默认
    	def sayHello:String = "Hello," + name
    	def sayBye:String = "Bye," + name
    }
    object Student9{ 
    	def main(args:Array[String]){ 
    		val s = new Student9("tom")
    		println(s.sayHello)
    		println(s.sayBye)
    	}
    }

# 6. Scala中的抽象字段field #

*  如果在父类中，定义了field，但是没有给出初始值，则此field为抽象field；
 *  代码如下

abstract class Person10(val name:String){ 
    	//抽象fields
    	val age:Int
    }
    class Student10(name:String) extends Person10(name){ 
    	val age:Int = 50
    }