==> 类
---> 类的定义
class Student{
// 定义属性
private var stuName:String = "Tom"
private vat stuAge:Int = 18
// 定义方法
def getStuName():String = stuName
def setStuName(newName:String) = {
this.stuName = newName
}
}---> 伴生类和伴生对象 object 相当于 Java 中的 static
---- object 对象可以跟类名不一样，如果跟类名一样，这个对象就是该类的伴生对象，反之，这个类就是这个伴生对象的伴生类
---> set 和 get 方法
---- Scala 中，会自动给 private 定义的属性生成get和set 方法，使用 val 可以使其只生成 get 方法，而不会生成set 方法
---- 在定义变量时使用 this 关键字，可以使其成为此类的私有属性，不会生成 get 和 set 方法，如：
// 定义正常的属性，可自动生成get 和 set 方法
private var aaa:String = "hello"
// 定义只可自动生成 get 方法的属性
private val aaa:String = "hello"
// 使用this 关键字，使其定义的属性成为此类的私有属性，不允许外界访问
private[this] var aaa:String = "hello"---> 嵌套类（内部类）
---- 内部类中的参数可以当做类的参数传递
---> 类的构造器
---- 主构造器 和类的声明在一起，只能有一个主构造器
class Student(val stuName: String, val stuAge: Int){
}
object Student{
def main(args: Array[String]): Unit = {
var stu = new Student("Tom", 20)
println(stu.stuName + "\t" + stu.stuAge)
}
}---- 辅助构造器 可以有多个辅助构造器，使用 this 关键字
class Student(val stuName:String, val stuAge:Int){
// 定义一个辅助构造器
def this(age:Int){
// 调用主构造器
this("No Name", age)
}
}
object Student{ //
var stu = new Student(22)
println(stu.stuName + "\t" + stu.stuAge)
} // 输出结果为 NoName 22---> Object 对象： 相当于 Java 中的 static 关键字
---- 单例模式： 一个类只有一个对象
// 生成信用卡的卡号
object CreditCard{
// 定义变量： 保存信用卡的卡号
// 该属性只属于该对象
private[this] var creditCardNumbe:Long = 0
// 产生卡号
def generateNewCCNumber():Long = {
creditCardNumbe += 1
creditCardNumber
}
// 测试程序
def main(args:Array[String]): Unit = {
// 得到新的卡号
println(CreditCard.generateNewCCNumber)
println(CreditCard.generateNewCCNumber)
println(CreditCard.generateNewCCNumber)
println(CreditCard.generateNewCCNumber)
}
}---- 应用程序对象： App ----- 可以省略 main 方法
object testApp extends App {
// 省略了 main 方法，可以直接将结果输出
println("hello")
}---> 类的 apply 方法
---- 作用： 创建对象时，省略 new 关键字，需要定义在类的伴生对象中
class Student(stuName:String){
}
object Student{
// 定义 apply 方法，必须定义在类的伴生对象中
def apply(stuName: String) = {
// 调用主构造器
new Student(stuName)
}
def main(args: Array[String]): Unit = {
var stu = Student("Tom")
}
}==> 继承
---> 简单继承
// 测试
object DemoExtends{
def main(args: Array[String]): Unit = {
// 创建一个 Person 对象
val p1:Person = new Person("Tom", 20)
println(p1.sayHello()) // My name is Tom，age is 20
// 创建一个子类
val p2:Person = new Employee("Marry", 32, 1233)
println(p2.sayHello()) // 子类中的 sayHello
// 创建一个匿名子类
val p3:Person = new Person("Jerry", 33){
override def sayHello(): String = "匿名函数中的 sayHello 方法"
}
println(p3.sayHello()) // 匿名函数中的 sayHello 方法
}
}
// 父类
class Person(val name:String, val age:Int){
def sayHello():String = "My name is " + name + "，age is " + age
}
// 子类 如果需要子类的值覆盖父类的值，需要加上 override 参数
class Employee(override val name:String, override val age:Int, val salary:Int) extends Person(name, age){
override def sayHello(): String = "子类中的 sayHello"
}---> 继承抽象类和抽象字段
object TestExtendsDemo {
def main(args: Array[String]): Unit = {
var apple:Fruit = new Apple()
var orange:Fruit = new Orange()
println(apple.name()) // 结果为 apple
println(orange.name()) // 结果为 orange
}
}
abstract class Fruit{
var id:Int
def name():String
}
class Apple extends Fruit{
// 实现抽象字段
var id:Int = 1
// 实现抽象方法
def name():String = {
"apple"
}
}
// 可以通过构造方法对抽象字段进行处理
class Orange() extends Fruit{
def name:String = {
"orange"
}
}---> 特质trait: 有点像接口，也有点像抽象类 支持多重继承，可以定义抽象方和字段，也可以定义完整的方法和字段
object Demo1 {
def main(args: Array[String]): Unit = {
var com:Computer = new Computer(1)
println(com.run())
println(com.movedown())
}
}
class Computer(var monitorid:Int) extends Monitor with Mouse with Keyboard {
def run():String = {
"running"
}
def moveup(): String = {
"moveup"
}
override def movedown(): String = {
"movedown"
}
override def press(): String = {
"press"
}
}
trait Monitor{
var monitorid:Int
def run():String
}
trait Mouse{
def moveup():String
def movedown():String
}
trait Keyboard{
def press():String
}==> 包的定义和使用
---> 包的定义：
// 定义格式一
package com.mytest
class Demo{}
// 定义格式二
package com.mytest{
class Demo{}
}---> 包的使用(引入)：
import com.mytest.Demo // 可以不写Demo 的全路径
import com.mytest._ // 引入mytest 包下所有的属性
import com.mytest.Demo._ // 引入 Demo 类中所有的属性==> 包对象
package object MyPackageDemo{
// 常量
val a:Int = 1
// 变量
var a:String = "hello"
// 方法
def Demo():String = {
"Demo"
}
// 类
class Demo{
}
// 对象 object
object Demo{
}
// trait(特质)
trait Demo{
}
}
