scala（三）

一、面向对象编程——类

1、定义一个简单的类

class HelloWorld {
private var name = "leo"
def sayHello() { print("Hello, " + name) }
def getName = name
}

　　创建类的对象， 并调用其方法

val helloWorld = new HelloWorld
helloWorld.sayHello()
print(helloWorld.getName)

　　调用类中的方法时，也可以不加括号， 如果定义方法时不带括号， 则调用方法时也 不能带括号

2、getter与setter

假设一个类中有 声明一个字段  val  age=0，则在scala中getter 和setter分别叫做 age 和age_    （反编译得来）

（1）定义不带private的var 字段， 此时scala生成的面向JVM的类时， 会定义为private的 name字段， 并提供public的getter和setter方法

（2）而如果使用private修饰字段， 则生成的getter和setter也是private的

（3）如果定义val 字段， 则只会生成getter方法

（4）如果不希望生成setter和getter方法， 则将字段声明为private[this]

class Student {
var name = "leo"
}

　　调用getter和setter方法， 分别叫做name和name_ =

val leo = new Student
print(leo.name)
leo.name = "leo1"

　　  2.1自定义getter与setter

如果只是希望拥有简单的getter和setter方法， 那么就按照scala提供的语法规则， 根据需求为字段 选择合适的修饰符就好： var、 val、 private、 private[this]

但是如果希望能够自己对getter与setter进行控制， 则可以自定义getter与setter方法

自定义setter方法的时候一定要注意scala的语法限制， 签名、 =、 参数间不能有空格

class Student {
private var myName = "leo"
def name = "your name is " + myName
def name_=(newValue: String) {
print("you cannot edit your name!!!")
}
} 
val leo = new Student
print(leo.name)
leo.name = "leo1

　　 2.2仅 暴露字段的getter方法

如果你不希望字段有setter方法， 则可以定义为val， 但是此时就再也不能更改字段的值了    但是如果希望能够仅仅暴露出一个getter方法， 并且还能通过某些方法更改字段的值， 那么需要综合
使用private以及自定义getter方法    此时， 由于字段是private的， 所以setter和getter都是private， 对外界没有暴露； 自己可以实现修改  字段值的方法；

class Student {
private var myName = "leo"
def updateName(newName: String) {
if(newName == "leo1") myName = newName
else print("not accept this new name!!!")
}
 def name = "your name is " + myName
}

　　  2.3private[this] 的使用

如果将字段使用private来修饰， 那么代表这个字段是类私有的，   在类的方法中， 可以直接访问类的其他对象的private 字段。
              如果不希望字段被其他对象访问到， 那么可以使用private[this]， 意味着是对象私有的字段，   只能被当前对象访问， 其他新创建的对象实例无法访问。 （没有访问权限）

class Student {
private var myAge = 0
def age_=(newValue: Int) {
if (newValue > 0) myAge = newValue
else print("illegal age!")
}
def age = myAge
def older(s: Student) = {
myAge > s.myAge
}
}

　　如果myAge声明为private[this]  将报错，因为s.myAge 不能访问myAge

3、（1）辅助构造器（构造函数）

Scala中， 可以给类定义多个辅助constructor， 类似于Java中的构造函数重载          辅助constructor之间可以互相调用， 而且必须第一行调用主constructor

class Student {
private var name = ""
private var age = 0
def this(name: String) {
this()
this.name = name
} 
def this(name: String, age: Int) {
this(name)
this.age = age
}
}

　　def this(name:String)   辅助构造器 ；this（） 默认的主构造器；this.name 当前对象

调用主构造器：val p =new Student                 调用第一个辅助构造器  val p1=new Student("li")      调用第二个辅助构造器  val  p2=new Student("li",22)

(2)主构造器（构造函数）

Scala中， 主constructor是与类名放在一起的， 与Java不同 ，而且类中， 没有定义在任何方法或者代码块之中的代码， 就是主constructor的代码。

class Student(val name: String, val age: Int) {
println("your name is " + name + ", your age is " + age)
}

　　          主constructor中还可以通过使用默认参数， 来给参数默认的值

class Student(val name: String = "leo", val age: Int = 30) {
println("your name is " + name + ", your age is " + age)
}

二、对象

1、object

object， 相当于class的单个实例， 通常在里面放一些静态的字段或者方法

第一次调用object的方法时， 就会执行object的constructor， 也就是object内部不在方法中的代码； 但是object不能定义接受参数的constructor

