【Scala---03】Scala 类与对象 『 类 | 属性 | 访问权限 | 方法 | 继承 | 伴生对象&伴生类 | 查看类/对象的所有方法』

1. 定义类

// Java 代码
public class Test {
	public static void main(String[] args){
		......
	}
}

// Scala代码
object Test {
	def main(args:Array[String]):Unit = {   
		......
	}
}

• Java文件：一个.java中可以有多个类，但是必须存在一个类用public修饰，且用public修饰的类的类名 必须 与 文件名 一样。

• Scala文件：一个.scala中可以包含多个类，且所有的类都不需要用public修饰，不要求类名 与 文件名一致。

  因为所有的类默认加上了public关键字，如果再写上public就重复了，反而就会报错

• .scala文件，也需要编译成.class文件才能运行。参考链接
  

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值，用 _ 代替 null
      var name: String =  _
      // 3. 由于一些场景下Java框架要利用反射调用getXXX和setXXX方法，有时候为了和这些框架兼容，需要显示生成getXXX和setXXX方法
      //    如果需要显示的生成getter、setter方法，用 @BeanProperty 注解即可
      @BeanProperty
      var age: Int = _
  }
  
  class 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 定义方法

语法和Java类型:

class 类名 {
	def 方法名([变量：变量类型，变量：变量类型]):返回值类型={
		方法体
	}
}

比如：

注意：如果方法是递归方法，则必须指名方法的返回值类型，不能不写。

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 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
    }
}

4.5 可变参数

在参数后面加上*，这个参数就变成了可变参数

object Main {
    def main(args: Array[String]): Unit = {
        def sum(x:Int*):Int = {  // 在参数x后加上 * ，则x变成了可变参数
            var value = 0
            for(i <- x)
                value += i
            value
        }
        println(sum(1, 2, 3))  // 输出：6
    }
}

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. 查看类/对象的所有方法