类的属性与私有字段
package OOP
class Person {
private var age = 0
def increment(){age += 1}
def current = age
def act(person: Person){
person.age
}
}
class Student{
private var privateAge = 0
private[this] val gender = "male"
val name = "Scala"
var age = 0
def isYounger(other: Student) = privateAge < other.privateAge
def sayHello(){
println(this.name + ":" + this.age + " : " + this.gender)
}
}
object HelloOOP {
def main(args: Array[String]): Unit = {
val person = new Person()
person.increment()
person.increment()
println(person.current)
val student = new Student
student.age = 10
println(student.age)
println(student.name)
println(student.gender)
}
}
构造器
class Teacher private (val name : String, val age : Int){
println("This is the primary constructor!!!")
var gender : String = _
println(gender)
def this(name : String, age : Int, gender : String){
this(name, age)
this.gender = gender
}
}
内部类
class Outer(val name: String) { outer =>
class Inner(val name: String){
def foo(b:Inner) = println("Outer: " + outer.name +
" Inner: " + b.name)
}
}
val outer1 = new Outer("Spark")
val outer2 = new Outer("Hadoop")
val inner1 = new outer1.Inner("Scala")
val inner2 = new outer2.Inner("Java")
inner1.foo(inner1);
inner2.foo(inner2);
伴生对象
class University{
val id = University.newStudenNo
private var number =0
def aClass(number:Int){this.number += number}
}
object University{
private var studentNo = 0
def newStudenNo = {
studentNo += 1
studentNo
}
}
object ObjecOps {
def main(args: Array[String]): Unit = {
println(University.newStudenNo)
println(University.newStudenNo)
}
}
apply
class ApplyTest{
def apply() = println("I am into Spark so much!!!")
def haveATry{
println("Have a try on apply!")
}
}
object ApplyTest{
def apply() = {
println("I am into Scala so much!!!")
new ApplyTest
}
}
object ApplyOperation {
def main(args: Array[String]) {
val array = Array(1,2,3,4,5)
val a = ApplyTest()
a.haveATry
println(a())
}
}
继承
class OverrideOperations
class Person1(val name : String, var age : Int){
println("The primary constructor of Person")
val school = "BJU"
def sleep = "8 hours"
override def toString = "I am a Person1!"
}
class Worker(name : String, age : Int, val salary : Long) extends Person1(name, age){
println("This is the subClass of Person, Primary constructor of Worker")
override val school = "Spark"
override def toString = "I am a Worker!" + super.sleep
}
object OverrideOperations{
def main(args: Array[String]) {
val w = new Worker("Spark", 5, 100000)
println("School :" + w.school)
println("Salary :" + w.salary)
println(w.toString())
}
}
抽象类
class AbstractClassOps{
var id : Int = _
}
abstract class SuperTeacher(val name : String){
var id : Int
var age : Int
def teach
}
class TeacherForMaths(name : String) extends SuperTeacher(name){
override var id = name.hashCode()
override var age = 29
override def teach{
println("Teaching!!!")
}
}
object AbstractClassOps{
def main(args: Array[String]) {
val teacher = new TeacherForMaths("Spark")
teacher.teach
println("teacher.id" + ":" + teacher.id)
println(teacher.name + ":" + teacher.age)
}
}
trait
class UseTrait {
}
trait Logger{
def log (msg : String){}
}
class ConcreteLogger extends Logger with Cloneable{
def concreteLog{
log("It's me !!!")
}
}
trait TraitLogger extends Logger{
override def log (msg : String){
println(" TraitLogger Log content is : " + msg)
}
}
trait TraitLoggered{
def loged (msg : String){
println("TraitLoggered Log content is : " + msg)
}
}
trait ConsoleLogger extends TraitLogger{
override def log(msg : String){
println("Log from Console :" +msg)
}
}
class Test extends ConsoleLogger{
def test{
log("Here is Spark!!!")
}
}
abstract class Account{
def save
}
class MyAccount extends Account with ConsoleLogger{
def save{
log("11")
}
}
class Human{
println("Human")
}
trait TTeacher extends Human {
println("TTeacher")
def teach
}
trait PianoPlayer extends Human {
println("PianoPlayer")
def playPiano = {println("I'm playing piano. ")}
}
class PianoTeacher extends Human with TTeacher with PianoPlayer {
override def teach = {println("I'm training students. ")}
}
trait Action {
def doAction
}
trait TBeforeAfter extends Action {
abstract override def doAction {
println("Initialization")
super.doAction
println("Destroyed")
}
}
class Work extends Action{
override def doAction = println("Working...")
}
object UseTrait extends App{
val t1 = new PianoTeacher
t1.playPiano
t1.teach
val t2 = new Human with TTeacher with PianoPlayer {
def teach = {println("I'm teaching students.")} }
t2.playPiano
t2 teach
val work = new Work with TBeforeAfter
work.doAction
}
