Scala 学习之面向对象（3）

class Student{
    // 定义属性
    private var stuName:String = "Tom"
    private vat stuAge:Int = 18
    
    // 定义方法
    def getStuName():String = stuName
    def setStuName(newName:String) = {
        this.stuName = newName
    }
    
    
}

 // 定义正常的属性，可自动生成get 和 set  方法
 private var aaa:String = "hello"
 
 // 定义只可自动生成 get 方法的属性
 private val aaa:String = "hello"
 
 // 使用this 关键字，使其定义的属性成为此类的私有属性，不允许外界访问
 private[this] var aaa:String = "hello"

class Student(val stuName: String, val stuAge: Int){

}

object Student{
    def main(args: Array[String]): Unit = {
        var stu = new Student("Tom", 20)
        println(stu.stuName + "\t" + stu.stuAge)
    }
}

class Student(val stuName:String, val stuAge:Int){
    // 定义一个辅助构造器
    def this(age:Int){
    // 调用主构造器
    this("No Name", age)
    }
}

object Student{  // 
    var stu = new Student(22)
    println(stu.stuName + "\t" + stu.stuAge)
}    // 输出结果为 NoName   22

// 生成信用卡的卡号
object CreditCard{
    // 定义变量： 保存信用卡的卡号
    // 该属性只属于该对象 
    private[this] var creditCardNumbe:Long = 0
    
    // 产生卡号
    def generateNewCCNumber():Long = {
        creditCardNumbe += 1
        creditCardNumber
    }
    
    // 测试程序
    def main(args:Array[String]): Unit = {
    // 得到新的卡号
        println(CreditCard.generateNewCCNumber)
        println(CreditCard.generateNewCCNumber)
        println(CreditCard.generateNewCCNumber)
        println(CreditCard.generateNewCCNumber)
    }
}

object testApp extends App {
    // 省略了 main 方法，可以直接将结果输出
    println("hello")
}

class Student(stuName:String){

}

object Student{
    // 定义 apply 方法，必须定义在类的伴生对象中
    def apply(stuName: String) = {
        // 调用主构造器
        new Student(stuName)
    }
    def main(args: Array[String]): Unit = {
        var stu = Student("Tom")
    }
}

// 测试
object DemoExtends{
  def main(args: Array[String]): Unit = {
    // 创建一个 Person 对象
    val p1:Person = new Person("Tom", 20)
    println(p1.sayHello())            // My name is Tom，age is 20

    // 创建一个子类
    val p2:Person = new Employee("Marry", 32, 1233)
    println(p2.sayHello())            // 子类中的 sayHello

    // 创建一个匿名子类
    val p3:Person = new Person("Jerry", 33){
      override def sayHello(): String = "匿名函数中的 sayHello 方法"
    }
    println(p3.sayHello())            // 匿名函数中的 sayHello 方法
  }
}
// 父类
class Person(val name:String, val age:Int){
  def sayHello():String = "My name is " + name + "，age is " + age
}

// 子类    如果需要子类的值覆盖父类的值，需要加上 override 参数
class Employee(override val name:String, override val age:Int, val salary:Int) extends Person(name, age){
  override def sayHello(): String = "子类中的 sayHello"
}

object TestExtendsDemo {
  def main(args: Array[String]): Unit = {
    var apple:Fruit = new Apple()
    var orange:Fruit = new Orange()

    println(apple.name())        // 结果为 apple
    println(orange.name())        // 结果为 orange

  }
}

abstract class Fruit{
  var id:Int
  def name():String
  
}

class Apple extends Fruit{
   // 实现抽象字段
   var id:Int = 1
  // 实现抽象方法
  def name():String = {
    "apple"
  }

}

// 可以通过构造方法对抽象字段进行处理
class Orange() extends Fruit{
  def name:String = {
    "orange"
  }

}

object Demo1 {

  def main(args: Array[String]): Unit = {
    var com:Computer = new Computer(1)
    println(com.run())
    println(com.movedown())
  }

}

class Computer(var monitorid:Int) extends Monitor with Mouse with Keyboard {
  def run():String = {
    "running"
  }

  def moveup(): String = {
    "moveup"
  }

  override def movedown(): String = {
    "movedown"
  }

  override def press(): String = {
    "press"
  }

}

trait Monitor{
  var monitorid:Int
  def run():String

}

trait Mouse{
  def moveup():String
  def movedown():String
}

trait Keyboard{
  def press():String
}

// 定义格式一
package com.mytest
class Demo{}

// 定义格式二
package com.mytest{
    class Demo{}
}

import com.mytest.Demo        // 可以不写Demo 的全路径
import com.mytest._            // 引入mytest 包下所有的属性
import com.mytest.Demo._        // 引入 Demo 类中所有的属性

package object MyPackageDemo{
    // 常量
    val a:Int = 1
    // 变量
    var a:String = "hello"
    // 方法
    def Demo():String = {
        "Demo"
    }
    // 类
    class Demo{
        
    }
    // 对象 object
    object Demo{
    
    }
    // trait(特质)
    trait Demo{
    
    }
}