1.18

apply 方法
可以在创建对象时免去 new 操作，格式：

object 伴生对象名{
def apply(参数名:参数类型...) = new 类(...)
}

示例：

object ClassDemo {

//半生类
class Person(name:String, age:Int){
}

//伴生对象
object Person{
def apply(name:String, age:Int): Person = new Person(name, age)
}

def main(args: Array[String]): Unit = {
val person = Person("sjh", 24)
}

}

案例：定义工具类
import java.text.SimpleDateFormat
import java.util.Date

object DateUtils {

var sdf:SimpleDateFormat = _

//日期转字符串
def date2String(date:Date, template:String): String = {
sdf = new SimpleDateFormat(template)
sdf.format(date)
}

//字符串转日期
def string2Date(dateStr:String, template:String): Date = {
sdf = new SimpleDateFormat(template)
sdf.parse(dateStr)
}

}

继承和抽象类
继承
语法：

class/object 子类 extends 父类{

}

子类重写方法必须使用 override 修饰，可以使用 override 重新一个 val 字段，父类的 var 字段不可重写。

示例：

object ClassDemo {

class Person{
val name = ""
var age = 24

def say(): Unit = print("")
}

class Student extends Person{
override val name = "sjh"

override def say(): Unit = print("hello")
}

def main(args: Array[String]): Unit = {
val student = new Student()
student.say()//hello
}

}

类型判断
isInstanceOf 判断对象是否为指定类的对象
asInstanceOf 将对象转换为指定类型
示例：

object ClassDemo {

class Person{
}

class Student extends Person{
def say(): Unit = print("hello")
}

def main(args: Array[String]): Unit = {
val p:Person = new Student()
if(p.isInstanceOf[Student]) {
val s = p.asInstanceOf[Student]
s.say()
}
}

}

isInstanceOf 只能判断对象是否为指定类以及其子类的对象而不能精确判断其类型，如果精确判断可以使用 getClass 和 classOf 来实现。

示例：

object ClassDemo {

class Person{
}

class Student extends Person{
}

def main(args: Array[String]): Unit = {
val p:Person = new Student()
print(p.getClass == classOf[Person])//false
print(p.getClass == classOf[Student])//true
}

}

抽象类
如果类中有抽象字段或抽象方法，那么该类就必须是抽象类。

抽象字段：没有初始化的变量。

抽象方法：没有方法体。

格式：

abstract class 抽象类名{
val/var 抽象字段名:类型
def 方法名(参数:参数类型...):返回类型
}

示例：

object ClassDemo {

abstract class Shape{
val c:Int
def getArea:Double
}

class Square(x:Int) extends Shape{
override val c: Int = x

override def getArea: Double = c * c
}

class Circle(r:Int) extends Shape{
override val c: Int = r

override def getArea: Double = Math.PI * c * c
}

def main(args: Array[String]): Unit = {
val square = new Square(1)
println(square.getArea)//1
val circle = new Circle(1)
println(circle.getArea)//3.141592653589793
}

}

匿名内部类
匿名内部类是继承了类的匿名子类对象

语法：

new 类名(){
//重写类中所有的抽象内容
}
如果类的主构造器参数列表为空，小括号可以省略。

作用：对象的成员方法仅调用一次、作为方法的参数传递。

示例：

object ClassDemo {

abstract class Person{
def sayHello()
}

def show(person: Person): Unit = person.sayHello()

def main(args: Array[String]): Unit = {
val person:Person = new Person {
override def sayHello(): Unit = println("hello")
}
show(person)
}

}

案例：动物类
定义抽象动物类，属性包括：姓名，年龄，行为：跑步和吃饭

定义猫类，重写吃饭方法，并定义独有抓老鼠方法。

定义狗类，重写吃饭方法，并定义独有看家方法。

object ClassDemo {

abstract class Animal{
var name = ""
var age = 0

def run(): Unit = println("run")
def eat()
}

class Cat extends Animal{
override def eat(): Unit = println("eat fish")

def catchMouse(): Unit = println("catch mouse")
}

class Dog extends Animal{
override def eat(): Unit = println("eat meat")

def catchThief(): Unit = println("catch thief")
}

def main(args: Array[String]): Unit = {
val animal:Animal = new Cat()
if(animal.isInstanceOf[Cat]) {
val cat = animal.asInstanceOf[Cat]
cat.catchMouse()
} else if(animal.isInstanceOf[Dog]) {
val dog = animal.asInstanceOf[Dog]
dog.catchThief()
} else {
println("not cat or dog")
}
}

}