1、总览Demo

object objectDemo {

  def main(args: Array[String]): Unit = {
    val user:User  = new User()
    println(user.username) // null (AnyRef _代表 null)
    user.username = "wangwu"
    println(user.username) // wangwu
    println(user.age) // 0 (AnyVal _ 代表0)
  }

}

class User(){
  // 在scala中所有的变量定义时都要初始化
  var username:String = _  // AnyRef  可以是null或_ 来填充初始化的值
  var age:Int = _ // AnyVal  可以给0或_ 来填充初始化的值
  def login(): Unit ={
    println("user登录")
  }
}

2、package

(待补充)

3、import

(待补充)

4、Field

object Field_Demo {
  def main(args: Array[String]): Unit = {
    val student:Student = new Student()
    student.username ="wangwu"
    println(student.username) // wangwu

    /*student.age = 5 //报错
    println(student.age) //报错*/

    //student.email = "xxxxxx.@163.com" //报错
    println(student.email) // ''
  }
}

class Student() {
  //总括：scala 类中的变量默认私有，提供getter和setter方法

  // var修饰：底层自动添加，getter和setter的自动添加
  var username: String = _
  //private 修饰：底层自动添加的getter和setter方法，都是私有的，不能取值或修改
  private var age: Int = _
  // val 修饰：底层私有，且被final修饰，只提供getter方法，不提供setter方法
  val email : String = ""
}

• 总括：scala 类中的变量默认私有，提供getter和setter方法
  1）var修饰：底层自动添加，getter和setter的自动添加
  2）private 修饰：底层自动添加的getter和setter方法，都是私有的，不能取值或修改
  3）val 修饰：底层私有，且被final修饰，只提供getter方法，不提供setter方法

5、权限修饰符

package p1{
  package p2{
    class Users(){
      // 默认修饰符是public ,但是没有public关键字，任意地方都可访问
      var username : String = "zhangsan"
      // private修饰符：只有本类可以访问
      private var password : String = "mima"
      //protected修饰符:本类及其子类可以访问
      protected var email : String = "xxx@163.com"
      // private[x]修饰符: 只有x包内才能访问 (x代表包名)
      //private[p3] var addr : String = "zzzz"
    }
  }

  package p3{

    import com.bfd.chap06.p1.p2.Users

    object test {
      def main(args: Array[String]): Unit = {
        val users : Users = new Users()
        println(users.username)
        //println(users.password) //报错
        //println(users.email) // 报错，若想访问，需要extends Users
        // println(users.addr) // private[p3] ,包名是p3可以访问
      }
    }
  }

1)默认修饰符是public ,但是没有public关键字，任意地方都可
2)private修饰符：只有本类可以访问
3)protected修饰符:本类及其子类可以访问
4)private[x]修饰符: 只有x包内才能访问 (x代表包名)

6、方法

在scala中，方法等同于函数，只是方法必须定义在类中，且调用方式不同

object MethodDemo4 {
  def main(args: Array[String]): Unit = {
    val testObj:TestDemo = new TestDemo()
    testObj.a()

  }
}

class TestDemo {
  def a(): Unit ={
    println("方法调用成功") //方法调用成功
  }
}

7、伴生类与伴生对象

object ClassAndObject5{
  def main(args: Array[String]): Unit = {
    val teacherName = Teacher.apply.name
    println(teacherName)
  }
}

// 伴生对象 (相当于静态static)
object Teacher {
  // 利用伴生对象创建伴生类
  def apply: Teacher = new Teacher()

  def test(): Unit ={
    //ClassAndObject5.name // 报错：因为静态方法，不能直接访问成员变量
    val claob:Teacher = new Teacher()
    claob.name
    claob.sex //伴生对象可以访问伴生类中的私有变量
  }
}

// 伴生类 (相当于成员的)
class Teacher {
  val name : String = "zhangsan"
  private val sex : String = "man"
}

1)伴生类和伴生同名时，是一对的
2)伴生对象可以访问伴生类中的私有变量
3)伴生对象不能用类名.变量名的方式访问变量，因为静态方法，不能直接访问成员变量（静态修饰的方法，在对象创建之前就已经创建了）
4)apply:def apply: Teacher = new Teacher(),实例化伴生类

//scala完全面向函数，类也是一个函数
// (1.def换成class  2.省略返回值类型 3.无入参去掉小括号 4.去掉=,类体（方法体）本身就没有返回值)
class Company{

}
/*def compa {
  "abc"
}*/

8、构造方法

scala的构造方法：主构造方法、辅助构造方法

object ConstruMethod6 {
  def main(args: Array[String]): Unit = {
    val company = new Company1()
  /* 结果：
         这是主构造函数
         这是辅助构造函数1
         这是辅助构造函数2 */
    val company = new Company1("xx","xx","xx")
  /*结果：
        这是主构造函数
        zzz
*/
  }
}

//Company1(name:String):这是主构造器
class Company1(s:String){

  //这是类体，同样是构造方法体
  println("这是主构造函数")
  println(s)

  def this(s:String,ss:String){
    this(s)
    println("这是辅助构造函数2")
  }

  def this(){
    this("这是辅助构造函数1","xxx")
  }
def this(s1:String,s2:String,s3:String){
    this("zzz")
  }
}

解释：
1）默认情况下scala提供无参构造
2）可以构建一个或多个辅助构造函数，但是最后必须要调用主构造函数
3）类的类体，同时也是主构造函数方法体
4）上面代码相当于是有两套构造方法

延伸

object ConstruMethod6 {
  def main(args: Array[String]): Unit = {
    val company = new Company1()
  }
}


//Company1(name:String):这是主构造器
class Company1(s:String){

  //这是类体，同样是构造方法体
  println("这是主构造函数")
  println(s)

  def this(s:String,ss:String){
    this(s)
    println("这是辅助构造函数2")
  }
  println("新建1")
  def this(){
    this("这是辅助构造函数1","xxx")
  }
  println("新建2")
  def this(s1:String,s2:String,s3:String){
    this("zzz")
  }
  println("新建3")
}
/* 结果：
这是主构造函数
这是辅助构造函数1
新建1
新建2
新建3
这是辅助构造函数2*/