Scala编程基础4 类、对象、继承、特质

类、对象、继承、特质

小白的Scala学习笔记 2024‎/5‎/28‎ 11:30:40

package com.oracle.jt.testobject

import scala.collection.mutable.ListBuffer

class Student {
  def add(a:Int,b:Int)=a+b
  def spint(a:String)=a.split(",")
  def getList()={
    val list=new ListBuffer[String]()
    list.++=(Array("hello tom","jerry marry"))
    list
  }
  def print(lst:Map[String,Int])={
    lst.foreach(x=>println(x))
  }
}
//伴生类
object Student
{
  def main(args: Array[String]): Unit = {
    val stu =new Student()
    val list=List(22,33,55)
    val map = Map(("22",22),("33",33))
    stu.print(map)
    stu.getList().foreach(x=>println(x))
    println(stu.add(22, 33))
  }
}

package com.oracle.jt.testobject

/**
 * 构造方法，分为主构方法、辅助构造方法
 * 直接写在类名那里，就是主构造方法
 */
class Teacher(name:String,sex:String,age:Int) //这里就是主构造方法
{
  /**
   * 在Scala中属性必须赋值,可以用下划线占着
   */
  private var tname:String=name
  private var tsex:String=sex
  private var tage:Int=age
  private var phoneNumber:String=_
  def funPrint(): Unit ={
    println(tname,tsex,tage)
  }
  def this(phone:String)//this就是辅助构造方法,写辅助构造方法必须调用主构造方法
  {
    this("wangwu","nan",45)
    phoneNumber=phone
  }
  def this(){
    this("wangwu","nan",45)
    println("无参构造方法")

  }
}


object Teacher{
  def main(args: Array[String]): Unit = {
    var t=new Teacher("zhangsan","nan",23)
    t.funPrint()
    t.phoneNumber="143252354542"//这里phoneNumber是私有属性，其他类是不能访问的，这里的伴生类可以访问
    println(t.phoneNumber)

    var t2=new Teacher("12341234")
    t2.funPrint()

    var t3=new Teacher()
    t3.funPrint()

  }
}

Scala可以在类中、非方法中写代码，可以理解为代码写到了构造方法中

class A private(path:String)//这里的私有，表示其他类无法创建这个类对象
{
  //写在类中的代码相当于在java中的构造方法中的代码
println(path)
  for(i <- 0.to(11)){
    println(i)
  }
}

object A{
  def main(args: Array[String]): Unit = {
    var a=new A("D:/a.txt")
  }
}

import java.io.FileInputStream

class A private(path:String)//这里的私有，表示其他类无法创建这个类对象
{
//  //写在类中的代码相当于在java中的构造方法中的代码
//println(path)
//  for(i <- 0.to(11)){
//    println(i)
//  }

  try {// 也可以自己手动写try，catch

    //实现在文件中读
    val input = new FileInputStream(path) //Scala自己处理了抛异常的问题，所以直接这样就可以
    val cnt = new Array[Byte](1024)
    var flat = true
    while (flat) {
      val tmp = input.read(cnt)
      if (tmp == -1) {
        flat = false
      } else {
        println(new String(cnt, 0, tmp))
      }
    }
  }
  catch {// 也可以自己手动写try，catch,注意这里和java的差别
    case e:IndexOutOfBoundsException=>{
      e.printStackTrace()
    }
    case e:Exception=>{
      e.printStackTrace()
    }
  }
}

object A{
  def main(args: Array[String]): Unit = {
    var a=new A("D:\\b.txt")
  }
}

继承、接口

接口中既可以写声明，也可以写实现

继承父类用extends，实现接口也用extends，先继承父类（extends）再实现接口用with

class ParentEmp {
def signature={
  println("打卡")
}
}

class Employee extends ParentEmp with TestTrait {
def work(): Unit ={
  println("工作")
}

  override def add(): Unit = {
    println("add......")
  }
}

object TestEmp {
  def main(args: Array[String]): Unit = {
    val emp=new Employee()
    emp.signature
    emp.add()
    emp.work()
  }
}

trait TestTrait {
def add();
  def delete()=0
}

抽象类

Scala抽象类和接口功能差不多了，都能写声明和实现

abstract class ABSParent {
def add();
  def select()={
    println("查询.......")
  }
}

class ABSClass extends ABSParent {
  override def add(): Unit = {
    println("add.......")
  }
}

object
TestABS {
  def main(args: Array[String]): Unit = {
    val oo=new ABSClass()
    oo.add()
    oo.select()
  }
}

样例类

用来实现java中的实体类
Case Class