初识scala

1.变量

变量：var |var a=10  等价于var a:Int =10
常量：val |val b=20  等价于var b:Int =20
     asInstanceOf[T]  数据类型转换
     isInstanceOf[T]  判断是否是某种数据类型
默认值：
    scala> var a:Int=_
    a: Int = 0
 
    scala> var a:Double=_
    a: Double = 0.0
 
    scala> var a:String=_
    a: String = null
 
    scala> var a:Boolean=_
    a: Boolean = false

2.类型

Any:任何类的父类，Object类的子类
AnyRef:Any的子类，所有引用数据类型的超类
AnyVal:Any的子类，所有基本数据类型的超类
 
 
基本数据类型：
    九种基本数据类型中的八种与java一样，多一个Unit
    Scala中的Unit类型类似于java中的void，无返回值。主要的不同是在Scala中可以有一个Unit类型值，也就是（），
    然而java中是没有void类型的值的。除了这一点，Unit和void是等效的。
    一般来说每一个返回void的java方法对应一个返回Unit的Scala方法。

 
引用数据类型：
  Null:AnyRef的子类
    表示引用类型的值为空，但在scala中我们这种场景下通常不使用Null，使用Option
  None:Option类型的两个子类之一，另一个为some
  Nothing:所有类型的子类型，表示没有值。
    也表示程序异常终止。对于一个函数而言，如果返回值是Nothing，表明函数发生了异常。
  Nil:表示没有值的集合
 
注意：
    Scala的数据类型首字母大写
    示例：Int，Long，Float，Double……

3.类、对象、构造器

1、类和对象
类：
    由class声明，在类中书写非静态的变量、方法等。
    不含任何静态的代码。
对象：
    由object声明，在对象中书写静态的变量、方法等。
    不含任何非静态的代码。主方法在对象中声明。
    所有对象均单例。
 
#即使在类中声明main方法，该方法也是一个叫做main的普通方法
 
 
2、示例：
object MainTest {
  def main(args: Array[String]): Unit = { //主函数的固定写法
    val a=new Scala01()    //实例化
    print(a.min(1,2))    //调用类中的方法
  }
}
 
class Scala01 {
  def min(x:Int,y:Int):Int={
    if(x>y) y else x 
  }
}
 
备注：
    val的垃圾回收快于var
    实例化时，类中除了普通方法外，其他所有东西都会执行，因为这些东西相当于定义在构造器中
    1.类名 - 对于所有的类名的第一个字母要大写吗？
      是的 class MyFirstScalaClass
    2.方法名称 - 所有的方法名称的第一个字母用小写吗？
      是的 def myMethodName()
    
 
3、构造器
object MainTest {
 
  def main(args: Array[String]): Unit = {
    val a=new Scala01(1,2,3)
  }
}
 //主构造器
class Scala01(val x:Int,val y:Int) {
  var z:Int=_   //接收任意的Int类型数据
 //附属构造器
 //每个附属构造器第一个行必须调用主构造器或者其它附属构造器
  def this(x:Int,y:Int,z:Int){
    this(x,y) //必须
    this.z=z    //给全局变量赋值
    print(x+y+z)
  }
}
    
 
4、伴生类和伴生对象（重要）
 
A、名称相同的类和对象，类叫做对象的伴生类，对象叫做类的伴生对象
B、对象中的方法和属性（包括私有）可以直接在类中通过"类名.方法"调用
C、类中的方法和属性（包括私有）可以直接在对象中通过"对象名.方法"调用
 
 
5、apply方法
 

    创建对象不用new
 
class Scala01(x:Int,y:Int) {
 
}
object Scala01{//在这个伴生对象中重写apply方法创建对象就不要new了
  def apply(x: Int, y: Int): Scala01 = {//返回一个Scala01对象
    new Scala01(x, y) 
  }
}
 
object MainTest {
     /**
      * 类名() =》 Object apply
      * new出来的对象() class apply
      */
 
  def main(args: Array[String]): Unit = {
    val a=Scala01(1,2)    //创建对象不用new   object apply
    val test = new Scala01
    test()     //class apply new出来的
  }
}