8Scala面向对象(二)

2.3 单例对象

单例对象定义

单例对象表示全局仅有一个对象,类似Java中static的概念
与定义类很像,把class换成object
object中的成员变量与Java中的静态变量类似
可以使用object直接引用成员变量和成员方法

案例:定义一个猫单例对象,定义eat方法和catfoot不可变量

object Cat {
  val CAT_FOOT = 4
  def eat():Unit = {
    println("吃老鼠")
  }
  def main(args: Array[String]): Unit = {
    println(Cat.CAT_FOOT)
    Cat.eat()
  }
}

单例对象工厂

单例对象常用于工厂(工具),封装某些操作
案例:创建一个工具,可以使字符串和date数据互相转换

object DateUtils {
  val dateFormat = new SimpleDateFormat("yyyy-MM-dd")
  def String_to_date(date:String):Date = dateFormat.parse(date)
  def date_to_String(date:Date):String = dateFormat.format(date)
  def main(args: Array[String]): Unit = {
    var str = "1992-2-2"
    println(DateUtils.String_to_date(str))
    var d = new Date()
    println(date_to_String(d))
  }
}

2.4 伴生对象

同时有实例成员又有静态成员的类,在scala中可以使用伴生对象来实现,还可使用伴生对象创建对象

2.4.1 伴生对象的定义

class和object具有相同名字,object称为伴生对象,class称为伴生类

必须同名,必须在同一个scala源文件中,两者可以互相访问private属性

案例:定义一个消费者类,类中有buy方法,同时定义消费者对象,有私有属性

class Constomer {
  def buy(name:String) = {
    println(s"${name}:买了${Constomer.PRODUCT}")
  }
}
object Constomer {
  private var PRODUCT = "fish"
  def main(args: Array[String]): Unit = {
    var con = new Constomer
    con.buy("lili")
  }
}

2.4.2 访问权限

类中如果某个成员设置为private[this],表示只能在当前类中访问.伴生对象也不可以访问

案例:定义一个Constomer类,包含一个name字段,定义Constomer类的伴生对象,定义test方法,检验伴生对象是否能访问private[this]权限的成员

class Constomer1(private[this] var name:String="lisi")
object Constomer1 {
  def test(con:Constomer1)={
    println(con.name)	//报错,无法访问类中private[this]
  }
  def main(args: Array[String]): Unit = {
    var con = new Constomer1("lisi")
    Constomer1.test(con)
  }
}

2.4.3 apply方法

语法:

基于伴生对象借助apply方法可以不用new直接构建类对象

案例:定义一个Teacher类,重写apply方法,使用Teacher类名就可以创建对象

class Teacher(var name:String, var age:Int)
object Teacher {
  def apply(name:String, age:Int):Teacher = new Teacher(name, age)
  def main(args: Array[String]): Unit = {
    var tea = Teacher("tom", 30)
    println(tea.age)
    println(tea.name)
  }
}

2.5 继承

2.5.1 继承定义

和Java一样使用关键字extends实现继承

可以在子类中定义父类没有的字段和方法,或重写父类的方法

类和单例对象都可以从某个父类继承

语法:

案例:类的继承

class Person {
  var name:String = "lisi"
  def getName():String = this.name
}
class Teacher1 extends Person
object ExtendsTest {
  def main(args: Array[String]): Unit = {
    var tea = new Teacher1
    println(tea.getName())
  }
}

案例:对象的继承

object Teacher2 extends Person
object ExtendsTest1 {
  def main(args: Array[String]): Unit = {
    println(Teacher2.getName())
    println(Teacher2.name)
  }
}

2.5.2 override 和 super

和Java类似,子类中使用override重写父类的成员,用super引用父类
子类要覆盖父类的一个方法,必须要用override关键字
只有父类变量为val定义时才能重写
案例:父类person定义name属性和getName方法,构建子类重写name属性和getName方法

class Teacher3 extends Person {
  override val name:String = "jake"
  override def getName(): String = "child:" + super.getName()
}
object ExtendsTest2 {
  def main(args: Array[String]): Unit = {
    var tea = new Teacher3
    println(tea.getName())
    println(tea.name)
  }
}

2.5.3 类型判断

scala中 isInstanceOf判断对象是否为指定类的对象 asInstanceOf将对象转为指定类型
语法:
案例:

class Teacher4 extends Person{}
object ExtendTest3 {
  def main(args: Array[String]): Unit = {
    var tea:Person = new Teacher4
    var b:Boolean = tea.isInstanceOf[Person]
    println(b)
    var c = tea.asInstanceOf[Teacher4]
    println(c)
  }
}

2.5.4 运行时类

object ExtendsTest4 {
  def main(args: Array[String]): Unit = {
    var tea:Person = new Teacher4
    var b:Boolean = tea.isInstanceOf[Person]
    println(b)
    var d:Class[_ <: Person] = tea.getClass
    println(d)
    var e:Class[Teacher4] = classOf[Teacher4]
    println(e)
    println(d == e)
  }
}

2.6 抽象类

案例1:

package com.wangbin.sy8

abstract class Shape {
  var name:String
  def area:Double
}

class Square(var len:Double, var name:String) extends Shape {
  override def area: Double = len * len
}

class Rectangle(var height:Double, var width:Double,var name:String) extends Shape {
  override def area: Double = height * width
}

class Circle(var rad:Double, var name:String) extends Shape {
  override def area: Double = Math.PI * rad * rad
}

object shapeTest {
  def main(args: Array[String]): Unit = {
    var sq = new Square(12,"正方形")
    println(sq.area)
    var re = new Rectangle(12,8,"长方形")
    println(re.area)
    var ci = new Circle(12,"圆形")
    println(ci.area)
  }
}

案例2:

package com.wangbin.sy8

abstract class Person1 {
  var NAME:String
}
class Teacher5 extends Person1{
  override var NAME: String = "tom"
}
object abstrctTest {
  def main(args: Array[String]): Unit = {
    var tea=new Teacher5
    println(tea.NAME)
  }
}

2.7 匿名类

abstract class Person2 {
  def NAME:String
  def area:Unit
}
object Person_test{
  def main(args: Array[String]): Unit = {
    var person=new Person2 {
      override def NAME: String = "lisi"
      override def area:Unit = {
        println("test.....")
      }
    }
    println(person.NAME)
    person.area
  }
}

实验总结