scala基础-class、object的一些体会

1、定义成员private与默认public

1.1成员定义private的时候也会默认定义private的get和set方法，因为是私有的所以不可访问。

这个时候就需要自己定义set、get方法来访问name。

1.2如果将成员定义为public，此时会默认定义public的get和set的方法，但是成员为私有的。

我们访问name其实是访问name的get、set方法。

object ProTest1 {
def main(args: Array[String]): Unit = {
val scala = new Hiscala
// 以下两种调用方式在没有参数的时候是等价的
scala.sayName()
scala.sayName

// println(scala.name) private是私有的，不可直接访问，但是可通过getName方法进行访问
println(scala.getName)
}
}

class Hiscala{
private var name = "scala"
def sayName(){ println("Hi, " + name) }
def getName = name
}

输出：

Hi, scala
Hi, scala
scala

2、get方法的覆写

object ProTest1 {
def main(args: Array[String]): Unit = {
val scala = new Person
println(scala.name)
scala.name = "Spark"
println(scala.name)
scala.update("Hadoop")
println(scala.name)
}
}

class Person{
private var myName = "Kylin"
def name = this.myName
// name_=实际为name的set方法的覆写，也就是set方法，所以可以直接调用name = newName
def name_=(newName : String){
this.myName = newName
println("Hi, " + myName)
}
// 同时可以自定义函数实现set方法
def update(newName : String){
myName = newName
println("Hi, " + myName + ". See you again!")
}
}

输出：

Kylin
Hi, Spark
Spark
Hi, Hadoop. See you again!
Hadoop

3、private[this]的使用

private[this]不允许其他对象访问，对象私有，只能这个对象访问，这个对象的类中的方法也不可以访问这个成员。其他对象中的方法也不可访问。

object ProTest1 {
def main(args: Array[String]): Unit = {
val personA = new Person()
val personB = new Person
personA.getName()
personA.getName(personB)
// 实现getName的重载
}
}

class Person{
var nameA = "AAA"
private var nameB = "BBB"
private[this] var nameC = "CCC"

def getName()={
println(nameA + "\t" +nameB + "\t" +nameC)
}
// 调用公开的nameA与私有的nameB都是可行的
def getName(p:Person){
println(nameA + "\t" +nameB)
}
// 使用nameC的时候报错value nameC is not a member of com.yanch.cn.Person
/*
def getNameC(c:Person){
println("It's " + c.nameC)
}*/
}

输出：

AAA BBB CCC
AAA BBB

4、构造器的重载

object ProTest1 {
def main(args: Array[String]): Unit = {
// 调用默认构造器
val scala = new Person
println("-" * 20)
// 调用 默认构造器
val scala2 = new Person()
println("-" * 20)
// 调用 this(newName : String)构造器
val scala3 = new Person("Spark")
println("-" * 20)
// 调用 this(newName : String, age : Int)构造器
val scala4 = new Person("Spark", 30)
}
}

class Person{
println("aaaa")
private var myName = "Kylin"
private var age = 10

def this(newName : String){
this()
myName = newName
println("This is a newname!" + myName)
}

def this(newName : String, age : Int){
this(newName)
this.age = age
println("This is a new age!" + age)
}
}

输出：

aaaa
--------------------
aaaa
--------------------
aaaa
This is a newname!Spark
--------------------
aaaa
This is a newname!Spark
This is a new age!30

5、伴生
4000
对象object

5.1 object 成员函数为静态的，可以直接调用；

5.2 object 有自带的默认构造器，而且只在调用object成员的时候第一次执行，后面不执行；

5.3 同文件中同名的class类即为其伴生类，object为class的伴生对象；伴生类与伴生对象必须在同一个文件之中；

5.4 伴生对象中有apply方法，当前类的伴生对象的工厂方法；

5.5 抽象类依旧可以通过伴生对象的工厂方法来构造实例化。

object ProTest2 {
def main(args: Array[String]): Unit = {
// 使用new构造Person2类的实例
val p1 = new Person2
println(p1.getAge)

println("-" * 20)
// 使用伴生对象构造实例
val p2 = Person2
println(p2.getAge2)

println("-" * 20)
// 使用伴生对象的apply犯法构造类Person2的实例
val p3 = Person2()
println(p3.getAge)

println("-" * 20)
// object 有自带的默认构造器，而且只在调用object成员的时候第一次执行，后面不执行
// object 成员函数为静态的，可以直接调用
println(Person2.getAge2)

}
}

class Person2{
println("It's a class !")
private var age = 10
def getAge = age
}

object Person2{
println("It's a object !")
private var age2 = 1
def getAge2 = age2
def apply()={
println("It's a apply method !")
new Person2
}
}

输出：

It's a class !
10
--------------------
It's a object !
1
--------------------
It's a apply method !
It's a class !
10
--------------------
1

6、抽象类

抽象类加final，则无法被继承（方法也是如此）

override 覆写父类的方法（统一，抽闲方法不写不影响功能），覆写父类非抽象方法就必须加override。

object ProTest2 {
def main(args: Array[String]): Unit = {
val c1 = new Cat
c1.eat
// 使用apply工厂方法
val c2 = Cat()
c2.eat
}
}

abstract class Animal{
var color : String
var action : String
def eat
}

class Cat extends Animal{
override var color = "Black"
override var action = "Creep"
override def eat{
println("Fish !")
}
}

object Cat{
def apply()={
println("It's a cat !")
new Cat
}
}

输出：

Fish !
It's a cat !
Fish !