scala介绍以及使用方法和案例类型

• 为什么要学习scala:为了后面要学习的spark,因为spark的源码是scala

scala是一门计算机语言,C++,C#,PHP,Java,python等,至少学两门语言,会发现,好多都是相通的;
相同点:编程的思路是一样的
不同点:语法规则不一样;
scala是在java基础进行了一次封装;

• scala的优点

语法更简洁;能省代码则省代码;好处:装逼,坏处:可读性差;
函数式编程:方法的五要素;方法的参数是基本数据类型和引用类型,方法的参数是接口,目标就是想执行接口中的某一个方法;方法的参数可以是方法;(JavaScript)

scala官网:https://www.scala-lang.org/
想开发scala,需要先下载jdk(java),下载器scala的编译器,(Eclipse的插件已经集成了);但是官网推荐的IDE,idea;
在线帮助手册:https://docs.scala-lang.org/
快速开始:https://docs.scala-lang.org/getting-started.html
scala之旅:手册:https://docs.scala-lang.org/tour/tour-of-scala.html

**

-Scala是什么？

**
Scala是一门现代的多范式语言，志在以简洁、优雅及类型安全的方式来表达常用的编程模型。它平滑地集成了面向对象和函数式语言的特性。
Scala是面向对象的
鉴于一切值都是对象，可以说Scala是一门纯面向对象的语言。对象的类型和行为是由类和特质来描述的。类可以由子类化和一种灵活的、基于mixin的组合机制（它可作为多重继承的简单替代方案）来扩展。
Scala是函数式的
鉴于一切函数都是值，又可以说Scala是一门 式语言。Scala为定义匿名函数提供了轻量级的语法，支持高阶函数，允许函数嵌套及柯里化。Scala的样例类和内置支持的模式匹配代数模型在许多函数式编程语言中都被使用。对于那些并非类的成员函数，单例对象提供了便捷的方式去组织它们。
此外，通过对提取器的一般扩展，Scala的模式匹配概念使用了right-ignoring序列模式，自然地延伸到XML数据的处理。其中，for表达式对于构建查询很有用。这些特性使得Scala成为开发web服务等程序的理想选择。
Scala是静态类型]0的
Scala配备了一个拥有强大表达能力的类型系统，它可以静态地强制以安全、一致的方式使用抽象。典型来说，这个类型系统支持：
泛型类
型变注解
上、下类型边界
作为对象成员的内部类和抽象类型
复合类型
显式类型的自我引用
隐式参数和隐式转化
多态方法
类型推断让用户不需要标明额外的类型信息。这些特性结合起来为安全可重用的编程抽象以及类型安全的扩展提供了强大的基础。(声明变量的时候不需要指定类型,弱类型语言—javascript,函数编程)
Scala是可扩展的
在实践中，特定领域应用的发展往往需要特定领域的语言扩展。Scala提供了一种语言机制的独特组合方式，使得可以方便地以库(librar–jar包)的形式添加新的语言结构。
很多场景下，这些扩展可以不通过类似宏（macros）的元编程工具完成。例如：
隐式类允许给已有的类型添加扩展方法。
字符串插值可以让用户使用自定义的插值器进行扩展。
Scala的互操作性
Scala设计的目标是与流行的Java运行环境（JRE）进行良好的互操作，特别是与主流的面向对象编程语言——Java的互操作尽可能的平滑。Java的最新特性如函数接口（SAMs）、lambda(入)表达式、注解及泛型类在Scala中都有类似的实现。
另外有些Java中并没有的特性，如缺省参数值和带名字的参数等，也是尽可能地向Java靠拢。Scala拥有类似Java的编译模型（独立编译、动态类加载），且允许使用已有的成千上万的高质量类库。

