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()
}
}
浙公网安备 33010602011771号