object的constructor只会在其第一次被调用时执行一次， 以后再次调用就不会再次执行  constructor了

object Persion{
   println("zhixing")
   val age=10
   def getAge=age
}

　　Persion.getAge时只会打印一次 “zhixing”  ,再次调用方法时不打印

2、伴生对象

如果有一个class， 还有一个与class同名的object， 那么就称这个object是class的伴生  对象， class是object的伴生类
         伴生类和伴生对象必须存放在一个.scala文件之中           伴生类和伴生对象， 最大的特点就在于， 互相可以访问private 字段

package Test

/**
 * 1、伴生类与伴生对象，名字相同，必须放在同一个.scala文件中
 * 2、伴生类与伴生对象之间可以访问private成员
 */
//伴生类
class Account{
//  val array=Array()
  //伴生类中的私有字段
  private var num=10
  //通过Account.num2调用伴生对象中的私有字段num2
  def getNum2=println(Account.num2)
  //通过Account.getResult调用伴生对象中的私有函数
  num=Account.getResult

  def getInfo=println(num)
}
//伴生对象
object Account {
  //伴生对象中的私有字段
  private var num2=20
  //伴生对象中的私有函数
  private def getResult={
    num2+=10
    num2
  }
  //创建apply（）方法,用于创建伴生类的对象
  def apply()={
    println("这是伴生对象中的apply方法！")
    new Account
  }
  def main(args: Array[String]): Unit = {
    val account=Account()//调用的是伴生对象中的apply方法
    account.getInfo
//    val account=new Account  调用主构造器
    //在伴生对象中，通过伴生类的对象访问类中的私有字段
//    println(account.num)
  }

}

　　类和它的伴生对象可以相互访问私有特性，  它们必须存在于同一个源文件中。

说明： 类的伴生对象可以被访问， 但并不在  作用域当中。 举例来说， Account类  必须通过Account.newUniqueNumber()而不  是直接用newUniqueNumber()来调用伴生对  象的方法。

在伴生类中访问伴生对象成员时需  伴生对象.字段；在伴生对象访问伴生类成员时，需创建类对象

3、apply方法

object中非常重要的一个特殊方法， 就是apply方法

通常在伴生对象中实现apply方法， 并在其中实现构造伴生类的对象的功能

而创建伴生类的对象时， 通常不会使用new Class的方式， 而是使用Class()的方式， 隐式地调  用伴生对象的apply方法， 这样会让对象创建更加简洁

比如， Array类的伴生对象的apply方法就实现了接收可变数量的参数， 并创建一个Array对象   的功能    val a = Array(1, 2, 3, 4, 5)

        4、用object来实现枚举功能
            Scala没有直接提供类似于Java中的Enum这样的枚举特性。    如果要实现枚举， 则需要用object继承Enumeration类， 并且调用Value方法来初始化枚举值。
 

object Season extends Enumeration {
val SPRING, SUMMER, AUTUMN, WINTER = Value
}

　　还可以通过Value传入枚举值的id和name， 通过id和toString可以获取； 还可以通过id和name来查找枚举值

object Season extends Enumeration {
val SPRING = Value(0, "spring")
val SUMMER = Value(1, "summer")
val AUTUMN = Value(2, "autumn")
val WINTER = Value(3, "winter")
}

　  调用时，可以

Season(0)
Season.withName("spring")

Season.SUMMER

使用枚举object.values可以遍历枚举值              for (ele <- Season.values) println(ele)
     5、main方法

就如同Java中， 如果要运行一个程序， 必须编写一个包含main方法类一样；  在Scala中， 如果要运行一个应用程序， 那么必须有一个main方法作为入口
     Scala中的main方法定义为def main(args: Array[String])， 而且必须定义在object中

object HelloWorld {
def main(args: Array[String]) {
println("Hello World!!!")
}
}

　　除了自己实现main方法之外， 还可以继承App trait， 然后将需要在main方法中运行的代码， 直接作  为object的constructor代码； 而且用args可以接受传入的参数
      App类中的trait 底层有main方法

object HelloWorld extends App {
if (args.length > 0) println("hello, " + args(0))
else println("Hello World!!!")
}

　　6、让object继承抽象类

object的功能其实和class类似， 除了不能定义接受参数的constructor之外   object也可以继承抽象类， 并覆盖抽象类中的方法

