scala 入门2

1 创建类和对象

class Abc{}

val a = new Abc()

class Abc

val a = new Abc

 

2 定义和访问成员变量

class Abc {
var a1 = ""
var a2 = 0
}

val abc = new Abc
abc.a1= "demo"
abc.a2= 3

 

3 下划线初始化成员变量(只有var 定义的变量可以用_初始化)

class Abc {
var a1:String = _
var a2:Int = _
}

val abc = new Abc
abc.a1= "demo"
abc.a2= 3

 

4 定义成员方法

class Abc {
var a1:String = _
var a2:Int = _

def hello(a3:String)= {

println(a1+"_"+a3)

}
}

val abc = new Abc
abc.a1= "demo"
abc.a2= 3

abc.hello("4")

 

5 访问修饰符

class Abc {

private a1:String = _
private a2:Int = _

def getA1() = a1
def setA1(a1:String) = this.a1 = a1
def getA2() = a2
def setA2(a2:Int) = this.a2 = a2
}

val abc = new Abc
abc.setA1("demo")
abc.setA2(3)
println(abc.getA1())
println(abc.getA2())

 

6 主构造器

class Abc(var a1:String = "", var a2:Int = 0) {
println("调用abc")
}

val abc1 = new Abc("1", 10)
println(abc1.a1)
println(abc1.a2)

val abc2 = new Abc
println(abc2.a1)
println(abc2.a2)

val abc3 = new Abc(a2 = 30)
println(abc3.a1)
println(abc3.a2)

 

7 辅助构造器

class Abc(var a1:String = "", var a2:String = "") {
　　def this(arr:Array[String]) = {
　　　　this(arr(0), arr(1))
　　}
}

val abc = new Abc(Array("1", "2"))
println(abc.a1)
println(abc.a2)

 

8 定义单例对象

object Abc{

val num = 1
}

def main(args: Array[String]): Unit = {
println(Abc.num)
}

 

object Abc{
　　val num = 1

　　def print() ={
　　println("-"*10)
　　}

}

def main(args: Array[String]): Unit = {
　　println(Abc.num)
　　Abc.print
}

 

object Abc{
private val dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm")

def format() ={
dateFormat.format(new Date())
}

}

def main(args: Array[String]): Unit = {
println(Abc.format())
}

 

9 main 方法

def main(args: Array[String]): Unit = {
println(Abc.format())
}

 

object t02 extends App {

println("123")

}

 

10 伴生对象

class Abc{
def test()={
println(s"${Abc.a1} 测试")
}
}

object Abc{
private val a1="123"
}

def main(args: Array[String]): Unit = {
val abc = new Abc()
abc.test()
}

private[this]，只能在当前类中访问。

class Abc(private var a1:String)
object Abc{
def method1(abc:Abc) = {
println(abc.a1)
}
}

def main(args: Array[String]): Unit = {
val abc = new Abc("qq")
Abc.method1(abc)
}

 

11 apply方法

class Abc(var a1:String="",var a2:Int=0)

object Abc{
def apply(a1: String, a2: Int): Abc = new Abc(a1, a2)
}

def main(args: Array[String]): Unit = {
val abc = Abc("1",2)
println(abc.a1)
println(abc.a2)
}

 

12 继承 (重点)

12.1 类继承

class Parent {
var a1 = "a1"

def getA1 = this.a1
}

class Children extends Parent

object t07 {

def main(args: Array[String]): Unit = {
val parent = new Parent()
val children = new Children()
children.a1 = "a1"
println(children.getA1)
}
}

 

12.2 单例对象继承

class Parent {
var a1 = "a1"

def getA1 = this.a1
}

object Children extends Parent

object t07 {

def main(args: Array[String]): Unit = {
println(Children.getA1)
}
}

 

13 override和super  ( 重写成员变量是 val 类型， var类型 报错 ； super关键字访问父类成员方法)

class Parent {
val a1 = "a1"
def getA1 = this.a1
}

class Children extends Parent {
override val a1 = "a2"   
override def getA1: String = "children:" + super.getA1
}

object t07 {
def main(args: Array[String]): Unit = {
println(new Children().getA1)
}
}

 

14 类型判断

isInstanceOf 对象是否为指定类对象 (只判断对象是否为指定类以及其子类对象)
asInstanceOf 对象转换为指定类型

class Parent {
val a1 = "a1"
def getA1 = this.a1
}

class Children extends Parent {
override val a1 = "a2"
override def getA1: String = "children:" + super.getA1
}

object t07 {
def main(args: Array[String]): Unit = {
val parent:Parent = new Children()
if(parent.isInstanceOf[Children]){
println("parent.isInstanceOf[Children]")
val children = parent.asInstanceOf[Children]
println(children.getA1)
}
}
}

 

15 getClass (精确获取对象类型) 和 classOf (精确获取类型)  和 ==操作符可以直接比较类型

class Parent {
val a1 = "a1"
def getA1 = this.a1
}

class Children extends Parent {
override val a1 = "a2"
override def getA1: String = "children:" + super.getA1
}

object t07 {
def main(args: Array[String]): Unit = {
val parent:Parent = new Children()
println(parent.isInstanceOf[Parent])
println(parent.getClass == classOf[Parent])
println(parent.getClass == classOf[Children])
}
}

 

