Scala简单入门1

一门语言想要精通应该很不容易，但是想要简单的掌握一些用法并拿来使用，应该不难，Scala和Java有许多共性，从Java的角度出发，来进入Scala，应该手到擒来。

配置Scala环境

这里我配置的是2.11.8版本的Scala
1、先是配置了本地的环境变量

2、在Settings->Plugins中安装了scala的插件

3、在Project Structure中的Libraries中添加进了SDK

Scala与Java的区别和共性

Scala特性

Scala可拓展
面向对象
函数式编程
兼容JAVA
类库调用
互操作
语法简洁
代码行短
类型推断
抽象控制
静态类型化（不能随便改变类型，var和val只能改变值）
可检验
安全重构
支持并发控制
强计算能力
自定义其他控制结构

区别（一些概念的区别）

Java中

Scala中非常兼容Java，这里我们简单定义一个Java类

public class Demo1Java {
    public void print(){
        System.out.println("打印java");
    }

    public static void main(String[] args) {
        Demo1Java demo1Java = new Demo1Java();
        demo1Java.print();//这是通过类的对象调用的方法

        Demo1Java.main(args);//这是通过类对象调用的方法

//        new Demo2Scala().print_scala();

        //Java中可以直接调用Scala中的类
        new Demo4ScalaStu().print();
    }
}

这里我们可以看到，在Java中，如果类中的一个方法不加上static的话，那它就只是一个普通的成员方法，必须通过类的对象调用，也就是下面这样：（这里面我们的print方法没有static修饰，只是一个简单的方法，调用的时候就需要创建一个类的对象来进行调用）

而只有static修饰的方法，才能通过类对象（类名）的方式直接调用，也就是下面这样：（因为Java中的main方法是由虚拟机调用的，也就是通过类对象这种方式调用的，类对象就是代码经过编译生成的.class字节码文件加载到内存的一个对象，主函数里面有一个static修饰，去掉static会报错，也就是说，主函数需要通过类对象的方式进行调用）

Scala中

Scala中的main方法只能放在object中运行，也就是说，object修饰的类相当于就是一个静态类，也就是相当于代码加载到虚拟机中的“类对象”，类中的方法和属性，相当于自动加上了static，可以直接通过“类对象”（类名）的方式直接调用，是一种单例模式

object Demo2Scala {
  val i = 10

  /**
    * Scala中的main方法
    * 在Scala中的方法不可以用static修饰
    *
    * def 定义一个函数的关键字
    * main 方法名
    * args: Array[String] 参数名：参数类型
    * Unit 返回值类型 相当于Java中的void
    * {} 方法体
    */

  def print_scala(): Unit ={
    print("scala")
  }

  def print_s: String ={
    val s = "S"
    return s
  }


  def main(args: Array[String]): Unit = {
    print("Hello World")
    Demo2Scala.print_scala()
    print(Demo2Scala.i)

  }
}

共性

Java中可以直接调用Scala中的类，并使用里面的方法

Scala中的类：

class Demo4ScalaStu {
  def print(): Unit ={
    println("Scala Stu")
  }
}

区别（一些使用的区别）

import java.io.{BufferedReader, FileReader}
import java.util

import scala.io.{BufferedSource, Source}