• 在线编程
• 可以在浏览器上使用ScalaFiddle运行Scala。
  打开https://scalafiddle.io；
  在左侧窗格中粘贴println(“Hello, world!”)；
  点击”Run”按钮，输出将展现在右侧窗格中。
  这是一种简单的、零设置的方法来实践Scala的代码片段。
  
  
• .类型
• java中都有哪些类型;基本数据类型和引用类型

Any是所有类型的超类型，也称为顶级类 型。它定义了一些通用的方法如equals、hashCode和toString。Any有两个直接子类：AnyVal和AnyRef。(Object)
AnyVal代表值类型。有9个预定义的非空的值类型分别是：Double、Float、Long、Int、Short、Byte、Char、Unit和Boolean。Unit是不带任何意义的值类型，它仅有一个实例可以像这样声明：()。所有的函数必须有返回，所以说有时候Unit也是有用的返回类型。(基本数据类型)
AnyRef代表引用类型。所有非值类型都被定义为引用类型。在Scala中，每个用户自定义的类型都是AnyRef的子类型。如果Scala被应用在Java的运行环境中，AnyRef相当于java.lang.Object。

• 转型

• Nothing和Null

Nothing是所有类型的子类型，也称为底部类型。没有一个值是Nothing类型的。它的用途之一是给出非正常终止的信号，如抛出异常、程序退出或者一个无限循环（可以理解为它是一个不对值进行定义的表达式的类型，或者是一个不能正常返回的方法）。
Null是所有引用类型的子类型（即AnyRef的任意子类型）。它有一个单例值由关键字null所定义。Null主要是使得Scala满足和其他JVM语言的互操作性，但是几乎不应该在Scala代码中使用。我们将在后面的章节中介绍null的替代方案。

• Eclipse+scala插件集成好的:http://scala-ide.org/index.html

推荐自己下载一下eclipse,然后将插件挺插到eclipse上(这个可以安装其它插件,使用最新的Eclipse)
插件网址:https://marketplace.eclipse.org/content/scala-ide

• 创建scala项目
  
  
  
  
  
  
• 代码

/**

• 包,包要手动创建,因为它不提示
• scala package object
  */
  package com.jinghangzz.scala.test

/**

• 第一个例子,也叫helloworld
  /
  object HelloWorld {
  /*

  • scala的一个main方法
  • def:固定的,修饰符
  • main:方法名
  • args:方法的参数
  • :固定的
  • Unit:返回值;–void
  • 提示的快捷键:alt+/
    /
    def main(args: Array[String]): Unit = {
    / 打印一句话 /
    System.out.println("-------南宋中兴四将-----");
    / ----------------------表达式---------------------- /
    / 直接print;System.out也省了 */
    println("====" + 1 + 1 );
    /* ----------------------常量---------------------- /
    / java=final;
    • 常量赋值是木有类型,弱类型语言,可以推荐出类型 /
      val val1 = 1 + 1 ;
      println("=val1=" + val1);
      / 常量赋值不可以修改 /
      //val1 = 3 ;
      / 可以指定类型;指定类型为Int /
      val val2:Int = 2 + 2 ;
      / ----------------------变量---------------------- /
      / 变量的值可以不停的变 /
      var var1 = 1 + 1 ;
      println("–var1–>" + var1) ;
      var1 = 3232;
      / 指定类型 */
      var var2:String = “abc” ;

  /* ----------------------表达式---------------------- /
  println({
  var var3: Int = 4 + 5 ;
  / return也可以省掉 */
  var3 ;
  });

}
}

**

• 方法—函数

**

代码

package com.jinghangzz.scala.test

/**

• Hw

• 对象是它们自己定义的单实例，你可以把它看作它自己的类的单例。(在整个JVM中,只能有一个对象);

• 在scala中,每一行的;可以省略
  /
  object FunctionTest {
  /*

  • 两个参数相加
  • 这是一个方法
  • 如果方法体只有一行,大括号可以省略
    /
    def add(a :Int , b:Int) : Int =
    {
    / 这是常量 */
    val c: Int = a + b ;

  var fun1 = (x :Int) => x + 1 ;

  return c ;
  }

