Scala 类和对象与Java的对比

一、包

 1 package com{
 2
 3   import com.atguigu.scala.Inner
 4
 5   // 在外层包中定义单例对象
 6   object Outer{
 7     var out: String = "out"
 8
 9     def main(args: Array[String]): Unit = {
10       println(Inner.in)
11     }
12   }
13   package atguigu{
14     package scala{
15       // 内层包中定义单例对象
16       object Inner{
17         var in: String = "in"
18         def main(args: Array[String]): Unit = {
19           println(Outer.out)
20           Outer.out = "outer"
21           println(Outer.out)
22         }
23       }
24     }
25   }
26 }
27
28 // 在同一文件中定义不同的包
29 package aaa{
30   package bbb{
31
32     object Test01_Package{
33       def main(args: Array[String]): Unit = {
34         import com.atguigu.scala.Inner
35         println(Inner.in)
36       }
37     }
38   }
39 }

二、包对象

在 Scala 中可以为每个包定义一个同名的包对象，定义在包对象中的成员，作为其对应包下所有 class 和 object 的共享变量，可以被直接访问。

 1 //package chapter06
 2 //
 3 //object Test02_PackageObject {
 4 //  def main(args: Array[String]): Unit = {
 5 //    commonMethod()
 6 //    println(commonValue)
 7 //  }
 8 //}
 9
10 package chapter06{
11   object Test02_PackageObject {
12     def main(args: Array[String]): Unit = {
13       commonMethod()
14       println(commonValue)
15     }
16   }
17 }
18
19 package ccc{
20   package ddd{
21     object Test02_PackageObject{
22       def main(args: Array[String]): Unit = {
23         println(school)
24       }
25     }
26   }
27 }
28
29 // 定义一个包对象
30 package object ccc{
31   val school: String = "atguigu"
32 }

三、导包

四、类和对象

1、scala没有public关键字，默认public。

2、Bean 属性（@BeanPropetry），可以自动生成规范的 setXxx/getXxx 方法。

 1 package chapter06
 2
 3 import scala.beans.BeanProperty
 4
 5 object Test03_Class {
 6   def main(args: Array[String]): Unit = {
 7     // 创建一个对象
 8     val student = new Student()
 9 //    student.name   // error, 不能访问private属性
10     println(student.getAge)
11     println(student.sex)
12     student.sex = "female"
13     println(student.sex)
14   }
15 }
16
17 // 定义一个类
18 class Student {
19   // 定义属性
20   private var name: String = "alice"
21   @BeanProperty
22   var age: Int = _
23   var sex: String = _
24 }

3、访问权限

4、动态绑定

Scala 中属性和方法都是动态绑定，而 Java 中只有方法为动态绑定。

 1 package chapter06
 2
 3 object Test08_DynamicBind {
 4   def main(args: Array[String]): Unit = {
 5     val student: Person8 = new Student8
 6     println(student.name)
 7     student.hello()
 8   }
 9 }
10
11 class Person8 {
12   val name: String = "person"
13   def hello(): Unit = {
14     println("hello person")
15   }
16 }
17
18 class Student8 extends Person8 {
19   override val name: String = "student"
20   override def hello(): Unit = {
21     println("hello student")
22   }
23 }

val student: Person8 = new Student8
使用父类实例化子类对象实例，同时把子类的属性也动态绑定到了父类。