Scala面向对象—类详解2（继承相关）

1、单例类

package com.zzzy

class AAA {//单例

  /*//java  思路--私有化构造方法，提供公开的getAAA   行不通

  private  def this(){

    this()

  }

  def  getAAA():AAA={

    val aaa = new AAA()

    return aaa

  }

*/

}

package com.zzzy

//单例类

//伴生类

class BBB private(){//1私有化构造方法

}

//伴生对象

object BBB{

  //不写apply

  private val bbb=new BBB()//2创建一个私有对象

  def getBBB:BBB={//3提供了一个公开的get方法

    bbb

  }

}

package com.zzzy

object test {

  def main(args: Array[String]): Unit = {

    val b1 = BBB.getBBB

    val b2=BBB.getBBB

    println(b1==b2)//true

  }

}

2、object的继承和App

package com.zzzzy

abstract class Register {//定义一个抽象类

  //抽象方法（没有方法体，只有方法定义）

  def  regist(name:String)

  def unregist(name:String)

}

package com.zzzzy

//实现用extends

object User1 extends Register {

  override def regist(name: String): Unit = {

    println(name+"注册了")

  }

  override def unregist(name: String): Unit = {

    println(name+"注销了")

  }

}

package com.zzzzy

class User2(n:String) extends Register {//主构造方法

  override def regist(name: String): Unit = {

    println(name+"注册"+n)

  }

  override def unregist(name: String): Unit ={

    println(name+"注销"+n)

  }

}

package com.zzzzy

object test extends App {//1如果一个对象继承App可以不需要main方法直接运行

  /*def main(args: Array[String]): Unit = {

    println("aaa")

  }*/

  println("bbb")

  //2让一个object实现一个抽象类用关键字extends   重写未实现的方法

  User1.regist("小敏")

  User1.unregist("笑笑")

  //3让一个class实现一个抽象类用关键字extends   重写未实现的方法可以有构造方法

  new User2("白白").regist("lili")

  new User2("白白").unregist("jack")

}

3、类的继承

package com.zzzzzy

class Person {

  var name:String=_//必须给类型，无法推断

  var age:Int=_

  private var num=99

  def show(): Unit ={

    print("父类的方法")

  }

}

package com.zzzzzy

class Student extends Person {

  //不能重写被final修饰的方法

  var sex:Char='男'

  override def show(): Unit = {

    println("重写父类的方法show")

  }

  def speak(): Unit ={

    //调用了父类的属性 实测在运行中无法使用

    /*println(super.age)

    print(super.name)*/

      //私有属性num无法通过super找到

    super.show()//父类的方法

    show()//子类重写的

  }

}

package com.zzzzzy

object test extends App {

  val stu = new Student

  stu.speak()

//多态的向上转型

  var s:Person=new Student()

  //还能得到子类特有的方法和属性吗？不能

  s.show()//调用的为子类重写的方法

  println(s.name)//null

  println(s.age)

}

4、类型检查和类型转换

package com.zzzzzzy

class Person(name:String,age:Int){

  var name1="小明"

  var age1=50

  def show(): Unit ={

    println(name+"\t"+age)

  }

}

package com.zzzzzzy

//在一个scala文件中可以定义n个类  写在一行必须写；  大括号可以省略

class Emp extends Person("李四",40)

class Student extends Person("张三",30)

package com.zzzzzzy

object test extends App {

   val em = new Emp

  em.show()

   val stu = new Student

  stu.show()

  println("---------------------")

  //判断某个对象是否是某个类型

 val ss= new Student()

  //继承关系上  is a

  println(ss.isInstanceOf[Person])

  //转换--向上转型

  val pp: Person = ss.asInstanceOf[Person]

  pp.show()

}

5、protected关键字

package com.yz.extendz

class Animal {//父类     A和B都不是Animal的子类。那么属性的可使用情况如下

  val a=100           //A类可用           //B类可用

  protected  val b=200

  protected [this] val c=300

  protected [extendz] val d=400//yz为包名     //A类可用

  //这里四个属性，只要是Animal的子类都可以使用，无论在不在同一个包中

}

package com.yz.extendz

class Cat extends Animal{

  val y=888

  def show: Unit ={

    println(s"$a-------$b------$c---------$d")

  }

}

package com.yz.extendz

class Dog extends Animal {

  val x=999

  def show: Unit ={

    println(s"$a-------$b------$c---------$d")

  }

}

package com.yz.extendz

class A {

  def show: Unit ={

    val animal = new Animal

    println(animal.a)

    println(animal.d)

  }

}

package com.yz2

import com.yz.extendz.Animal

class B {

  def show: Unit ={

    val animal = new Animal

    println(animal.a)

  }

}

6、匿名子类

package com.yz3

class Person {

  def aaa="中国"

}

package com.yz3

object test  extends App {

  val pp= new Person {

    override def aaa: String = "新中国"

  }

 //这个过程中产生了一个匿名子类【发生重写，子类重写父类方法但是又没有显示的定义处理----匿名】

   val result = pp.aaa

  println(result)

  //定义方法

  println("-------------------")

  def show(p:Person): Unit ={

    println(p.aaa)

  }

  //调用

  show(new Person)

}

7、抽象

package com.yz4

abstract class Animal {//可以用于抽象或非抽象方法   拥有抽象字段/非抽象字段

//抽象字段(没有初始值)

  val count:Int

  //非抽象字段

  val num=100

  //抽象方法

  def aaa:String

  //非抽象方法

  def bbb: Int ={

    10

  }

}

package com.yz4

class Cat extends Animal {

  //重写抽象方法

  override def aaa: String = {"你好"}

  override val count: Int = 666

}

package com.yz4

object test extends App {

 val cat = new Cat

   val aaa: String = cat.aaa

   val bbb: Int = cat.bbb

   println(aaa+bbb)

}

8、特质（java接口）

package com.yz5

trait Log {

  //非抽象方法   抽象时super调用时会出错

  def  showa:String={

"原始的"

  }

}

package com.yz5

trait ALog extends Log {

  override def showa: String = {

    super.showa

    println("ALog重写的方法")

    "ALog"

  }

}

package com.yz5

trait BLog extends Log {

  override def showa: String = {

    println("BLog重写的方法")

    super.showa

    "BLog"

  }

}

package com.yz5

class CCC extends ALog with BLog {//继承两个特质

  //showa()//默认应该调用最右边的特质中的同名方法【发生同名，以右边为主】

  override def showa: String = {

    super.showa

  }

}

package com.yz5

object test extends App {

   val ccc = new CCC

            //条件：ALog和BLog重写方法中调用了super.showa

  ccc.showa//默认把所有的都运行出来(ALog和BLog中的都运行了)没办法只运行左边的

}

巴特西

Scala面向对象—类详解2（继承相关）

最新文章

热门文章