《Scala 2》--IDE安装scala插件、伴生类和伴生对象、scala闭包、scala字符串、Scala数组、Scala迭代器、Scala类和对象、Scala继承、抽象类、模式匹配、异常、读写

it2022-05-06 2

IDE安装scala插件：

IDEA全称InteliJ IDEA,支持Java、Kotlin、Groovy、Scala等语言，能够实现智能编码。相比于Eclipse来说，界面UI更现代化，代码提示补充等功能更智能。

IntelliJ IDEA的在线注册码生成页面 http://idea.iteblog.com 新的License server地址为：http://idea.iteblog.com/key.php 激活服务器地址：http://47.104.86.228:8888

安装IDEA。安装Scala插件： a.选择【File】-->【Setting】-->【plugins】--> 选择scala，点击Install JetBrains Plugins.. 重新启动idea b.选择【File】-->【New-->project】 -->选择scala选项，并指定【IDEA】，next c.添加工程名，指定JDK版本，Scala SDK 找到Scala版本安装路径(create)，然后Finish； d.新建一个模块--> 选择【File】-->【new】-->【Module】-->【选择Scala】-->【Finish】

object HelloWord { def main(args: Array[String]): Unit = { System.out.println("Hello World!") } }

函数调用:

object T2 { def main(args: Array[String]): Unit = { println(add(1,2)) } def add(x:Int,y:Int): Int = { x + y ; } } def main(args: Array[String]): Unit = { //println(add()) //函数调用 println(add) //函数调用无参数时可以省略掉小括号 } //方法定义一条数据可以省略大括号 def add() = 1 + 2 //不写return 最后一行做为值返回 // def add(): Int = { // 1 + 2 // }

定义包有两种方法： 1、package com.ahu class HelloScala 2、package com.ahu{ class HelloScala }

1.创建Scala Class Object文件伴生类和伴生对象如果有一个class，还有一个与class同名的object 那么就称这个object是class的【伴生对象】，class是object的【伴生类】 scala中默认的主函数入口要在单例模式中（Object) 类的伴生对象可以访问类的私有变量 SingletonObject在伴生对象中可以访问伴生类的私有属性,SingletonObject111不可以访问