16 抽象类 (重点)  只能是 类继实现 抽象类， 单例对象不可以。

方法没有方法体（抽象方法）
变量没有初始化（抽象字段）

abstract class Root {
def area:Double
}

class Children1(var edge:Double) extends Root{
override def area: Double = edge*edge
}

class Children2(var length:Double,var width:Double) extends Root{
override def area: Double = length*width
}

object t08 {
def main(args: Array[String]): Unit = {
val children1:Root = new Children1(1)
val children2:Root = new Children2(1,2)
println(children1.area)
println(children2.area)
}
}

 

17 抽象字段  (   var  val  类型字段都可以 )

abstract class Root {
val a1 :String
def area:Double
}

class Children1(var edge:Double) extends Root{

override val a1: String = "children1"
override def area: Double = edge*edge

}

class Children2(var length:Double,var width:Double) extends Root{
override val a1: String = "children2"
override def area: Double = length*width
}

object t08 {
def main(args: Array[String]): Unit = {
val children1:Root = new Children1(1)
val children2:Root = new Children2(1,2)
println(children1.a1)
println(children2.a1)
}
}

 

18 匿名内部类  (没有名称子类，Spark  源代码  用到匿名内部类 )

abstract class Root {
var a1: String

def a2
}

object t08 {
def main(args: Array[String]): Unit = {
var children1: Root = new Root {
override var a1: String = "a1"

override def a2 = println("匿名")
}

println(children1.a1)
children1.a2

}
}

 

19 特质 (重点)  (类似 接口， 每个类都只能继承一个超类， 而一个类可以添加任意数量特质 ，scala 类、抽象类、特质，都使用extends关键字)

 

19.1 类继承1个trait

trait Root {
def a1(msg:String)
}

class Children extends Root {
override def a1(msg:String): Unit = println("children:"+msg)
}

object t08 {
def main(args: Array[String]): Unit = {
val children = new Children()
children.a1("abc")
}
}

 

19.2 类继承多个trait

trait Root {
def a1(msg:String)
}

trait Test {
def a2(msg:String)
}

class Children extends Root with Test {
override def a1(msg:String): Unit = println("children:"+msg)

override def a2(msg: String): Unit = println("test:"+msg)
}

object t08 {
def main(args: Array[String]): Unit = {
val children = new Children()
children.a1("abc")
children.a2("abc")
}
}

19.3 object继承trait

trait Root {
def a1(msg: String)
}

object Children extends Root {
override def a1(msg: String): Unit = println("children:" + msg)
}

object t08 {
def main(args: Array[String]): Unit = {
Children.a1("abc")
}
}

 

19.4 特质中定义具体方法 ,特质定义具体的字段和抽象字段 

import java.text.SimpleDateFormat
import java.util.Date

trait Root {
val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm")
def a1(msg: String)
}
class Children extends Root {
override def a1(msg: String): Unit = {
val info = s"${sdf.format(new Date())}:控制台消息 :${msg}"
println(info)
}
}

object t08 {
def main(args: Array[String]): Unit = {
val children = new Children()
children.a1("abc")
}
}

 

20 实现模板模式

trait Root {
def base(msg: String)
def a1(msg:String) = base("a1="+msg)
def a2(msg:String) = base("a2="+msg)
def a3(msg:String) = base("a3="+msg)

}

class Children extends Root {
override def base(msg: String): Unit = {
println(msg)
}
}

object t08 {
def main(args: Array[String]): Unit = {
val children = new Children()
children.a1("a1")
children.a2("a2")
children.a3("a3")
}
}

 

21 对象混入 （将trait混入对象中，就是将trait中定义方法、字段添加到一个对象）

 

trait Root {
def base(msg: String) = println(msg)
}

class Children

object t08 {
def main(args: Array[String]): Unit = {
val children = new Children() with Root
children.base("123")
}
}

 

22 调用链

trait Root {
def base(msg: String) = println(msg)
}

trait Children1 extends Root {
override def base(msg: String): Unit = {
println("Children1")
super.base(msg)
}
}

trait Children2 extends Root {
override def base(msg: String): Unit = {
println("Children2")
super.base(msg)
}

}

class Children3 extends Children2 with Children1 {
override def base(msg: String): Unit = {
println("Children3")
super.base(msg)
}
}

object t08 {
def main(args: Array[String]): Unit = {
val children = new Children3()
children.base("123")
}
}

 

23      trait

23.1   trait构造机制

package cn.test

trait Root {
println("执行构造器")
}

trait Children1 extends Root {
println("Children1")
}

trait Children2 extends Root {
println("Children2")
}

class Children3 extends Children2 with Children1{
println("Children3")
}

object t08 {
def main(args: Array[String]): Unit = {
val children = new Children3()
}
}

 

23.2   trait继承class

class Root {
def log0(msg:String) = println(msg)
}

trait Children1 extends Root {
def log1(msg:String) = log0("children1:" + msg)
}

class Children3 extends Children1{
def log3() = log1("children3")
}

object t08 {
def main(args: Array[String]): Unit = {
val children = new Children3()
children.log3()
}
}