object Demo5ScalaBase {
  //scala的基本语法
  def main(args: Array[String]): Unit = {
    /**
      * 变量
      * 可以使用val 和 var 来定义变量，定义的时候不需要指定类型，但是最好指定类型
      * 用val修饰的变量，不能进行修饰，相当于常量
      * 用var修饰的变量，可以进行修改
      * 能使用val就使用val
      */
    val i = 100
    var j = 200
    j = 300
    println(i+1)//这样不算是修改变量

    //自动推断类型
    val k = 100
    //最好手动加上类型
    val kk : Int = 200
    //不知道是什么类型就使用object类型
    val k1 :Object = "100"
    println(k)
    println(kk)
    println(k1)


    //类型转换
    //Java中的类型转换
    val str1 = "123"
    println(Integer.parseInt(str1))
    //scala中的类型转换：只要数据符合要求，就可以直接to+类型
    val i1 = str1.toInt
    println(i1)


    //String类型
    //1.
    val str:String = "Hello,World"
    println(str.getClass.getSimpleName)
    val strings = str.split(",")
    strings.foreach(println) //这样就可以直接输出遍历了
    println(strings{0}) //这里输出需要用{}括号


    val str2:String = "abc"+"def"
    println(str2)
    //2.
    val builder: StringBuilder = new StringBuilder()
    builder.append("a")
    builder.append("bc")
    println(builder)
    //3.
    //可以通过 $变量名 在字符串中去变量的值 底层是StringBuilder
    val str3:String = "abc"
    val str4:String = "def"
    val str5:String = "hij"
    println(s"$str3,$str4,$str5")//前面用上s


    //文件读写
    //Java方式
    val br = new BufferedReader(new FileReader("data/students.txt"))
    var line:String = br.readLine()
    while (line!=null){
      println(line)
      line = br.readLine()
    }
    br.close()
    println("*" * 50)

    //scala读取文件
    val source: BufferedSource = Source.fromFile("data/students.txt")
    val iter: Iterator[String] = source.getLines() //返回一个迭代器，但是迭代器只能遍历一次
    //scala中的foreach
    for (elem <- iter) {
      println(elem)
    }
    println("*" * 50)

    //第一种简化
    for(elem<-Source
    .fromFile("data/students.txt")
    .getLines()){
      println(elem)
    }
    println("*" * 50)

    //第二种简化：链式调用
    Source
      .fromFile("data/students.txt")
      .getLines()
      .foreach(println)
    println("*" * 50)
  }
}

scala面向对象编程

构造方法

class Student(id:String,name:String,age:Int){
  println("默认的构造函数")
  //直接定义类的属性
  val _id:String = id
  val _name:String = name
  val _age:Int = age

}


object Demo6ScalaClass {
  def main(args: Array[String]): Unit = {
    val stu: Student = new Student("001","张三",21)
    println(stu._id)
    println(stu._name)
    println(stu._age)
  }
}

构造方法的重载

class Student(id:String,name:String,age:Int){
  println("默认的构造函数")
  //直接定义类的属性
  val _id:String = id
  val _name:String = name
  val _age:Int = age
  var _clazz:String = _


//  构造方法的重载 需要重新实现this方法
//  第一行代码必须调用默认的构造方法
  def this(id:String,name:String,age:Int,clazz:String){
    //调用默认的构造方法
    this(id,name,age)
    _clazz = clazz
  }

}


object Demo6ScalaClass {
  def main(args: Array[String]): Unit = {
    val stu: Student = new Student("001","张三",21)
    println(stu._id)
    println(stu._name)
    println(stu._age)

    val stu2:Student = new Student("002","李四",22,"文科一班")
    println(stu2._id)
    println(stu2._name)
    println(stu2._age)
    println(stu2._clazz)

  }
}

注意：
// 如果变量名以下划线开头 需要用花括号括起来
// 如果想调用变量的某个方法 也需要用花括号括起来
// return 可以省略 最后一行代码默认是返回的值

继承

class A(id:String,name:String){
  println("A的构造方法")
  //定义即赋值
  val _id:String = id
  val _name:String = name

  override def toString = s"A(${_id}, ${_name})"
}

/**
  * 继承还是使用extends关键字
  * 但是在继承的时候，需要调用父类的构造方法
  */
class B(id:String,name:String,age:Int) extends A(id,name){
  println("B中的构造方法")
  val _age:Int = age

  override def toString = s"B(${_id}, ${_name},${_age})"
}


object Demo7ScalaExtend {
  def main(args: Array[String]): Unit = {
    val b: A = new B("001","张三",21)
    println(b.toString)
  }

}

样例类

object Demo8CaseClass {
  def main(args: Array[String]): Unit = {
    //创建样例类对象的时候，new关键字可以省略
    val stu: Stu = Stu("001","张三",21,"男","文科一班")
    println(stu.id)
    println(stu.name)
    println(stu.age)
    println(stu.gender)
    println(stu.clazz)

    //样例类中的参数 就是该类的属性
    //默认是以val赋值的，如果想要修改，就需要手动修改成var
    stu.age = 22
    println(stu.age)
  }
}

/**
  * 样例类：会给每一个属性在编译的时候自动加上“get、set”方法，还会实现序列化接口
  */
case class Stu(id:String,name:String,var age:Int,gender:String,clazz:String)

感谢阅读，我是啊帅和和，一位大数据专业大四学生，祝你快乐。