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

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 T