好程序员大数据教程Scala 系列之 类

1.  类的定义

Scala 访问修饰符基本和Java的一样，分别有：private，protected，public。

如果没有指定访问修饰符符，默认情况下，Scala 对象的访问级别都是 public。

私有(Private)成员

用 private 关键字修饰，带有此标记的成员仅在包含了成员定义的类或对象内部可见，同样的规则还适用内部类。

class Outer{
     class Inner{
     private  def f(){println("f")}
     class InnerMost{
        f()  //  正确
        }
    }
    ( new Inner).f()  // 错误
}

 (new Inner).f( ) 访问不合法是因为  f  在 Inner 中被声明为 private，而访问不在类 Inner 之内。

但在 InnerMost 里访问  f  就没有问题的，因为这个访问包含在 Inner 类之内。

Java中允许这两种访问，因为它允许外部类访问内部类的私有成员。

保护(Protected)成员

  在 scala 中，对保护（Protected）成员的访问比 java 更严格一些。因为它只允许保护成员在定义了该成员的的类的子类中被访问。而在java中，用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可以进行访问。

package p{
class Super{
     protected  def f() {println("f")}
    }
     class Sub  extends Super{
        f()
    }
     class Other{
        ( new Super).f()  // 错误
    }
}

类的定义示例：

// 定义 Point 类，构造器带有两个参数
class Point( var x: Int,  var y: Int) {

     // 无返回值的类方法
   def move(dx: Int, dy: Int): Unit = {
    x = x + dx
    y = y + dy
  }

     // 没有参数但是返回值为 String 类型的重写方法
   override  def toString: String =
    s"($x, $y)"
}

// 创建类的实例
val point1 =  new Point(2, 3)
point1.x   // 2
println(point1)   // prints (2, 3)

构造器可以带有默认值：

class Point( var x: Int = 0,  var y: Int = 0){
...
}
val origin =  new Point   // x, y 都取默认值 0
val point1 =  new Point(1) //x=1,y=0
println(point1.x)   // prints 1

私有成员变量以及重新定义的Getter/Setter方法：

  private  var _x = 0
   private  var _y = 0
   private  val bound = 100

   def x = _x
   def x_= (newValue: Int): Unit = {
     if (newValue < bound) _x = newValue  else printWarning
  }

   def y = _y
   def y_= (newValue: Int): Unit = {
     if (newValue < bound) _y = newValue  else printWarning
  }

   private  def printWarning = println("WARNING: Out of bounds")
}

val point1 =  new Point
point1.x = 99
point1.y = 101  // prints the warning

类定义中的其他细节：

// 在 Scala 中，类并不用声明为 public 。
//Scala 源文件中可以包含多个类，所有这些类都具有公有可见性。
class Person {
   // 用 val 修饰的变量是只读属性的，只带 getter 方法但没有 setter 方法
   // （相当与 Java 中用 final 修饰的变量）
   // 字段必须初始化
   val id = "1234"

   // 用 var 修饰的变量，默认同时有公开的 getter 方法和 setter 方法
   var age: Int = 18

   // 类私有字段 , 有私有的 getter 方法和 setter 方法，只能在类的内部使用
   private  var name: String = " 王老五 "

   // 对象私有字段 , 访问权限更加严格的， Person 类的方法只能访问到当前对象的字段
   private[ this]  val hobby = " 旅游 "
}

scala中，在实现属性时你有如下四个选择：

var foo: Scala自动合成一个getter和一个setter

val foo: Scala自动合成一个getter

由你来定义foo和foo_=方法

由你来定义foo方法

2.  构造器

注意：

1.主构造器会执行类定义中的所有语句

2.主构造器如果有参数直接放置在类名之后

 class ConstructorDemo ( val id: Int ) { … }

3.主构造器变成私有的，可以像这样放置private关键字：

 class ConstructorDemo private ( val id: Int ) { … }

  此时，用户必须通过辅助构造器来构造Person对象

class ConstructorDemo {

   private  var var1 = ""

   private  var var2 = 0

   // 辅助构造器 1
   def  this(var1:String) {
     this()   // 调用主构造器
     this.var1 = var1
  }

   // 辅助构造器 2
   def  this(var1:String, var2:Int) {
     this(var1)  // 调用辅助构造器 1
     this.var2 = var2
  }

}