abstract class Hello(var message: String) {
def sayHello(name: String): Unit
}
object HelloImpl extends Hello("hello") {
override def sayHello(name: String) = {
println(message + ", " + name)
}
def main(args: Array[String]): Unit = {

HelloImpl.sayHello("zhangsan")
}

}

　　mes:这个参数是主构造器的，它需要val或var来修饰 ；object继续Hello类时需要给参数赋值

三、继承

1、extends

Scala中， 让子类继承父类， 与Java一样， 也是使用extends关键字   ； 、

继承就代表， 子类可以从父类继承父类的字段和方法； 然后子类可以在自己内部放入父类没有， 而子类特  有的字段和方法；使用继承可以有效复用代 码

子类可以覆盖父类的字段和方法；
         如果父类用final修饰， 字段和方法用final修饰， 则该类是无法被继承的， 字段和方法是无法被覆盖的
       2、override和super
          Scala中， 如果子类要覆盖一个父类中的非抽象方法， 则必须使用override关键字
          此外， 在子类覆盖父类方法之后， 如果我们在子类中就是要调用父类的被覆盖的方法，  那就可以使用super关键字， 显式地指定要调用父类的方法
          

class Person {
private var name = "leo"
def getName = name
}
class Student extends Person {
private var score = "A"
def getScore = score
override def getName = "Hi, I'm " + super.getName
}

　　   override 字段  ：Scala中， 子类可以覆盖父类的val 字段， 只要在子类中使用override关键字即可

class Person {
val name: String = "Person"
def age: Int = 0
}
class Student extends Person {
override val name: String = "leo"
override val age: Int = 30
}

　　例：

class Persion{

  private var name="战三"
  val age=20
  def getName=name
}
class Persion1 extends Persion{
  override val age=30
  override def getName={
    "hi,"+super.getName
//    println("hi,"+super.getName)
  }
}
object day3lianxi2 {
  def main(args: Array[String]): Unit = {
    val stu =new Persion1
    println(stu.getName)
    println(stu.age)
  //  println(stu.getName)
  }
}

　　（def age:Int=0      方法名age,返回类型Int;返回值类型可以写，也可以不写，递归时必须写）

3、isInstanceOf和asInstanceOf

如果我们创建了子类的对象， 但是又将其赋予了父类类型的变量。 则在后续的程序中， 我们又需   要将父类类型的变量转换为子类类型的变量， 应该如何做？
          首先， 需要使用isInstanceOf判断对象是否是指定类的对象， 如果是， 则可以使用asInstanceOf将  对象转换为指定类型。
         注意：如果对象是null， 则isInstanceOf一定返回false， asInstanceOf一定返回null

如果没有用isInstanceOf先判断对象是否为指定类的实例， 就直接用asInstanceOf 转换， 则可能会  抛出异常
           例：class Person
                class Student extends Person
                val p: Person = new Student
                var s: Student = null
                if (p.isInstanceOf[Student])                s = p.asInstanceOf[Student]

4、getClass和classOf

isInstanceOf只能判断出对象是否是指定类以及其子类的对象， 而不能精确判断出， 对象就是指  定类的对象

如果要求精确地判断对象就是指定类的对象， 那么就只能使用getClass和classOf了

对象.getClass可以精确获取对象的类， classOf [类]可以精确获取类， 然后使用==操作符即可  判断

class Person
class Student extends Person
val p: Person = new Student
p.isInstanceOf[Person]
p.isInstanceOf[Student]
p.getClass == classOf[Person]
p.getClass == classOf[Student]

5、使用模式匹配进行类型判断

在实际开发中， 比如Spark的源码中， 大量的地方都是使用了模式匹配的方式来进行类型的判断，  这种方式更加地简洁明了， 而且代码的可维护性和可扩展性也非常高。
         使用模式匹配， 功能性上来说， 与isInstanceOf一样， 主要判断是该类以及该类的子类对象即可，  不是精准判断的

class Person
class Student extends Person
val p: Person = new Student
p match {
case per: Person => println("it's Person's object")
case _ => println("unknown type") //注意case与下划线之间有一个空格
}

6、protected   （在本类或者子类中能访问）

跟Java一样， Scala中同样可以使用protected关键字来修饰字段和方法，  这样在子类中就不需要super关键字， 就直接可以访问字段和方法

如果使用protected[this]， 则只能在当前子类对象中访问父类的字段和方法， 无法通过其他子类对象访问父类的   字段和方法