/**

• 匿名函数;指的是=的左边木有名字;
• fun1:木有指定类型,是function类型
• fun2:也木有指定类型, 是int类型
• 函数的位置:
• 在java里面只能放到最外面的大括号中(类的方法);方法里面套方法;方法写到第二层大括号里面;
• 在scala中,方法的定义位置随便写;
• 这是一个函数
  */
  var fun1 = (x :Int) => x + 1 ;

/**

• 一个方法可以有多个参数列表
• 此知识点在java里面叫重载
  */
  def function1(x: Int,y: Int)(z: Int) =
  {
  println(x + “function1=” + y + “—function1–” + z);
  }

/**

• main方法
  */
  def main(args: Array[String]): Unit =
  {
  println(“明太祖—洪武帝----朱元璋”);

/* 调用方法 */
var addC = add(3, 5);
println("--add--" + addC);
/* 调用方法的时候,拿变量接收了 */
addC = 10 ; 

 var fun1 = (x :Int) => x + 1 ;
 /* 调用方法 */
 var fun2: Int = fun1(5) ; 
 
 /* 调用方法,有多个参数列表 */
 function1(4,5)(6);
 
 /* new了一个引用类型的变量 */
 var p1: Person = new Person(1,"aa");
 p1.say() ; 
 
 /* new了一个引用类型的变量 */
 var p2: Person = new Person(2,"bb");
 p2.say() ; 
 
 /* object不能new */
 //var f1:FunctionTest = new FunctionTest();
 
 /*------样例类比较--------*/
 var point1 = Point(1,2);
 var point2 = Point(1,2);
 var point3 = Point(2,2);
 
 /* 引用类型的比较 */
 println("==样例类==" + (point1 == point2));
 println("==样例类==" + (point1 == point3));
 
 /*------对象,--------*/
 /* object不能new ,直接调用方法
  * 如果方法的定义处和使用处在一个object里面,object.(可以省略)
  * */
 var addI = FunctionTest.add(3, 2);
 println("==FunctionTest.add==" + addI);
 add(3, 2);

}
}

/**

• 声明一个类,
• 声明类的时候可以直接跟上构造函数参数列表
  /
  class Person(id: Int,name: String)
  {
  /*
  • 定义了一个方法,此方法是无参数,无返回值
    */
    def say() : Unit=
    {
    println(id + “–Person–say->” + this.name);
    }
    }

/**

• 这是一个样例类,可用作值比较
  */
  case class Point(x: Int , y: Int)
  {

}

/**
特质trait===Interface
*/
trait Animal
{
//void say();
def say() : Unit
}

**

• 类

**
代码
package com.jinghangzz.scala.test

/**

• 类的测试
  /
  object ClassTest {
  /*

  • 这是main方法
    /
    def main(args: Array[String]): Unit =
    {
    / new一个对象 */
    var stu: Student = new Student(4,“aa”);
    println(“toString” + stu);

  /* 在调用的时候,直接将那一个不传也行 */
  var stu1: Student = new Student;
  println(“toString” + stu1);

  /* 前面的可以填写,后面的能忽略;

  • 填写了第二个参数,想忽略第一个参数,这不中
  • */
    var stu2: Student = new Student(4);
    println(“toString” + stu2);

  /* 这一节课就中了 */
  var stu3: Student = new Student(id=5,name=“cc”);
  println(“toString” + stu3);

  /* 如果只想为第二个参数赋值,第一个忽略,使用默认值,

  • 在赋值的时候要写上:名字=值; */
    var stu5: Student = new Student(name=“dd”);
    println(“toString” + stu5);

  /* 这是set方法 */
  stu5.id_=(150);

  /* 这是get方法 */
  println(“stu5.id=” + stu5.id)
  println(“stu5.name=” + stu5.name)
  }
  }

