scala 类对象学习记录

接首篇

https://www.cnblogs.com/xstCoding/p/15531299.html

整理一下scala的类对象

scala的类，属性

 

定义使用方式和Java中没什么区别，主要要注意一下属性val 和var的赋值问题

class Persion2 {
var name: String = "bobo" //定义属性
var age: Int = _ //_表示给属性一个默认值

//  val 修饰的属性不能赋默认值，必须显示指定
}

 

scala的方法

定义形式

def functionName ([参数列表]):[return type]={  function body

  return [expr]}

其中返回类型可以不写，就会根据你函数体的最后一行的类型值来自动生成

如下;

def sum(n1: Int, n2: Int): Int =

{ n1 + n2 }

还可以写成这种形式，直接跟=号 ，也是默认最后一行的类型值来自动生成

def sum(n1: Int, n2: Int)=

{ n1 + n2 }

 

scala类的权限控制

scala中权限修饰符主要为public(不写)、protected和private，可以用来修饰类、方法和属性，如果没写权限修饰符，默认就是public，这个的权限范围跟java一样，此外private修饰的，也只能在本类中使用，跟java类似。

权限修饰符	本类	子类	同包类	其他类
默认不写-public	true	true	true	true
protected	true	true	false	false
private	true	false	false	false

scala中的类默认是public ，所以不用像java中写 public  class classname {}

另外scala中有更加细粒度的权限控制  

使用protected[x]或private[x]来修饰成员，可以做到对权限的精确控制，其中x可以是类、包和单例对象

具体可以看这篇博客中的权限控制这块。

https://www.cnblogs.com/youngchaolin/p/12360647.html#_label5

 

scala的创建对象

1）基本语法

val | var 对象名 [：类型] = new类型()

 

Scala的主构造器，辅助构造器

定义形式

class 类名(形参列表) {  // 主构造器

   // 类体

   def  this(形参列表) {  // 辅助构造器

   }

   def  this(形参列表) {  //辅助构造器可以有多个...

   }

}

辅助构造器必须直接或间接与主构造器绑定，也就说要有一个辅助构造器和主构造器绑定

class Person_1 {

  private var name = ""

  private var age = 0

  def this(name: String) { //一个辅助构造器

    this() //调用主构造器

    this.name = name

  }

  def this(name: String, age: Int) {//另一个辅助构造器

    this(name)//调用前一个辅助构造器

    this.age = age

  }

}

具体细节可以看这篇博客

https://www.cnblogs.com/zsql/p/10952565.html

 

继承和特质

scala的继承概念和java差不多，但是scala是单继承体系

这篇博客讲的继承extends和特质trait

 https://juejin.cn/post/6844903950102036493#heading-6

也可以直接看这篇的类对象接口篇比较通俗易懂

https://blog.csdn.net/qq_39346903/article/details/113562823?ops_request_misc=&request_id=&biz_id=102&utm_term=scala%E6%95%99%E7%A8%8B&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-8-113562823.pc_search_all_es&spm=1018.2226.3001.4187

来看一下继承时的父子类执行顺序

class Person08(nameParam: String) {
  var name = nameParam
  var age: Int = _ // 给属性一个默认值

  def this(nameParam: String, ageParam: Int) {
    this(nameParam)
    this.age = ageParam
    println("父类辅助构造器")
    println(this.age)
  }

  println("父类主构造器")
}


class Emp(nameParam: String, ageParam: Int) extends Person08(nameParam, ageParam) {
  var empNo: Int = _

  def this(nameParam: String, ageParam: Int, empNoParam: Int) {
    this(nameParam, ageParam)
    this.empNo = empNoParam
    println("子类的辅助构造器")
  }

  println("子类的主构造器")
}


object Test {
  def main(args: Array[String]): Unit = {
    new Emp("z3", 11, 1001)
  }
}

 new Emp 带着参数进入到子类的辅助构造器，但是这里只是带参数进到 def this (,,,,)这里，不执行里面的函数体，然后继续往上找，直到父类的主构造器，都是只带着参数，不执行函数体，也不给里面的属性参数赋值，找到源头父类的主构造器，才开始，赋值属性参数，执行非方法函数，依次往下。

这里的执行顺序是 父类主构造器-》父类的辅助构造器-》子类的主构造器-》子类的辅助构造器

 

Scala的单例对象（伴生对象）和apply方法

 

Scala语言是完全面向对象的语言，所以并没有静态的操作（即在Scala中没有静态的概念）。但是为了能够和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，该对象为单例对象。若单例对象名与类名一致，则称该单例对象这个类的伴生对象，这个类的所有“静态”内容都可以放置在它的伴生对象中声明。

单例对象 类似 于Java中的 启动类 放置  public static void main 启动函数 ，单例对象上升为伴生对象的途径就是在类对象文件中 同时声明单例，且这个单例对象名字和这个类对象名字一致。

 

1）基本语法

object Person{
​ val country:String=“China”

}

2）说明

（1）单例对象采用object关键字声明

（2）单例对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。

（3）单例对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问
 （4） 要防止伴生对象调用类中信息，可以加 作用域限定符 private[this ] ,具体可以去上面看权限控制板块讲述。

 

// (1) 伴生对象采用object关键字声明
object Person_danli {
var country: String = "China"
}

// (2) 伴生对象对应的类称为伴生类，伴生对象的名称应该和伴生类名一致
class Person_danli {
var name: String = "taotao"

}

object Test_danli {
def main(args: Array[String]): Unit = {
// （3）伴生对象中的属性和方法都可以通过伴生对象名（类名）直接调用访问
println(Person_danli.country)
}
}

 

apply方法是定义在伴生类中的方法，当新建对象的时候，如果不是用new，而是直接类名（）这样创建类的话，那么使用的都是apply方法。

可以去这篇博客看详细说法

https://zhuanlan.zhihu.com/p/95737087

 

 

 类型检查和转换
1）说明

（1）obj.isInstanceOf[T]：判断obj是不是T类型。

（2）obj.asInstanceOf[T]：将obj强转成T类型。

（3）classOf获取对象的类名。

2）案例实操

package com.atguigu.chapter6

class Person14 {

}

object Person14 {
def main(args: Array[String]): Unit = {
val person = new Person14

// (1) 判断对象是否为某个类型的实例
val bool: Boolean = person.isInstanceOf[Person14]
if (bool) {
// (2) 将对象转换为某个类型的实例
val p1: Person14 = person.asInstanceOf[Person14]
println(p1)

// (3) 获取类的信息
val pClass: Class[Person14] = classOf[Person14]
println(pClass)
}
}
}

 枚举类和应用类
1）说明

​ 枚举类：需要继承Enumeration

​ 应用类：需要继承App

2）案例实操

package com.atguigu.chapter6

object Test_Em {
def main(args: Array[String]): Unit = {
println(ColorEm.RED)
}

}

//枚举类
object ColorEm extends Enumeration {
val RED = Value(1, "red")
val YELLOW = Value(2, "yellow")
val BLUE = Value(3, "blue")
}

//应用类
object TestApp extends App {
println("xxxxx")
}

Type定义新类型
1）说明

使用type关键字可以定义新的数据数据类型名称，本质上就是类型的一个别名，类似c++ 和c 语言中的typedef用法

2）案例实操

package com.atguigu.chapter6

object Test_Type {
def main(args: Array[String]): Unit = {
type S = String;
var v: S = "abc"

def test(): S = "xyz"
}

}