object SingletonObject111{ def main(args:Array[String]){ val s = new SingletonObject() //println(s.init) println(s.name) //s.hello() } } 伴生类SingletonObject object SingletonObject{ def main(args:Array[String]){ val s = new SingletonObject() println(s.init) println(s.name) s.hello() } } 伴生对象SingletonObject class SingletonObject{ private var init = 0; val name:String = "zhangsan"; private def hello(){ println("Hello, This is Singleton Object" + name) } } ========================================================================================= 例：伴生类<-->伴生对象，相互关系 package com.hyxy import scala.math._ class Circle(radius: Double) { private def area: Double=Circle.calculateAre(radius) } object Circle{ private def calculateAre(radius:Double):Double = Pi * pow(radius,2.0) def main(args:Array[String]){ val s = new Circle(5.0); println(s.area) } } object Circle111 { private def calculateAre(radius:Double):Double = Pi * pow(radius,2.0) def main(args:Array[String]){ val s = new Circle(5.0); // 其它类访问不了伴生类 //println(s.area) } }

Scala闭包：

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。例子：

object Test{ def main(args: Array[String]){ println("muliplier(1) value = " + muliplier(1)) println("muliplier(2) value = " + muliplier(2)) } var factor = 3 // 定义在函数外的自由变量 val muliplier = (i:Int) => i * factor // muliplier函数变量就是一个闭包 } 输出结果： muliplier(1) value = 3 muliplier(2) value = 6

--Scala字符串： Scala中可以创建两种字符串： 1)一种是不可修改的， 2)一种是可以修改的。 // 创建不可修改的字符串 val greeting:String = "Hello World!"; // 创建可以修改的字符串 var str:String = "wangyuan"

object Test{ def main(args: Array[String]){ val buf = new StringBuilder; buf += 'a' // 添加一个字符 buf ++= "bcdef" // 添加一个字符串 println(buf.toString); // 输出：abcdef } }

--字符串长度：xxx.length() --字符串连接：可以用concat()方法或者用 “+”

object Test { def main(args: Array[String]) { var str1 = "字符串1："; var str2 = "字符串2"; var str3 = "字符串3："; var str4 = "字符串4"; println( str1 + str2 ); // 字符串1：字符串2 println( str3.concat(str4) ); // 字符串3：字符串4 } }

--创建格式化字符串： String类中可以使用printf()方法来格式化字符串并输出。

object Test{ def main(args:Array[String]){ var floatVar = 12.456 var intVar = 2000 var stringVar = "字符串变量" printf("浮点型变量为 %f ," +"整形变量为 %d," + 字符串为 %s " ,floatVar, intVar, stringVar) } }

--Scala数组： 1.声明数组 var z:Array[String] = new Array[String](3) 或者 var z = new Array[String]() z(0) = "value1"; z(1) = "value2"; z(2) = "value3" 或者 var z = Array("value1", "value2", "value3") 2、处理数组：

object Test{ def main(args: Array[String]){ var myList = Array(1.1, 2.2, 3.3, 4.4) // 输出所有数组元素 for(x <- myList){ println(x) } // 计算数组所有元素的总和 var total = 0.0 for(i <- 0 to (myList.length - 1)){ total += myList(i) } println("总和：" + total) // 查找数组中的最大元素 var max = myList(0) for(i <- 1 to (myList.length - 1)){ if(myList(i) > max) max = myList(i) } println("最大值：" + max) } }

3、多维数组：

定义空数组 import Array._ scala> Array.ofDim[String](1) res0: Array[String] = Array(null)

scala> Array.ofDim[Double](1) res1: Array[Double] = Array(0.0)

scala> Array.ofDim[Int](10) res2: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

scala> Array.ofDim[Boolean](1) res3: Array[Boolean] = Array(false)

scala> Array.ofDim[Float](1) res4: Array[Float] = Array(0.0)

import Array._ object Test{ def main(args: Array[String]){ // 定义数组 var myMatrix = ofDim[Int](3,3) // 创建矩阵 for(i <- 0 to 2){ for(j <- 0 to 2){ myMatrix(i)(j) = j; } } // 打印矩阵 for(i <- 0 to 2){ for(j <- 0 to 2){ print(" " + myMatrix(i)(j)); } println(); } } }

4、合并数组：

import Array._ object Test{ def main(args: Array[String]){ var myList1 = Array(1.1, 2.2, 3.3, 4.4) var myList2 = Array(5.5, 6.6, 7.7, 8.8) // 使用concat()合并 var myList3 = concat(myList1, myList2) // 输出所有数组元素 for(x <- myList3){ println(x) } } }

5、创建区间数组: 使用range(x,y,z)创建区间数组,数值范围大于等于x,小于y。z表示步长?

import Array._ object Test{ def main(args: Array[String]){ var myList1 = range(10, 20, 2) var myList2 = range(10, 20) for(x <- myList1){ print(" " + x) //输出：10 12 14 16 18 } println() for(x <- myList2){ print(" " + x) // 输出：10 11 12 13 14 15 16 17 18 19 } } }

6. /** Scala迭代器： * 迭代器不是一个集合，而是一个用于访问集合的方法。 * **/

object Test{ def main(args: Array[String]): Unit = { val it = Iterator("one", "two", "three", "four") while(it.hasNext){ // 检测集合中是否还有元素 println(it.next()) // 返回迭代器的下一个元素，并更新迭代器的状态 } val ita = Iterator(1, 2, 3, 4, 5) val itb = Iterator(11, 22, 33, 44, 55) println(ita.max) // 查找最大元素 println(itb.min) // 查找最小元素 } }

7. /** * Scala类和对象： * 类是对象的抽象，对象是类的具体实例。 * 类是抽象的，不占用内存；对象是类的具体实例，占用存储空间。 * */

class Person(val name:String,val age:Int) { println("Person:"+name+","+age) } object mainTest{ def main(args: Array[String]): Unit = { val s = new Person("zhangsan",12); println(s.name) println(s.age) } }

8.类的继承：

class ArrayElement(conts: Array[String]) extends Element { def contents: Array[String] = conts }

定义 ArrayElement 为 Element 的子类类 ArrayElement 定义为扩展了类 Element 。就好象 Java 里，你在类名之后使用 extends 子句那样： ... extends Element ... 这种 extends 子句有两个效果：

1）使类 ArrayElement 从类 Element 继承所有非私有的成员， 2）并且使 ArrayElement 成为 Element 的子类型。由于 ArrayElement 扩展了 Element ，类 ArrayElement被称为类 Element 的子类。反过来， Element 是 ArrayElement 的超类。如果你省略 extends 子句，Scala 编译器隐式地假设你的类扩展自 scala.AnyRef ，在 Java 平台上与 java.lang.Object 一致。因此，类 Element 隐式地扩展了类 AnyRef 。 /** * Scala继承：跟Java差不多。 * 1、重写一个非抽象方法必须使用override修饰符 * 2、只有主构造函数才可以往基类的构造函数里写参数 * 3、在子类中重写超类的抽象方法时，不需要使用override * 4、子类继承父类时，类参数需要定义val ,否则外部类不能使用此属性 */

class Person(val name:String,val age:Int) { println("Person:"+name+","+age) } //定义val class student(name:String,override val age:Int,val sex:String) extends Person(name,age) { println("Student:"+name+","+age+","+sex) } object mainTest{ def main(args: Array[String]): Unit = { val s = new student("zhangsan",12,"女"); println(s.name) println(s.age) println(s.sex) //val sex:String 父类中没有定义的属性子类需要定义val ,否则外部类不能使用此属性 } }

方法的重写，覆盖:

class Person(val name:String,val age:Int) { def hello (): Unit = { println(" Person hello !") } } //定义val class student(name:String,override val age:Int,val sex:String) extends Person(name,age) { override def hello (): Unit = { println("student hello !") } } object mainTest{ def main(args: Array[String]): Unit = { val s = new student("zhangsan",12,"女"); s.hello() } }

抽象类：在子类中重写超类的抽象方法时，不需要使用override

abstract class Person { var name:String val age :Int def speak def hello (): Unit = { println(" Person hello !") } } class student() extends Person() { var name: String = "zhangsan" val age: Int = 15 def speak: Unit={ println ("hello ") } //重写hello () override def hello (): Unit = { println(" student hello !") } } object mainTest{ def main(args: Array[String]): Unit = { //val p = new Person() 不允许实例化抽象类 val s = new student() s.name="张三" s.speak //子类重写抽象方法 s.hello() //父抽象类中具体实现方法 println(s.name) println(s.age) } }

case class: 不需要new对象，直接可以用一般用于模式匹配中

case class student() { var name: String = "zhangsan" val age: Int = 15 def speeak(): Unit={ println ("hello 123") } } object mainTest{ def main(args: Array[String]): Unit = { student().speeak() println(student().name) println(student().age) } }

/** * Scala异常处理： scala没有检查型异常，不用抛出声明语句 * 和Java类似。在Scala中借用了模式匹配的方法来在catch语句块中来进行异常匹配。 */ /*

object Test12 { def main(args: Array[String]): Unit = { try { val i = 10/0 println(i) } catch { case e: ArithmeticException=>println("除数不能为0...") case e: Exception => println(e.getMessage) } finally { println("释放资源...") } } } import java.io.{FileNotFoundException, FileReader, IOException} object Test{ def main(args: Array[String]): Unit = { try { val f = new FileReader("input.txt") }catch { case ex: FileNotFoundException => { println("Missing file exception") } case ex: IOException => { println("IO Exception") } }finally { println("Exiting finally...") } } }

//scala写文件：

import java.io._ object Test { def main(args: Array[String]) { val writer = new PrintWriter(new File("test.txt" )) writer.write("Scala语言") writer.close() } }

// 从文件上读取内容：

import scala.io.Source object Test { def main(args: Array[String]) { println("文件内容为:" ) Source.fromFile("test.txt" ).foreach{ print } } } import scala.io._ object Test12 { def main(args: Array[String]): Unit = { print("请从键盘输入内容 : " ) val line = StdIn.readLine() import java.io._ val writer = new PrintWriter(new File("test.txt" )) writer.write("输入内容" +line) writer.close() } }

Scala基本类型说明编程70 ----------------------------------------------------------------------------------------------------- 1.scala2.10版本以上将不采用八进制对整数赋值；支持十进制和十六进制(0x或0X) scala> val oct = 035 // （八进制35是十进制29）不采用八进制对整数赋值 0放在前面不识别 oct: Int = 29

2.浮点数文本是由十进制数字，可选的小数点和可选的E或e及指数部分组成的

专利

最新回复(0)