/**

• 这是一个类,方法的参数列表,可以填写上默认值
  */
  class Student(id: Int = 100,name: String=“aaa”)
  {
  private var _id = 0 ;
  private var _name = null;

/**

• get方法
  */
  def id(): Int =
  {
  this._id ;
  }

/* get方法,简写 */
def name = _name ;

/**

• 这是set方法
  */
  def id_=(newValue: Int) :Unit =
  {
  _id = newValue ;
  }

/def name_=(newValue: String) :Unit =
{
_name = newValue ;
}/

/**

• 重写父类的方法
  /
  override def toString(): String =
  {
  / s $属性;叫做占位符 */ this.id + "--->" + this.name + "=====>" + s"$id—"+ this.id+ s"–$name";
  }
  }

**

• 元组

**
代码

package com.jinghangzz.scala.test

/**

• 元组的测试类
  /
  object TupleTest {
  /*

  • main方法
    */
    def main(args: Array[String]): Unit =
    {
    println(“明惠帝----建文帝—朱允文”);

  /* 元组

  • 键是String,值是Int;
  • List:这是一个集合,每一个元素都是一个;
  • Map:这是一个集合,每一个元素都是两个;
  • Tuple22:这是一个集合,每一个元素都是22个;
  • 这是一个集合,每一个元素都是100个;List,List<List>;一维数组,二维数组,三维数组
  • /
    var map = (“a”,10):Tuple2[String,Int];
    / toString:(a,10) */
    println(“toString>” + map)

  /* 取第几个元素 */
  println(“取第n个元素” + map._1);
  println(“取第n个元素” + map._2);

  /* 解构元组:解析;起别名 */
  var (name,num) = map;
  println("=map=name==" + name);
  println("=map=num==" + num);

  /* 写一个容器,new了一个List,并且,List里面有5个元素 /
  var lists = List(1,2,3,4,5);
  / List是官方提供的

  • forEach此方法的参数也是一个方法;
  • java的方法参数只能是类型(基本数据类型和引用类型,从来木有听说过参数还可以是方法)
  • scala此方法的参数还是方法(需要我们自己定义);
  • 自己定义的方法为什么要写Int,因为List里面放的是Int
  • */
    var method1 = (e:Any) =>
    {
    println(“循环” + e);
    };
    lists.foreach(method1);

  /* 在java中增强for循环如何写 /
  /for(Integer temp : lists)
  {
  System.out.println(temp) ;
  }/
  /

  • scala的增强for循环,把:换成了<-
  • */
    for(temp <- lists)
    {
    println("–增加for循环–" + temp) ;
    }

  /* 合二为一;复习一下,当年我们讲的lambda表达式

  • 方法的参数类型系统会自动判断
  • 如果方法的参数只有一个,小括号也可以省略
  • 如果方法体只有一行,大括号可以省略
  • */
    lists.foreach(e => println(“循环222” + e));

  /* 就是List里面放的是元组

  • 第一个元组是四个元素;
  • java的写法;List<List;List规定是4个;
  • List<Map<String,Object>>;可以放四个键值对
  • /
    var list2 = List( (“a”,20,“90.1”,“90.2”) , (“b”,30,“98.1”,“92.2”) , (“c”,21,“95.1”,“87.2”) );
    / 循环List
  • 循环List,参数是一个方法
  • 只想取第三列,下标值从1开始
  • 想知道tuple的4列分别是什么意思;起别名
  • /
    list2.foreach( tuple =>
    {
    println(“循环List" + tuple + ">” + tuple._3)
    / 为tuple起别名 */
    var (name,age,chinses,math) = tuple ;
    println(name + “–起别名–” + age ) ;
    });

  /*

  • List循环tuple,同时解析Tuple
  • */
    for((name,age,chinses,math) <- list2)
    {
    println(name + “–起别名–” + age ) ;
    }
    }
    }