scala语法：包，类和对象，文件，访问修饰符，属性，方法，构造方法，自定义方法，自定义函数，动态参数，隐式函数，泛型，集成和堕胎，动态混入，异常

最新推荐文章于 2022-06-16 09:29:33 发布
最新推荐文章于 2022-06-16 09:29:33 发布
阅读量84 收藏
点赞数
分类专栏： 学术 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fljiaoyuxue/article/details/118881441
版权

scala语法

//包

//包申明
package cn.kgc.scalaoop.test01		//一个文件一个模块

package cn.kgc.scalaoop.test01{		//一个文件多个模块
	作用域
}


//包对象：相当于类 => 作用域(相对小)
package object packobj{				//一个包多个模块
	作用域
}

//类和对象

一个文件中只写一个类 => 类似于java
同一个文件中同名的class(伴生类)和object(单例伴生对象：运行时由虚拟机创建，程序人员直接使用)
	//scala纯粹OOP，不支持static
	//object(伴生对象)：相当于给伴生类提供了静态成员
	//伴生类和伴生对象之间可以互相访问私有属性
scala中文件
	object				黄色o
	class				蓝色c
	class + object		上蓝下黄
	classes + objects	灰色图标
scala class
	访问修饰符
		private
		protected
		public	(默认)
	属性
		访问修饰符 var|val varName:Type = 初值
		属性名称和构造参数名称不能相同
	方法
		方法的参数可以通过"="号赋默认值
		返回值为方法体中最后一个表达式的结果，不使用return关键字
		构造方法
			一个主构造方法+n个辅助构造方法 ：构成构造方法的重载
			class ClassName(p1:Type1,...){}
			辅助构造方法依赖主构造方法
			class ClassName(p1:Type1,...){
				def this(p1:Type1,...){			//构造方法){之间无=
					
				}
				def this(p1:Type1,...){			//构造方法){之间无=
					
				}
			}
			
		自定义方法
			方法是类的一部分
			def methodName(param*:Type):ReturnType={方法体}
				如果方法体只有一句话，则{}可以缺省
		自定义函数
			独立的对象：可以自由传递
				//本质
				class f extends Function2[Int,Int,Int]{
				  override def apply(v1: Int, v2: Int): Int = v1+v2
				}
				
				//应用
				val f = (a:Int,b:Int)=>a+b:Int
				
		函数可以作为方法的参数或返回值
			def method(f:(Type1,...)=>ReturnType)=...		//函数作为参数
			def method():(Type1,...)=>ReturnType=...		//函数作为返回值
				调用method()(v1,...)
				函数作为返回值的现象称之为柯里化
				
		动态参数 params:Type*
			带有动态参数的方法，其他参数不能有默认值
			动态参数必须是最后一个
			动态参数每传递一次增加一个维度
			
		隐式参数
			先创建隐式变量：implicit var|val VAR_NAME:Type = value
			创建带隐式参数的函数
				def method(v1:Type1,...)(implicit param:Type)=...
				
		隐式函数
			隐式函数参数
			隐式转换
			
		隐式类
			扩展某指定类型/某执行类的功能
			必须且只能有带有唯一参数的构造器，构造参数的类型决定了被扩展参数的类型
			case class T()

			implicit class Cal(v:Int){
			def sqr()=v*v
			def cub()=sqr()*v
			}

			implicit class Enc(v:String){
			def enc()=v.map(x=>(x+1).toChar)
			}

			implicit class TExt(v:T){
			def pow(a:Int,b:Int)=math.pow(a,b)
			}
			
			println(2.sqr())
			println(2.cub())
			println("abc".enc())
			println(T().pow(3, 2))
			
			
		泛型
			参数化类型可变：必须继承关系的两个类 (多态)
			参数化类型的泛化
			协变 List[+A]	面向A的超类 返回值		类型放大
			逆变 List[-A]	面向A的子类 参数		类型缩小
			不变 [T]
			
			
		闭包
			方法内应用
	
	
	//样例类：方便
		case class Student(name:String,age:Int,gender:Char){
			def me()=s"${name}\t${age}\t${gender}"
			def show()=println(me)
		}
		
		val stu1 = Student("henry",18,'男')
		stu1.show()
		
	//普通类
		class Stu(name:String,age:Int,gender:Char){
			var _name:String = name
			var _age:Int = age
			var _gender:Char = gender
			def me()=s"${_name}\t${_age}\t${_gender}"
			def show()=println(me)
		}
		
		val stu2 = new Stu("henry",18,'男')
		stu2.show()
		
	备注：数据封装：首选元组（22列以内），其次样例类
		  业务封装：特质，抽象类，普通（伴生）类|伴生对象（静态成员和方法）|包对象（独立模块如工具类）
			

