文章目录
- 1. 定义类
- 2. 属性
- 3. 访问权限
- 4. 方法
- 4.1 方法 vs 函数
- 4.2 方法重写
- 4.3 方法重载
- 4.4 构造方法
- (1) 构造器定义
- (2) 构造器的参数列表
- (3) 构造器私有化
- 5. 继承
- 6. 伴生对象 & 伴生类
- 6.1 伴生对象的由来
- 6.2 伴生对象 & 伴生类
- 7. 后续
1. 定义类
- Java文件：一个文件中可以有多个类，但是必须存在一个类用
public修饰，且用public修饰的类的类名 必须与文件名一样。 - Scala文件：一个文件中可以包含多个类，且所有的类都不需要用
public修饰。（因为所有的类默认加上了public关键字，如果再写上public就重复了，反而就会报错）注意：类和属性的修饰符，都是默认加上了
public关键字，如果再写上就重复了，反而就会报错。
2. 属性
-
Java封装操作如下：
- 将属性进行私有化
- 提供一个公共的set方法，用于对属性赋值
- 提供一个公共的get方法，用于获取属性的值
-
在scala中所有的属性，不管是用
public还是private修饰，在底层都是private，并通过get方法（obj.field()）和set方法（obj.field_=(value)）访问该属性。因此，那个修饰符只用于定义 访问权限 的，没有起到封装的效果(Java是借助修饰符达到封装的效果)。 -
属性的定义：
class Student{ // 1. 类的属性一般用 var 修饰，因为一般要修改属性值 // 2. 如果赋null值，用 _ 代替 null var name: String = _ // 3. 由于一些场景下Java框架要利用反射调用getXXX和setXXX方法，有时候为了和这些框架兼容，需要显示生成getXXX和setXXX方法 // 如果需要显示的生成getter、setter方法，用 @BeanProperty 注解即可 @BeanProperty var age: Int = _ } object Student{ def main(args: Array[String]): Unit = { val st = new Student() st.age = 50 } }
3. 访问权限
private私有权限，只在类的内部和伴生对象中可用。protected为受保护权限，同类、子类可以访问，同包无法访问。private[包名]为包访问权限，指定包名下的类可以访问。- 默认(什么都不写)，就是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的构造方法分为两类：
- 主构造器：必须有
- 辅助构造器：必须调用主构造器
- 主构造器必须有，如果主构造器没有参数，则括号可以省略。如：
class Person { ...... }- 主构造器的方法体在哪里？？？
- 辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法
- 构造器调用其他另外的构造器，要求被调用构造器必须提前声明。也就是说，存在代码的先后顺序。
(2) 构造器的参数列表
- 未用var或val修饰，这个参数就是一个局部变量，底层有属性的特性
- var修饰参数，作为类的成员属性，可以修改
- val修饰参数，作为类的成员属性，不能修改
package chapter06
object 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 伴生对象 & 伴生类
-
伴生对象用object关键字修饰，伴生类用class关键字修饰。
-
他俩的名字必须相同，
-
且必须放在同一个scala文件中。
class Student{ .... } object Student{ .... }
因为伴生对象相当于是存放
static的地方，所以所有类的对象共享伴生对象中的数据。
伴生对象与伴生类可以相互访问对方中的数据
7. 后续
差不多了，告一段落！！！！
https://www.bilibili.com/video/BV1Xh411S7bP?p=77
