scala 包

// 声明包的方式和Java中相比会更加的灵活
// 包的声明顺序决定了包的嵌套关系
package cn
package tedu
package objectx

import cn.tedu.objectx.o.a.Cat

object ObjectDemo {

def main(args: Array[String]): Unit = {

// 通过包来调用函数
demo.test

var c = new Cat

}

def test() = println(“lalala~~~”)

}

// 为了允许在包中声明函数，提供了一类特殊的包 - 包对象
package object demo {
def test() = println(“running~~~”)
}

package o {
package a {
class Cat {

  def play() = ObjectDemo.test
  
}

}
}

---

package cn.tedu.objectx

// _表示通配
// 导入一个包下的多个类
//import java.util.{ List, Set, HashSet }
// 在导包的时候给这个类来起别名
import java.util.{ Date => UtilDate }
import java.sql.{ Date => SqlDate }

object ObjectDemo2 {

def main(args: Array[String]): Unit = {

}

}

package a1 {
// 类中可以定义属性、方法
// 属性：静态和非静态
// 方法：构造方法、静态方法和成员方法
class Driver {
// 在类中定义的属性和方法默认是public并且是非静态的
protected var name: String = _
// 表示这个属性在objectx包中可用
private[objectx] var age: Int = _

def dtest() {
  println(name)
  import cn.tedu.objectx.a2._
  var t = new Test
}

}

class YoungDriver extends Driver {

def test() {
  println(this.name)
}

}
}

package a2 {

class Test {

def test() {
  var d = new a1.Driver
  //      d.age
}

}

}

---

package cn.tedu.objectx

object ObjectDemo3 {

def main(args: Array[String]): Unit = {

import cn.tedu.objectx.o3.Pet

var p = new Pet

}

}

package o3 {

// 在一个类中可以声明属性和方法
// 属性：静态和非静态
// 方法：构造、静态和成员
// 在class中只能写非静态的属性和方法
// 在Scala中，所有的静态都必须定义到object中
// class和object在编译完成之后会编译到一个类中
// 利用这种方法来完成静态的定义
// object Pet称之为class Pet的伴生对象
// class Pet称之为object Pet的伴生类
// 将非静态方法和属性定义在伴生类中
// 将静态的方法和属性定义在伴生对象中
class Pet {

private var name: String = _

def getName = this.name
def setName(name: String) = this.name = name

}
// object中定义的都是静态方法
object Pet {
def sleep = println(“sleeping~~~”)
}

}

---

package cn.tedu.objectx

object ObjectDemo4 {

def main(args: Array[String]): Unit = {

import o4.Student

var s: Student = new Student("g01c01", "Sam")
//    println(s.id)
println(s)

}

}

package o4 {

// 定义在类名后边的构造方法称之为主构造器
class Student() {

private var id: String = _
private var name: String = _
private var age: Int = _
private var gender: String = _
private var addr: String = _

// 在一个类中，除了属性和函数之外的代码默认是放在主构造器中
if (this.name == null)
  this.name = ""
this.age = 10

// 重载 - 辅助构造器
// 在辅助构造器中需要显式的调用主构造器
def this(id: String) = {
  this()
  this.id = id
}
// 提供一个含参构造，对id和name赋值
def this(id: String, name: String) = {
  this()
  this.id = id
  this.name = name
}

}

// 如果在主构造器定义参数，那么此时主构造器中的参数默认就是Driver中的私有属性
// 在Scala中，函数的参数列中的参数默认是val定义的
class Driver(id: String, name: String, age: Int) {

//    private val id:String = _
if (age <= 18) throw new IllegalArgumentException

def getId = id

def test() = {
  var c: Cat = new Cat("瞄~")
}

}

// 表示将主构造器私有，只对外提供辅助构造器
// 养一只猫，起名，允许改名
class Cat private () {

private var name: String = _

def this(name: String) {
  this()
  this.name = name
}

def setName(name: String) = this.name = name

}

// 定义类表示矩形
class Rectangle(a: Double, b: Double) {}

}

---

package cn.tedu.objectx

object ObjectDemo5 {

def main(args: Array[String]): Unit = {

import o5._
// 类型的自动推导
var p: Pet = new Dog
// 强制转换为Dog类型
var d = p.asInstanceOf[Dog]

}

}

package o5 {

class Pet {
val age: Int = 8
def eat() = println(“吃东西中~~~”)
}

// class Dog (name:String)extends Pet {}
class Dog extends Pet {

// 父子类中不能出现同名的变量
// 父子类中可以出现同名常量，但是子类中的同名常量必须用override
override val age: Int = 5

// 在Scala中，如果一个方法是被重写的方法，那么这个方法需要显式的声明为override
override def eat() = println("这只狗在吃XXXX~~~")

}

}