//继承和多态
	class Type extends Single		单继承
	class Type with Dao1 with Dao2	多混入
	[+A]

//特质 trait
	package cn.kgc.scalajdbc.oop04{
		trait Dao[T]{
		def exeUpdate(sql:String,params:Object*):Int
		def exeQuery(sql:String,params:Object*):List[T]
		}
		trait Dao2
	}

	package cn.kgc.scalajdbc.oop05.stu {
		case class Student(name:String,age:Int,gender:Char)
		class StudentDao extends DaoBase with Dao[Student] with Dao2 {
		override def exeUpdate(sql: String, params: Object*): Int = ???
		override def exeQuery(sql: String, params: Object*): List[Student] = ???
		}

		object StudentDao extends Dao[Student] {
		override def exeUpdate(sql: String, params: Object*): Int = ???
		override def exeQuery(sql: String, params: Object*): List[Student] = ???
		}
	}
	
	//动态混入
	val fs = new FreeStudent() with Dao[Student]{
		override def exeUpdate(sql: String, params: Object*): Int = ???
		override def exeQuery(sql: String, params: Object*): List[Any] = ???
	}
	val fs2 = new FreeStudent()

实例1

package cn.kgc.scalajdbc.oop01{
  //主构造器
  class Test01(name:String="NONE",age:Int=0,gender:Char='男') { //主构造方法
    //属性
    var _name: String = name
    var _age: Int = age
    var _gender: Char = gender

    //辅助构造器
    def this(name: String, age: Int) { //辅构造器
      this(name, age, '男')
    }

    //自定义方法：无参有返回值
    def me(): String = s"${_name}\t${_age}\t${_gender}"

    //自定义方法：无参无返回值
    def show() = println(me)

    //自定义方法：有普通参数和普通返回值
    def add(a:Int,b:Int):Int=a+b

    //自定义方法：函数作为参数
    def add(a:Int,b:Int,f:(Int,Int)=>Int):Int = f(a,b)

    //定义柯里化方法：函数作为参数
    def add2(a:Int,b:Int)(f:(Int,Int)=>Int):Int = f(a,b)

    //自定义方法：函数作为返回值:柯里化正统
    def add():(Int,Int)=>Int = {
      def a(a:Int,b:Int):Int = a+b
      a
    }

    //自定义方法：传入隐式参数
    def add(arr:Array[Int])(implicit initVal:Int) = {
      var rst:Int = initVal
      //arr.foreach(x=>rst=rst+x)
      for (elem <- arr) {
        rst = rst + elem
      }
      rst
    }

    //自定义方法：传入隐式函数参数
    def cal(a:Int,b:Int)(implicit f:(Int,Int)=>Int):Int = f(a,b)
  }
  object Test01 {
  }
}

实例1 Test

package cn.kgc.scalajdbc.oop01

