Scala-10：面向对象03-抽象类

Scala-10：面向对象03-抽象类

一、抽象属性和抽象方法

1：基本语法

1. 定义抽象类：abstract class Person{} //通过 abstract 关键字标记抽象类
2. 定义抽象属性：val|var name:String //一个属性没有初始化，就是抽象属性
3. 定义抽象方法：def hello():String //只声明而没有实现的方法，就是抽象方法

abstract class Person { 
 
    val name: String 
 
    def hello(): Unit 
} 

class Teacher extends Person { 
 
    val name: String = "teacher" 
 
    def hello(): Unit = { 
        println("hello teacher") 
    } 
} 

2：继承&重写

1. 如果父类为抽象类，那么子类需要将抽象的属性和方法实现，否则子类也需声明为抽象类
2. 重写非抽象方法需要用 override 修饰，重写抽象方法则可以不加 override。
3. 子类中调用父类的方法使用 super 关键字
4. 子类对抽象属性进行实现，父类抽象属性可以用 var 修饰； 子类对非抽象属性重写，父类非抽象属性只支持 val 类型，而不支持 var。 因为 var 修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写

二、匿名子类

就是在使用抽象方法的时候直接在使用过程中继承然后实现抽象类的方法和属性，并不实例对象，也没有子类名称。和 Java 一样，可以通过包含带有定义或重写的代码块的方式创建一个匿名的子类。

abstract class Person { 
 
    val name: String 
 
    def hello(): Unit 
} 
 
object Test { 
 
    def main(args: Array[String]): Unit = { 
 
        val person = new Person { 
 
            override val name: String = "teacher" 
 
            override def hello(): Unit = println("hello teacher") 
        } 
    } 
}

三、单例对象（伴生对象）

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

其实在我们最开始接触Scala的时候就使用了单例对象，在每次新建的object，实际上就是一个单例对象。当单例对象的名称和类名一致的时候，这个单例对象就是伴生对象，伴生对象可以类比为Java中的static。

1：语法

object Person{ 
  val country:String="China" 
} 

2：说明

1. 单例对象采用 object 关键字声明
2. 单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。
3. 单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问。

//（1）伴生对象采用 object 关键字声明 
object Person { 
    var country: String = "China" 
} 
 
//（2）伴生对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。 
class Person { 
    var name: String = "bobo" 
} 
 
object Test { 
    def main(args: Array[String]): Unit = { 
        //（3）伴生对象中的属性和方法都可以通过伴生对象名（类名）直接调用访
问。 
        println(Person.country) 
    } 
} 

3：apply 方法

在实例化的时候我们要使用new的方法进行实例化对象，如果不想通过new的话，就可以选择使用工厂模式进行实例化，就是声明一个工厂方法，然后在这个方法中进行实例化，当用户调用这个方法的时候，就会完成实例化的过程，而apply方法就是实现了这个操作

1. 通过伴生对象的 apply 方法，实现不使用 new 方法创建对象。
2. 如果想让主构造器变成私有的，可以在()之前加上 private。
3. apply 方法可以重载。
4. Scala 中 obj(arg)的语句实际是在调用该对象的 apply 方法，即 obj.apply(arg)。用以统一面向对象编程和函数式编程的风格。
5. 当使用 new 关键字构建对象时，调用的其实是类的构造方法，当直接使用类名构建对象时，调用的其实时伴生对象的 apply 方法。

object Test { 
 
    def main(args: Array[String]): Unit = { 
 
        //（1）通过伴生对象的 apply 方法，实现不使用 new 关键字创建对象。 
        val p1 = Person() 
        println("p1.name=" + p1.name) 
 
        val p2 = Person("bobo") 
        println("p2.name=" + p2.name) 
    } 
} 
 
//（2）如果想让主构造器变成私有的，可以在()之前加上 private 
class Person private(cName: String) { 
    var name: String = cName 
} 
 
object Person { 
 
    def apply(): Person = { 
        println("apply 空参被调用") 
        new Person("xx") 
    } 
 
    def apply(name: String): Person = { 
        println("apply 有参被调用") 
        new Person(name) 
} 

4：单例模式

Scala的伴生对象的设计，就使得实现单例模式变得简洁了许多，只需要将类私有化，然后在伴生对象中实现实例化方法，外界通过调用该实例化方法即可，在伴生对象中声明的属性和方法可以类比成Java中的static

饿汉式

//私有化类
class Student private(val name : String){}

//伴生对象,名字要和类名一致，在伴生对象中的属性和方法都是静态的
object Student {
    //私有化实例
	private val student : Student = new Student("tom")
    //调用该方法将实例返回
	def getInstance() : Student = student
}

以上的这种方法，不管方法有没有被调用，都提前将数值赋值完成，这种实例化的模式为饿汉式

懒汉式

//私有化类
class Student private(val name : String){}

//伴生对象,名字要和类名一致，在伴生对象中的属性和方法都是静态的
object Student {
    //私有化实例
	private val student : Student = _
    //调用该方法将实例返回
	def getInstance() : Student = {
		if (student == null){
			student = new Student("tom")
		}
	}
}