试类在子包 ×
7>>封装类在父包,添加scala04,测试类在子包 √
8>>封装类在父包,添加scala04,测试类在父包 √
1>>封装类在子包,省略this,测试类在子包 √
2>>封装类在子包,省略this,测试类在父包 ×
3>>封装类在子包,添加this,测试类在父包 ×
4>>封装类在子包,添加this,测试类在子包 √
5>>封装类在子包,添加Scala04,测试类在子包 √
6>>封装类在子包,添加Scala04,测试类在父包 √
7>>封装类在子包,添加demo,测试类在父包 ×
8>>封装类在子包,添加demo,测试类在子包 √
总结:(1)private[this]修饰类表示当前包下及其子包都可以访问,[this]可以省略;
(2)若在子包中定义private类,只能子包访问,如想父包访问,需要在private后添加[父包名]
(3)若在父包中定义private类,且添加[子包名],则父包与子包都无法访问该类
三、伴生对象:
定义:在同一个类文件中,单例对象名与类名相同的两个单例对象和类,称之为伴生对象。
class Person6 (private var name:String,age:Int){
var high:Int = _
def this (name:String,age:Int,high:Int){
this(name,age)
this.high = high
}
}
object Person6{
def main(args: Array[String]): Unit = {
val p = new Person6("hunter",30)
println(p.name)
}
}
注意:单例对象可以访问其伴生对象类的私有成员变量和方法,
但伴生对象他们必须在同一个类文件中。
四、Scala特质和混入特质
特质:相当于java中的接口
混入特质:相当与实现多个接口
trait Animal {
//定义未实现方法
def eat(name:String)
//定义实现的方法
def sleep(name:String):Unit={
println(s"$name 在睡觉")
}
}
trait Running {
def how(str:String)
}
object Pig extends Animal with Running {
override def eat(name: String): Unit = {
println(s"$name 在吃鸡")
}
override def how(str: String): Unit = {
println(f"$str 在奔跑")
}
def main(args: Array[String]): Unit = {
Pig.sleep("reba")
Pig.eat("wyh")
Pig.how("hunter")
}
}
注意:(1)Scala中没有implement,只有extends
(2)Idea中ctrl+i与ctrl+o的区别:
ctrl+i:实现未实现的方法
ctrl+o:重写已经实现的方法
五、Scala抽象类
abstract class AbstractDemo {
def eat(food:String)
def sleep(how:String):Unit={
println(s"$how->很香")
}
}
object AbstractImpl extends AbstractDemo {
override def eat(food: String): Unit = {
println(s"hunter is eating $food")
}
override def sleep(how: String): Unit ={
println(s"hunter 睡得$how")
}
def main(args: Array[String]): Unit = {
AbstractImpl.eat("大猪蹄子")
AbstractImpl.sleep("很香")
}
}
注意:Scala中可以先继承抽象类在继承特质,但是抽象类必须写在前面!!
六、模式匹配(match/case)
以下为三个模式匹配的例子,分别匹配了字符串、数组、元祖三种类型:
object MatchTest {
def main(args: Array[String]): Unit = {
def strMatch(str:String):Unit = str match {
case "Hunter" => println("很帅?")
case "reba" => println("真的美")
case _ => println("what?")
}
strMatch("Hunter")
strMatch("hunter")
def ArrayMatch(arr:Any):Unit = arr match {
case Array(1) => println("只有一个元素的数组")
case Array(1,2) => println("有两个元素的数组")
}
ArrayMatch(Array(1))
def tupleMatch(tuple:Any):Unit = tuple match {
case (1,_) => println("元祖第一个元素为1,第二个元素为任意类型")
case ("hunter",34) => println("这哥们老帅了")
}
tupleMatch(("hunt