object Test {
  def main(args: Array[String]): Unit = {
    /*val t1 = new Test01("henry",18)
    val t2 = new Test01("pola",16,'女')
    val t3 = new Test01
    t1.show()
    t2.show
    t3.show*/

    val t1 = new Test01
    //println(t1.add(1, 2))
    //println(t1.add(1, 2, _ + _))
    //println(t1.add2(1, 2)(_ + _))
    //println(t1.add()(1, 2))

    //隐式参数：隐式传值
    //implicit val initVal:Int = 5
    //println(t1.add(Array(2, 3, 4)))
    //隐式参数：显示传值
    //println(t1.add(Array(2, 3, 4))(3))

    //隐式函数
    //1、隐式转换
    /*implicit def toInt1(v:String)={
      println("implicit toInt1 invoked")
      v.toInt
    }
    implicit def toInt2(v:Double)=v.toInt
    var v:Int = "123"
    var v2:Int = 12.345
    println(v*2)
    println(v2+3)*/

    //2、隐式函数参数
    implicit def add(a:Int,b:Int):Int = a/b
    println(t1.cal(1, 2)(_-_))
  }
}

实例2

package cn.kgc.scalajdbc.oop02{
  //模块化：设计 ：具体业务
  class Test01(name:String="",age:Int=0,gender:Char=Test01.DEFAULT_GENDER) {
    var _name:String = name
    var _age:Int = age
    var _gender:Char = gender
    private val PRIVATE_KEY:String = "kb12redis"

    def this(name:String,age:Int){
      this(name,age,Test01.DEFAULT_GENDER)
    }

    def me()=s"${_name}\t${_age}\t${_gender}"

    def show()=println(me)


  }

  object Test01{
    private val public_key:String = "123456"
    private val DEFAULT_GENDER:Char = '男'

    println(new Test01().PRIVATE_KEY)
  }
}

package cn.kgc.scalajdbc.oop03{
  //工具类:通用性 :
  package object util{
    val PI:Double = 3.14
    def cal()=println("aa")
    //动态参数
    def cal(params:Int*)=params.sum
  }
  object util2{
    val PI:Double = 3.14
    def cal()=println("aa")

  }
}

package cn.kgc.scalajdbc.oop04{
  trait Dao[T]{
    def exeUpdate(sql:String,params:Object*):Int
    def exeQuery(sql:String,params:Object*):List[T]
  }
  trait Dao2
}

package cn.kgc.scalajdbc.oop05.com{

  import java.sql.Connection

  abstract class DaoBase{
    def con():Connection={
      null
    }
  }
}

package cn.kgc.scalajdbc.oop05.stu {

  import cn.kgc.scalajdbc.oop04._
  import cn.kgc.scalajdbc.oop05.com.DaoBase

  case class Student(name:String,age:Int,gender:Char)
  class StudentDao extends DaoBase with Dao[Student] with Dao2 {
    override def exeUpdate(sql: String, params: Object*): Int = ???
    override def exeQuery(sql: String, params: Object*): List[Student] = ???
  }

  object StudentDao extends Dao[Student] {
    override def exeUpdate(sql: String, params: Object*): Int = ???
    override def exeQuery(sql: String, params: Object*): List[Student] = ???
  }

  class FreeStudent
}

实例2 Test

package cn.kgc.scalajdbc.oop02

object Test {

  case class T()

  implicit class Cal(v:Int){
    def sqr()=v*v
    def cub()=sqr()*v
  }

  implicit class Enc(v:String){
    def enc()=v.map(x=>(x+1).toChar)
  }

  implicit class TExt(v:T){
    def pow(a:Int,b:Int)=math.pow(a,b)
  }

  abstract class Math[-T,+R]{
    def func(t:T):R
  }

  class F(v:Int){var _v:Int = v;}
  class S(v:Int) extends F(v:Int)
  class G(v:Int) extends S(v:Int)

  case class A(name:String,age:Int)
  case class B()

  class Add extends Math[S,S]{
    override def func(t: S): S = new S(t._v*t._v)
  }

  class Collect[-A](a:A*){}

  //样例类
  case class Student(name:String,age:Int,gender:Char){
    def me()=s"${name}\t${age}\t${gender}"
    def show()=println(me)
  }
  //普通类
  class Stu(name:String,age:Int,gender:Char){
    var _name:String = name
    var _age:Int = age
    var _gender:Char = gender
    def me()=s"${_name}\t${_age}\t${_gender}"
    def show()=println(me)
  }


