scala学习之路：7.OOP

class Person() {
  private var age = 0
  def increment(){
    age +=1
  }
  def current = age 
  
}
class Student{
//  var age = 0 // 默认权限修饰允许访问，同时生成get和set方法
  
  private [this] var privateAge = 0// [this] 只能是当前对象使用，不能对当前对象方法使用，即对象私有属性
  def age = privateAge;
  val name = "Scala"  // 不可变的 只能get 不能set
  
//  def isYounger(other : Student) = privateAge < other.privateAge
  
}

object dt01OOP {
  
  def main(args: Array[String]): Unit = {
    
    var person = new  Person()
    person.increment()
    
    person.increment()
    println(person.current)
    
    val student = new Student 
//    不允许使用Set方法但是可以使用get方法获取到私有属性
//    student.age = 10  
//    student.name = "Hadoop"  // 会报出重复赋值
    println(student.name)      // get方法正常使用
    println(student.age) 
    
    
  }
}

打印结果是： 

2

Scala

0

上面是对象的使用，下面来看看构造器

方式一：

class Teacher() { // 此处添加() 就是主构造器
  var name : String = _
  private var age = 27 // 生成的get 和set 都是私有的
  private [this] val gender = "male" 
  
  def  this (name : String)  {
    this()  // 重载构造器 必须调用其他的附属构造器  其他的附属构造器一定最终会调用主构造器
    this.name = name
  }
  
  def  sayHello(): Unit = {
    println(this.name +":" + this.age + ":" + this.gender)
  }
} 
object dt02oopInScala {

  def main(args: Array[String]): Unit = {
        var teacher = new Teacher
        teacher.name = "Spark"
//        teacher.gender = "wqe"
        teacher.sayHello // 打印结果是： Spark:27:male
 
  
 
  
   }
 
  
 }
 
  
 
  
 
  
 
  
 
 
  
方式二：
 
  
 
  
class Teacher private (val name: String, val age: Int) { // 主构造器使用 private修饰就不会被别人使用
  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
  }
  def sayHello(): Unit = {
    println(this.name + ":" + this.age + ":" + this.gender)
  }

}

object dt02oopInScala {

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

    //     由于 主构造器被 private修饰这里不能使用这种构造方
//        var p = new Teacher("spark" ,5) 
        var p = new Teacher("spark", 5, "male")
}
}
 
  
 
  
 
  

 
  
打印结果是： 说明主构造器中的代码会执行，但是方法不会执行
 
  
 
  
 This is the primary constructor
 
  
 null
 内部类： 
  
 
 
  
class Outer(val name: String) { outer =>
  class Inner(val name: String) {
    def foo(b: Inner) = println("Outer: " + outer.name + " Inner : " + b.name)
  }

}
object dt02oopInScala {

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

    val outer1 = new Outer("Spark")
    val outer2 = new Outer("Hadoop")
    val inner1 = new outer1.Inner("Scala")
    val inner2 = new outer2.Inner("Java")

    //    inner1.foo(inner2)   会直接报出错误 不匹配 而java中则是可以的  隶属于实例本身
    inner1.foo(inner1)

    inner2.foo(inner2)

  }
}
 
  
 
  
 打印结果是：
 
  
 Outer: Spark Inner : Scala
 
  
 Outer: Hadoop Inner : Java