class Person {
protected var name: String = "leo"
protected[this] var hobby: String = "game"
} 
class Student extends Person {
def sayHello = println("Hello, " + name)
def makeFriends(s: Student) {
println("my hobby is " + hobby + ", your hobby is " + s.hobby)   //报错  s.hobby  不能够被其他子类对象访问
}
}

　　

     7、调  用父类的constructor 

Scala中， 每个类可以有一个主constructor和任意多个辅助constructor。  每个辅助constructor的第一行都必须是调用其他辅助constructor或者是主constructor，   因此子类的辅助constructor是
一定不能直接调用父类的constructor的。

只能在子类的主constructor中调用父类的constructor， 以下这种语法， 就是通过子类的主构造函数来调用父类的构  造函数

注意： 如果是父类中接收的参数， 比如name和age， 子类中接收时， 就不要用任何val或var来修饰了， 否则会认为   是子类要覆盖父类的字段

class Person(val name: String, val age: Int)
class Student(name: String, age: Int, var score: Double) extends Person(name, age) {
def this(name: String) {        //子类辅助构造器
this(name, 0, 0)                //子类主构造器
}
def this(age: Int) {
this("leo", age, 0)
}
}

　　8、抽象类

如果在父类中， 有某些方法无法立即实现， 而需要依赖不同的子类来覆盖， 重写实现自己不同的方法实  现。 此时可以将父类中的这些方法不给出具体的实现， 只有方法签名， 这种方法就是抽象方法。    而一个类中如果有一个抽象方法， 那么类就必须用abstract来声明为抽象类， 抽象类是不可以实例化的。
         在子类中覆盖抽象类的抽象方法时， 不需要使用override关键字

abstract class Person (val name: String) {
def sayHello: Unit
}
class Student(name: String) extends Person(name) {
def sayHello: Unit = println("Hello, " + name)
}

　　9、抽象字段

如果在抽象父类中， 定义了字段， 但是没有给出初始值， 则此字段为抽象字段

抽象字段意味着， Scala会根据自己的规则， 为var或val类型的字段生成对应的getter和setter方法

子类必须覆盖字段， 以定义自己的具体字段， 并且覆盖抽象字段， 不需要使用override关键字

abstract class Person {
val name: String
}
class Student extends Person {
val name: String = "leo"
}

四、面向对象编程——trait 特质

1、将trait作为接口使用

Scala中的trait是一种特殊的概念  ，首先可以将trait作为接口来使用， 此时的trait就与Java中的接口非常类似。  在triat中可以定义抽象方法， 就与抽象类中的抽象方法一样， 只要不给出方法的具体实现即可。
          类可以使用extends关键字继承trait，  注意， 这里不是implement， 而是extends， 在scala中没有implement的概念， 无论继承类还是trait， 统一都是extends。
         类继承trait后， 必须实现其中的抽象方法， 实现时不需要使用override关键字

scala不支持对类进行多继承， 但是支持多重继承trait， 使用with关键字即可

例：

trait Hellotrait {
def sayHello(name: String)
}
trait MakeFriendstrait {
def makeFriends(p: Person)
}
class Person(val name: String) extends Hellotrait with MakeFriendstrait with Serializable {
def sayHello(name: String) = println("Hello, " + name)
def makeFriends(p: Person) = println("Hello, my name is " + name + ", your name is " + p.name)
}

　　2、在 trait中定义具体方法

Scala中的trait不仅仅可以定义抽象方法， 还可以定义具体方法， 此时trait更像是包含了通用工具方法的东西。  比如， trait中可以包含一些很多类都通用的功能方法， 比如打印日志等等， Spark中就使用了trait来定义了通  用的日志打印方法

trait Logger {
def log(message: String) = println(message)
}
class Person(val name: String) extends Logger {
def makeFriends(p: Person) {
println("Hi, I'm " + name + ", your name is , " + p.name)
log("name=" + p.name)
}
}

　　3、在trait中定义具体字段

Scala中的trait可以定义具体字段， 此时继承trait的类就自动获得了trait中定义的字段

但是这种获取字段的方式与继承class是不同的： 如果是继承class获取的字段， 实际是定义 在父类中的； 而继承trait获取的字段， 就直接被添加到了类中

trait Person {
val eyeNum: Int = 2
}
class Student(val name: String) extends Person {
def sayHello = println("Hi, I'm " + name + ", I have " + eyeNum + " eyes.")
}

　　    例：

