别人笑我太疯癫，我笑他人看不穿。

3、可变参数本身是个数组，你可以把一个数组做传参给可变行参，但是怎么用的话，就不能传其他的了。scala可变参数需要在类型后面加个*Java的可变参数是在类型后面加三个点。2、多个参数可变参数需要定义在最后。1、一个方法只能有一个可变参数。两者在使用的时候要注意。

这个错误通常出现在新建项目里面，这是个开发工具问题，点击Interllij IDEA中 File->Project structure, 选择 Module, 在Sources的页签里，右侧的, +Add Content Root面板中移除不存在的资源目录就行。这个问题一般出现在22版以后得idea上，原因是你在pom中导入的scala版本和你本地的SDK版本不一致，但是开发工具不提供兼容的能力，所以就报错了，解决方法就是把pom里面的scala版本号该成和本地一样的就行。

第一步：下载Scala插件，下图已经下载好了，没有下载时最右侧的详情中会有下载安装按钮，你也可以在项目中的settings-plugins中下载，一样的。前置条件你的电脑需要安装有JAVA-JDK、Maven、Scala-JDK、idea。第三步：src下创建一个scala资源路径，并设置为代码路径。第二步：正常创建Maven工程。OK后就可正常开发Scala了。第四步：添加scala的支持。

Scala Option(选项)类型用来表示一个值是可选的（有值或无值)，其实主要的目的是因为Scala不建议我们直接使用null去标识一个为空的数据在Scala中认为直接使用null是不好的，因此才出现了Option对象比如Option[T] 是一个类型为 T 的可选值的容器当我们调用方法取值的时候，如果值存在， Option[T] 就返回一个 Some[T] 的结果，如果不存在， Option[T] 返回的结果是一个 None对象 。...

