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)
}
} <pre name="code" class="objc">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")<pre name="code" class="objc">}
}
<span style="font-family: Monaco; font-size: 11px; background-color: rgb(255, 255, 255);">打印结果是: 说明主构造器中的代码会执行,但是方法不会执行</span>
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