  def main(args: Array[String]): Unit = {
    //println(new Test01()._age)
    import scala.math._
    import cn.kgc.scalajdbc.oop02.Test01
    /*import cn.kgc.scalajdbc.oop03.util._
    cal()
    println(cal(2, 3, 4))*/

    /*println(2.sqr())
    println(2.cub())
    println("abc".enc())
    println(T().pow(3, 2))*/

    //println(new Add().func(new S(2))._v)

    /*new Collect[F](new S(2))
    new Collect[S](new G(2))
    new Collect[G](new G(2))*/

    /*var ratio:Float = 0.892f
    def func(v:Int)={
      v*ratio
    }

    var a:Int = 5
    a*ratio*/

    /*val stu1 = Student("henry",18,'男')
    val stu2 = new Stu("henry",18,'男')
    stu1.show()
    stu2.show()*/

    /*import cn.kgc.scalajdbc.oop05.stu.FreeStudent
    import cn.kgc.scalajdbc.oop04._
    val fs = new FreeStudent() with Dao[Student]{
      override def exeUpdate(sql: String, params: Object*): Int = ???
      override def exeQuery(sql: String, params: Object*): List[Student] = ???
    }
    val fs2 = new FreeStudent()*/
  }
}

异常

package cn.kgc.scalajdbc.oop7