trait Person{
val name:String
val age=30
}

trait Worker{
val age=35
}
class Student extends Person with Worker{

val name:String="张三"

override val age =20
}

　　

特质Person和Worker中都有age字段， 当Student混入这两个特质时，需要重 写age字段，并且要用override关键字， 否则就会报错。

4、为实例混入trait

有时我们可以在创建类的对象时， 指定该对象混入某个trait， 这样， 就只有这个对象   混入该trait的方法， 而类的其他对象则没有。

trait Logged {
def log(msg: String) {}
}
 trait MyLogger extends Logged {
override def log(msg: String) { println("log: " + msg) }
}
 class Person(val name: String) extends Logged {
def sayHello {
println("Hi, I'm " + name);
log("sayHello is invoked!") }
}
val p1 = new Person("leo")
p1.sayHello
val p2 = new Person("jack") with MyLogger
p2.sayHello

　　5、trait调用链

Scala中支持让类继承多个trait后， 依次调用多个trait中的同一个方法， 只要让多个trait的同一个方法中，  在最后都执行super.方法即可。
        类中调用多个trait中都有的这个方法时， 首先会从最右边的trait的方法开始执行， 然后依次往左执行，  形成一个调用链条。

这种特性非常强大， 其实就相当于设计模式中的责任链模式的一种具体实现依赖

补充：问题总结： 调用链必须是类继续多个trait；

多个trait中必须包含同一个方法；

并且多个trait有一个公共的父trait；
                              调用的多个trait的同一个方法中，最后的语句必须是super.方法名，通过这种形式调用trait调用链中下一个trait方法。

满足以上条件才能构成trait调用链，在调用链中按照从右往左的顺序依次调用一个方法。

trait Handler {
def handle(data: String) {}
}
trait DataValidHandler extends Handler {
override def handle(data: String) {
println("check data: " + data)
super.handle(data)
}
}
trait SignatureValidHandler extends Handler {
override def handle(data: String) {
println("check signature: " + data)
super.handle(data)
}
}
class Person(val name: String) extends SignatureValidHandler with DataValidHandler {
def sayHello = {
println("Hello, " + name);
handle(name) }
}

　　

6、混合使用trait的具体方法和抽象方法

在trait中， 可以混合使用具体方法和抽象方法    可以让抽象方法放到继承trait的类中去实现    这种trait其实就是设计模式中的模板设计模式的体现

trait Valid {
def getName: String //抽象方法
def valid: Boolean = { //具体方法
getName == "leo"
}
}
class Person(val name: String) extends Valid {
def getName = name
println(valid)
}

　　7、trait的构造机制

在Scala中， trait也是有构造代码的， 也就是trait中的不包含在任何方法中的代码。

而继承了trait的类的构造机制如下：

1、 父类的构造函数执行；

2、 trait的构造代码执行， 多个trait从左到右依次执行；

3、 构造trait时会先构造父trait， 如果多个trait继承同一个父trait， 则父trait只会构造一次；

4、 所有trait构造完毕之后， 子类的构造函数执行

class Person { println("Person's constructor!") }
trait Logger { println("Logger's constructor!") }
trait MyLogger extends Logger { println("MyLogger's constructor!") }
trait TimeLogger extends Logger { println("TimeLogger's constructor!") }
class Student extends Person with MyLogger with TimeLogger {
println("Student's constructor!")
}

　　先输出

        Person's constructor!

        Logger's constructor!

         MyLogger's constructor!

         TimeLogger's constructor!

         Student's constructor!     

8、trait继承class

在Scala中， trait也可以继承自class， 此时这个class就会成为所有继承该trait的类的父类

class MyUtil {
def printMessage(msg: String) = println(msg)
} 
trait Logger extends MyUtil {
def log(msg: String) = printMessage("log: " + msg)
} 
class Person(val name: String) extends Logger {
def sayHello {
log("Hi, I'm " + name)
printMessage("Hi, I'm " + name)
}
}

　　

      

补充：
      1、序列化相当于 保存的过程   反序列化就相当于读取的过程   （序列化原因 ：网络传输不安全，影响传输速度）

      2、

package com.ghgj;

public class A {

	public static void main(String[] args) {
		Person p =new Student();
		Student s=new Student();
	}
}
class Person{
	public Person(){
		System.out.println("a");
	}
}
class Student extends Person{
	public Student(){
		System.out.println("b");
	}
}

　　返回值都是 a  b   a  b