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

it2022-05-06  1

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)