object ExceptionTest {
  def main(args: Array[String]): Unit = {
    //异常
    //编译异常 try catch    运行时异常  程序逻辑
    try{
      val arr = Array(1,2.0)
      val ix = 1
      if(ix>=arr.length){
        throw new ArrayIndexOutOfBoundsException("index $ix out of bounds")
      }
      if(0==arr(1)){
        throw new ArithmeticException("/by zero")
      }
      println(arr(0)/arr(1))
    }catch{
      case e:IndexOutOfBoundsException=>println(e.getMessage)
      case e:ArithmeticException=>println(e.getMessage)
      case _=> println("unkown error")
    }finally {
      println("finally")
    }


    //有两个值有3个值得 用collect偏函数把只有2个值得映射出来
    Array(("henry",19,"male"),("jack",19),("pola",16,"female"),("ariel",8))
      .collect({
        case (a,b)=>s"$a\t$b"               //假如2个就输出2个
        case (a,b,"male")=>s"$a\t$b\tmale" //假如2个+male   输出 两个+male
      })
      .foreach(println)


    //运行时异常在scala中是怎么处理的
    import scala.collection.mutable.Map
    def cal1(a:Int,b:Int):Map[String,Any]={
      val rst = Map[String,Any]()
      if(0==b){
        rst.put("exception",new ArithmeticException("/by zero"))
      }else{
        rst.put("result",a/b)
      }
      rst
    }
    def cal2(a:Int,b:Int):Option[Float]={   //用Option一般是避免异常发生 用判断规避它
      if(0==b){
        Option.empty
      }else{
        Some(a*1.0f/b)
      }
    }
    //推荐用下面这个
    def cal3(a:Int,b:Int):Either[ArithmeticException,Float]={
      if(0==b){
        Left(new ArithmeticException("/by zero"))
      }else{
       Right(a*1.0f/b)
      }
    }
    val value: Either[ArithmeticException, Float] = cal3(1, 2)
    if(value.isLeft){
      println(value.left.get)
    }else{
      println(value.right.get)
    }



  }

}
fljiaoyuxue
关注
专栏目录
Scala(6) -- scala类(成员变量、成员方法、修饰符)和对象
erainm
09-19 1884
1. 类和对象 2. 定义和访问成员变量 3. 下划线初始化成员变量 4. 定义和访问成员变量 5. 访问权限修饰符 6. 类的构造器 7. 单例对象 8. main方法 9. 伴生对象 10. 案例
Spark学习笔记09:Scala类和对象
balabalalibala的博客
05-20 670
... scala类和对象
覆盖（Override）和重写（Overload）的区别
weixin_30940783的博客
09-06 106
Overload Overload是重载的意思。 重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。 Overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。 在使用重载要注意以下的几点...
面向对象概念 重载与重写（重写又称覆盖）
幸福的瞬间
10-15 901
代码复用方式： 设计成公共类。类就是具有相同的属性和功能的对象的抽象的集合。   你写了一个函数shout()。 情况： 在其他 模块（即关联性很小的模块） 也需要 一个shout() ，如何处理？ 改成public，让别人使用？ —— 写成类。（面向对象是不是没有独立的函数）： (C. Java语言中的方法属于类中的成员（member）) D. Java语言中的方法必定隶属于某一类
idea无法新建scala类解决办法
Zero小猿的博客
01-24 6507
1. 问题及背景   用idea新建了一个maven项目，完成了项目的各种配置如maven环境、sdk、jdk等，准备新建一个scala类时，却发现没有这个选项。尝试了各种常用办法都不行，以下三个常用方法确实能够解决绝大部分idea无法新建scala工程的问题： 1.在global labrari重新配置sdk的； 2.把整个src目录作为source 3.把settings下maven的Use plugin registry选项勾选上 2. 解决方法   在尝试了多次之后，无奈只好新建一个file，
Java笔试题（一）单选题
热门推荐
互联网叫兽
08-15 13万+
1、下列哪一种叙述是正确的 A． abstract修饰符可修饰字段、方法和类 B． 抽象方法的body部分必须用一对大括号{ }包住 C． 声明抽象方法，大括号可有可无 D． 声明抽象方法不可写出大括号 答案：D abstract（抽象）修饰符，可以修饰类和方法 abstract修饰符在修饰类时必须放在类名前。 public abstract void method(); 2、如下代码，...
子类重写（覆盖）父类的方法必须满足的条件+构造方法和方法的重载和重写
升级打怪
02-28 4086
父类中的方法在子类中必须可见，即子类继承了父类中的该方法（可以显式的使用 super 关键字来访问父类中的被重写的方法），如果父类中的方法为 private 类型的，那么子类虽能继承，但无法覆盖 子类和父类的方法必须是实例方法，如果父类是 static 方法而子类是实例方法，或者相反都会报错。如果父类和子类都是 static 方法，那么子类隐藏父类的方法，而不是重写父类方法 ...
Scala编程详解 第12讲-Scala编程详解：面向对象编程之类 共12页.pptx
最新发布
11-25
Scala是一种强大的多范式编程语言，它融合了面向对象和函数式编程的特性，尤其在大数据处理领域，如Apache Spark，Scala是首选的开发语言。本课程深入讲解Scala编程，涵盖了从基础语法到高级特性的各个方面，旨在...
Scala:它包含一些scala程序以了解其语法
03-12
类和对象是Scala的核心概念，你可以通过定义类来创建新的数据类型，并通过对象实例化这些类。同时，Scala支持单例对象，它们类似于Java中的静态成员，但具有更强大的功能。 函数在Scala中也是第一等公民，这意味着...
Scala类和对象
qq_57026298的博客
06-16 860
scala
Scala教程(六)类、属性和对象字段
yuan_xw的专栏
09-22 8321
定义类：Scala是一种纯粹的面向对象编程语言，而又无缝地结合了命令式和函数式的编程风格。在面向对象的语言有两个重要的概念：类(class)和对象(object也被称为实例—instance)，其中类是对象的抽象。可以把类理解为模板，对象才是真正的实体。 伴生对象：在Java或C++中即有实例方法又有静态方法。在Scala可以通过类与同名的“伴生”对象来达到同样的目的。类和它的伴生对象可以互相访问私有特性。它们必须在于同一个源文件中。 scala继承(extends)：子类继承父类的特征和行为，使得子类具有
Java基础--重写（Overriding，覆盖）-重载（Overloading）
05-09 115
多态性: 　　Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法 　　Java的方法重写，就是各子类对父类中的方法可能有其他特殊定义，需要将父类中的方法的内容重写计算一边。方法名，返回类型，方法参数必须相同的情况下，即为重写 　　多态性是面向对象编程的一种特性，...
Java高频面试题—Java基础
weixin_44838502的博客
08-04 175
Java高频面试题—Java基础 1. 面向对象可以解释下吗？都有哪些特性？ 答：面向对象是一种思想，可以将复杂的问题简单化，让我们从执行者变为指挥者。面向对象的三大特征：封装、继承和多态。 封装：将事务封装成一个类，减少耦合，隐藏细节。保留特定的接口与外界联系，当接口内部发生改变时，不影响外部的调用方。 继承：从一个已知的类中派生出另一个新的类，但新的类拥有已知类的属性和方法，并且可以通过覆盖/重写来增强已知类的能力。 多态：多态的本质就是一个程序中出现多个同名的不同方法，主要通过三种方式体现： 通过
java中函数覆盖（即重写override），子类的返回类型一定要和父类一样吗？
HD243608836的博客
09-22 1万+
分情况的，第一种情况：jdk1.4及之前的版本返回类型必须完全一样。第二种情况：jdk1.5及之后的版本，返回类型可以是父类返回类型的兼容类型。 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 关于重写，遵循以下的规则（不变：参数列表、返回类型（类型可以是子类））：（1）重写方法必须和被重写方法具有相同的参数列表（包括顺序及个数还有类型），返回类型必须和被重写方法的返回类型相同...
scala属性的getter和setter方法
qa38113202的博客
06-16 3484
类的基本内容要点： 1、scala在定义字段时使用var ,默认生成对应setter和getter方法 2、调用了scala的setter方法  对应的名称money_= 3、调用了scala的gettter方法  对应的名称就为字段名称money 4、当使用val定义字段时，scala不在提供对应的setter方法 5、如果使用private修饰字段时 scala不在提供对应的sett
Java方法重写
benhz的博客
12-06 4510
方法重写 如果子类中具有与父类中声明相同的方法，在java中称为方法覆盖。换句话说，如果子类提供了由其父类提供的其中一个方法的特定实现，则它被称为方法覆盖。所以方法覆盖有两个前提条件：继承和子父类中方法名称相同。 q)方法覆盖的用法 在继承超类的同时，添加当前类的行为。 方法重写用于运行时多态。 q)方法覆盖的条件 首先得继承 与父类中方法的名称相同 与父类中方法的参数相同（这点容易和重载混...
java map类说_在Java中，关于HashMap类的描述，以下说法错误的是（   ）。
weixin_35891825的博客
02-27 1703
【单选题】所谓覆盖，也称为重写，是指子类中定义了一个与父类某一方法具有相同型构的方法，这里所说的相同型构所指的不是()。【填空题(主观)】半导体二极管实质上是由 [填空(1)] 构成，其主要特性是 [填空(2)] 。【单选题】对直接承受动力荷载的矩形截面梁，截面塑性发展系数取值为( )【判断题】静载试验效率系数与实际加载车辆重力无关。【单选题】检测简支梁桥的最大压应力，其应变片应( )。【...
11.Scala属性和访问权限
resilienter的博客
12-27 676
Scala属性和访问权限 在类中声明的变量就是属性 基本语法 [修饰符] var|val 属性名称 [：类型] = 属性值 在scala中，当使用var声明了一个属性时，scala在编译时会自动为该属性构造类似set和get方法（名字不符合javabean规范）。 一下是反编译的源码 public class User { private String name = "zhangsan...
scala开发新建文件，不显示scala class
limiaoiao的博客
05-11 447
scala开发新建文件，不显示scala class 首先，鼠标选定项目，单击右键，，其次，选择Add FrameWorks Support,弹出第二张图，选择scala。图片展示如下：（改方法仅限配置好plugin，选择文件夹为source之后还不出现scala class的情形） 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们
掌握Scala基础：变量、方法与类设计
本篇文章是关于Scala编程语言的基础介绍，涵盖了变量、方法、方法调用、方法重写以及类和构造函数等内容。 1. 变量: Scala中的变量类型分为`vals`（不可变值）和`var`（可变变量）。在Scala中，声明不可变变量使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值