Scala支持闭包，就是方法套方法，有的也会写类中定义类，那个是内部类不是闭包package com.wyobject OtherFunction { def main(args: Array[String]): Unit = { //(a+b)*c println(total(1,2,3)) } def total(a:Int, b:Int ,c:Int) = { def add(x:Int, y:Int) = { x + y } d

隐式转换的核心是implicit关键字作用是当操作的实体，无法满足操作条件时，如果拥有隐式转换的条件，那么会自动触发，给大家举个例子package com.wy/** * 隐式转换是Scala中一种特殊的功能，它能将一种数据类型转换成另外一种数据类型， * 然后这种数据类型将拥有另外一种数据类型的所有方法，可以看成是对类的一种增强。 * 隐式转换分为两种： * 1.隐式转换函数 * 2.隐式转换值 * * 定义隐式转换的关键字是implicit * 隐式转换的命名方式

Scala的柯里化，有的人也叫它半函数，它的应用场景就是让一个方法只传入部分参数就可以使用package com.wyobject CurryFunction { def main(args: Array[String]): Unit = { //println(add(2,3)) println(add2(2)(3)) } //柯里化之前 def add(x:Int,y:Int)={ x+y } //柯里化之后 def add2(x:Int)(y:

我们看Scala写的源码或者是其他人写的代码时，会发现有些object虽然他是一个

首先我想要让大家知道的是这三个东西用来干什么的，我们在其他编程语言中常出现一个问题，如果A是B的子类，那么A的对象实例化时，可以赋值给B的引用，但是如果中间隔了一层那父、子类之间的关系就不能用了，比如生成 List[B]=new ArrayList[A] 时，就不可以了斜变、逆变、非变就是用来解决这个问题的package comclass Superclass Sub extends Super//协变class Temp1[+A](title: String)//逆变class Temp

Scala有个不常用的东西叫做偏函数，它其实就是用了PartialFunction做一个一进一出的函数

Scala特质类和JAVA的接口在意义上是一样的，下面看看怎么使用吧package com.wytrait LoggedTrait { // 该方法为实现的具体方法，无参数时括号可以省略 def log = { println("记录日志……") }}class PersonForMixTrait(val name: String) { def sayHello = { println("Hi, I'm " + this.name) }}object

JAVA有自己的判断用关键字，Scala当然也不甘落后，Scala用的是方法，在Scala中会从顶级父类中继承两个方法，让我们看看怎么使用吧 //一个普通的对象 var a=new AAA //isInstanceOf用来判断一个对象是否可以转换成 [] 中的目标，返回值是一个布尔值 val bool: Boolean = a.isInstanceOf[AAAB] //asInstanceOf用来做时间的转换，常常用在isInstanceOf生效后 val aaab: AAAB =

Scala也是有继承的，同时它的继承可以实现多继承，因为Scala的底层除了objeck，其他的本质上都是类，而objeck是一个实例对象，没有需要继承怎么一说不过Scala在使用继承的时候有一些注意的事项，我们需要注意，下面给大家准备了一个例子package com.wy/*** 超类* Scala的成员变量需要有默认值，除非是抽象类，这点和JAVA不同*/class Extends_Animal { val aimaltype:String = "loweranimal" var

Scala有一个当初差点挤掉JAVA地位的东西，就是高阶方法，也叫高阶函数

在JAVA中有switch，scala有match，而且在应用上比JAVA的更加灵活，JAVA可以接收如下六种，如下1、int2、char3、byte4、short5、枚举6、 String JDK版本必须为1.7及以上版本

scala里面的抽象类还是比较常用的，比较上下线没有JAVA那么灵活，所以必要的时候用抽象类来写代码package com.wy//abstract 抽象类关键字abstract class Abstract_Person { var name1:String = _ //非抽象属性，不可以用null，你要给一个初值这里用下划线 var name2:String //抽象属性，没值 /** * 非抽象方法 */ def method1:Unit={ p

scala没有直接的break和continue关键字供我们使用，不过提供了Breaks类来完成这两个功能，下面我们看看怎么用把//此类需要实例化val breaks = new Breaksvar i:Int=1//要彻底中断一个循环就是breaks包裹循环breaks.breakable({ for(a <- array){ str.append(a.VN+":"+a.V+";") i+=1 if(i==5){ //生效时调用方法

Scala的伴生说的是如Array那样不用new就可以使用的类，下面个大家一个例子，希望可以帮到大家package com.wy/*伴生类和伴生对象类名要一样*/class Student(name:String){ //伴生类 override def toString = s"Student($name)"}object Student{//伴生对象 //核心方法，支持重载 def apply(name: String): Student = new Student(name

类似于JAVA语言，scala中也会自动补全一个空构造，但是有参构造在scala中分主、副的，只有在你没有写主构造，或者主构造为空构造时，才会补全package com.wy//不写主构造时自动补全一个空构造class Person{ var id:Int = 0 var name:String = null def printPerson(): Unit ={ println("printPerson被调用了！") } //辅助构造器 可以有多个 def th

object在scala中是个实例，它是一个单独存在的，它本质上是样例类的伴生对象，在其中写的方法可以被直接调用，比如：package com.wyobject A { def main(args: Array[String]): Unit = { B.printB() }}object B{ def printB(): Unit ={ println("B被调用了！") }}样例类其实就是被case修饰的一种类，它的底层其实是两个东西，一个叫伴生对象

package com.wyobject CollectionReview { def main(args: Array[String]): Unit = { val ints = List(1,3,2,5,2,4,4) //contains println(ints.contains(4))//true //distinct println(ints.distinct)//13254 //isEmpty println(ints.isEmpt

scala有一个使用很方便的数据类型叫做元组，元组的好处就是可以容纳的数据类型很多，和前端js中的数组一样，但是他是有长度限制的，最小是二元，最长大概是24左右package com.wyobject Tuple { def main(args: Array[String]): Unit = { //new Tuple2("","") //var t = (1, 3.14, "Fred") /*println(t._1) println(t._2) prin

下面是scala中set的基本操作，希望可以帮到大家package com.wyobject SetDemo { def main(args: Array[String]): Unit = { //不可变Set //var set1:Set[String] = Set("apple","orange") //set1 = set1+("banana") //添加元素 无序 /*set1 = set1+("pear") //添加元素 无序 set1 = se

下面是scala的map操作，希望可以帮到大家package com.wyobject MapDemo { def main(args: Array[String]): Unit = { //var colors = Map("red" -> 1, "blue" -> 2) //println(colors("red")) //打印1 //增 //colors = colors + ("yellow" -> 3) //改 //co

scala的for循环使用起来相当的灵活，大致分为如下几种使用方式package com.wyobject LoopTest { //1、循环条件 //2、循环体 //3、结束条件 //for while do……while //循环打印1到10 [1,10] //to [] //until [) def main(args: Array[String]): Unit = { var i:Int = 0 /*for(i <- args){

package com.wyimport scala.collection.mutable.ListBufferobject ListDemo { def main(args: Array[String]): Unit = { //不可变List: 长度不可变，内容不可变 var list: List[String] = List("Runoob", "Google", "Baidu") //val list2 = "Runoob" :: ("Google" :: ("

类似于JAVA的Scanner，Scala也有自己的输入类，使用也比JAVA的方便直接调方法就行 /** * 实现加减乘除 */ def caculate(): Unit ={ print("请输入第一个数：") var x = StdIn.readLine().toInt print("请输入第二个数：") var y = StdIn.readLine().toInt print("请输入操作符：") var operate = St

scala的if/else语句和其他的语言其实没太大的差别，写法一样package com.wyimport scala.io.StdInobject IFElseTest { def main(args: Array[String]): Unit = { var x = 30 //多分支 if( x == 10 ){ println("X 的值为 10") }else if( x == 20 ){ println("X 的值为 20")

package com.wyimport java.utilimport com.wy.JavaFormatValueobject CodingWithJava { def main(args: Array[String]): Unit = { //可以直接实例化JAVA类 var jo = new JavaFormatValue //JAVA的容器也可以直接使用 var list1 = new util.ArrayList[String]() list1.a

下边这个例子是给大家演示一下普通数组和可变数组的操作方式package com.wyobject ArrayDemo { def main(args: Array[String]): Unit = { //不可变数组 var array = Array("java","html","css") //查 println(array(1)) for(str <- array){ println(str) } //改

Scala的懒加载其实是用来做，调用时实例化的操作package com.wyobject LazyDemo { def main(args: Array[String]): Unit = { lazy val count = sum(10,20) println("==================") println(count) } def sum(a:Int,b:Int):Int={ println("sum被调用了！") a+b }

scala的方法返回值不需要一定写return，如果有特殊需要也可以写，否则一般情况下最后一行就是方法的返回值object Test { def sum(can:Int): Int ={ if(can==0){ return 0 }else{ return 1 } } def main(args: Array[String]): Unit = { println(sum(0)) } def sum1(a:Int,b:Int

scala提供了三种插词器s、f、war三种插词器的作用也不同object Test { def main(args: Array[String]): Unit = { var name:String = "小明" var height:Double = 1.92345 //s插词器常用在字符串中直接拼接值 println("学生的名字是"+name) println(s"学生的名字是${name}") //f插词器在s的基础上拥有对值格式

Scala没有JAVA的包装类一说，它的数据格式化相当方便，直接用方法就可以了，如下，其中方法没有括号，是因为scala的方法在没有参数的时候括号可以省略JAVA中的格式化package com.wy;/** * Created by wy on 2020/6/13. */public class JavaFormatValue{ public static void main(String[] args){ System.out.println(String.for