1. 定义类

• Java文件：一个文件中可以有多个类，但是必须存在一个类用public修饰，且用public修饰的类的类名 必须与文件名一样。
• Scala文件：一个文件中可以包含多个类，且所有的类都不需要用public修饰。（因为所有的类默认加上了public关键字，如果再写上public就重复了，反而就会报错）

  注意：类和属性的修饰符，都是默认加上了public关键字，如果再写上就重复了，反而就会报错。

2. 属性

• Java封装操作如下：

  1. 将属性进行私有化
  2. 提供一个公共的set方法，用于对属性赋值
  3. 提供一个公共的get方法，用于获取属性的值

• 在scala中所有的属性，不管是用public还是private修饰，在底层都是private，并通过get方法（obj.field()）和set方法（obj.field_=(value)）访问该属性。因此，那个修饰符只用于定义 访问权限 的，没有起到封装的效果(Java是借助修饰符达到封装的效果)。

• 属性的定义：

  class Student{// 1. 类的属性一般用 var 修饰，因为一般要修改属性值// 2. 如果赋null值，用 _ 代替 nullvar name: String =  _// 3. 由于一些场景下Java框架要利用反射调用getXXX和setXXX方法，有时候为了和这些框架兼容，需要显示生成getXXX和setXXX方法//    如果需要显示的生成getter、setter方法，用 @BeanProperty 注解即可@BeanPropertyvar age: Int = _
  }object Student{def main(args: Array[String]): Unit = {val st =  new Student()st.age = 50}
  }
  

3. 访问权限

1. private私有权限，只在类的内部和伴生对象中可用。
2. protected为受保护权限，同类、子类可以访问，同包无法访问。
3. private[包名]为包访问权限，指定包名下的类可以访问。
4. 默认(什么都不写)，就是public，任何类都可以访问

4. 方法

4.1 方法 vs 函数

• 从广义上理解，函数 是更加广的一个概念，方法 是特殊的 函数。即：函数作为类的属性而存在时，此时函数叫做方法。
  从狭义上理解，方法 之外，才是 函数。
• 从位置上理解：方法 定义在类中，做为类的属性；函数 定义在方法中。 (狭义的函数)
• 从是否可以重载的角度：方法定义在类中可以实现重载；函数不可以重载。 (狭义的函数)
• 从运行位置角度：方法是保存在方法区；函数是保存在堆中。 (狭义的函数)

4.2 方法重写

• 在def关键字前加上override关键字：

  class Person {def run(): Unit = {println("person run")}}class Student extends Person {// 在 def 关键字前加上 override 关键字override def run():Unit = {println("student run")}
  }
  

4.3 方法重载

• 不用加关键字，直接写

  class Person {def run(): Unit = {println("person run")}def run(name: String): Unit  = {println(s"${name} run")}
  }
  

4.4 构造方法

(1) 构造器定义

Scala的构造方法分为两类：

1. 主构造器：必须有
2. 辅助构造器：必须调用主构造器
   

1. 主构造器必须有，如果主构造器没有参数，则括号可以省略。如：

   class Person {......
   }
   

2. 主构造器的方法体在哪里？？？
   
3. 辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法
   
4. 构造器调用其他另外的构造器，要求被调用构造器必须提前声明。也就是说，存在代码的先后顺序。

(2) 构造器的参数列表

1. 未用var或val修饰，这个参数就是一个局部变量，底层有属性的特性
2. var修饰参数，作为类的成员属性，可以修改
3. val修饰参数，作为类的成员属性，不能修改

package chapter06object Test07_ConstructorArgs {def main(args: Array[String]): Unit = {val person0 = new Person("zhangsan",11,"男")println(person0.name)println(person0.age)println(person0.sex)}
}// 主构造器参数 分为3类:
// 没有修饰符 : 作为构造方法中的传入参数使用
// val 修饰 : 会自动生产同名的属性 并且定义为val
// var 修饰 : 会自动生产同名的属性 并且定义为var
class Person (name1:String,val age:Int,var sex:String){val name = name1//  val age = age//  var sex = sex
}

(3) 构造器私有化

实现单例模式时，需要将构造器私有化。那么如何将构造器私有化，直接在主构造器前上加上private关键字：

class Student private (var name: String, var sage: Int){}object Student {private var instance:Student = _def getInstance(name:String, age:Int): Student = {if (instance == null) {instance = new Student("zhang",  18)return instance}instance}
}

5. 继承

Scala和Java一样都是单继承机制：

6. 伴生对象 & 伴生类

6.1 伴生对象的由来

在Java的类中，用 static 关键字修饰的内部类、方法、属性，可以通过类名访问。比如：

class Student{public static String school;
}
class Main {public static void main(String[] args) {System.out.printf(Student.school);  // 通过类名直接访问。}
}

这里的Student.school是通过类名来访问，并不是通过对象访问，Java号称面向对象，这里就相当与面向对象的理念冲突了。

所以，在Scala中，没有 static 关键字。为了实现与 static 关键字相同的功能，于是引入了伴生对象。

• 问：删除static关键字容易，如何实现static关键字的功能呢？

• 思路：static 修饰的就是当前类所共享的，而Student.school，中的Student应该是一个对象，而不是类。自然的想到为每个类创建第一个同名字的对象，然后将 static 修饰的东西都放入该对象中即可。

• 例子：

  class Student(var name:String, var age:Int) {// 定义与类相关的一些信息def printerInfo():Unit = {println(s"姓名：${name}, 年龄；${age}")}
  }object Student{// 所有Student在同一所学校var school:String = "XXX高中"  // main方法本来应该用static修饰，所以应该写在这里def main(args: Array[String]): Unit = {var stu = new Student("张三", 18)stu.printerInfo()}
  }
  

6.2 伴生对象 & 伴生类

1. 伴生对象用object关键字修饰，伴生类用class关键字修饰。

2. 他俩的名字必须相同，

3. 且必须放在同一个scala文件中。

   class Student{....
   }
   object Student{....
   }
   

因为伴生对象相当于是存放static的地方，所以所有类的对象共享伴生对象中的数据。
伴生对象与伴生类可以相互访问对方中的数据

7. 后续

差不多了，告一段落！！！！
https://www.bilibili.com/video/BV1Xh411S7bP?p=77