Scala 的学习

337 0 0

作者:疯狂的IT

Scala

只是学习无基本理论

安装Scala

装前必须有jdk

windows安装

解压缩 D:dev/scala

配置环境变量

SCALA_HONE

path

cmd检查

Scala -version

直接输入Scala 控制台运行

idea安装与运行Scala

idea-->插件-->scala-->安装-->重启

新建maven项目

catalog-->maven

archetype-->

项目结构-->全局库-->添加Scala

添加应用支持-->scala
add开头

新建Scala类选择 object

scala 完全面向对象

scala风格与java风格

public class JavaDemo01 {
    public static void main(String[] args) {
        System.out.println("我爱你中国");
    }
}

javac JavaDemo01

object ScalaDemo01{
    def main(args: Array[String]): Unit = {
    print("我爱你中国")
  }
}

scalac ScalaDemo01

终端运行Scala

编码 utf-8

scalac 文件名字--> 生成文件名字$.class 与文件名字.class-->调用文件名字.class

Scala项目启动方式

main函数与extends app特质的区别：

App是scala语言内置的一个特质，使用它，则把对应object内部的整体作为scala main的一部分，有延迟启动的特性。

同时，命令行参数args也作为App特质的一部分，可以被开发者直接使用。而main函数则是scala的默认启动方式。

使用main函数

object ScalaDemo02{
    def main(args: Array[String]): Unit = {
    print("我爱你中国")
  }
}

使用App特质

object ScalaDemo03 extends App{
    print("我爱你中国")
}

object ScalaDemo04 extends App{
    print(args(0))
}

终端运行：

scalac ScalaDemo04.scala

scala ScalaDemo04 lhz

Scala代码与Java代码混用

object ScalaDemo05{
    def main(args: Array[String]): Unit = {
    System.out.println("我爱你中国")
  }
}

在 Scala 代码中可以直接使用 Java 代码

注意：main 方法使用Scala 风格

变量与常量

object ScalaDemo06{
    def main(args: Array[String]): Unit = {
    // var 变量 修饰符
        var a:Int = 10
    // val 常量 修饰符
    	val b:Int = 10
        
        a = 20
        println(a)
        /**
         *报错
         *reassignment to val
        */
        // b = 20
  }
}

字符串基本使用

object ScalaDemo07{
    def main(args: Array[String]): Unit = {
        var str01:String = "我爱你"
        var str02:String = "中国"
        // java 风格
        println (str01 + str02)
        // 插值方式 与 python 风格比较相像
        var slogan:String = "桃李不言下自成蹊"
        println(s"slogan >>> $slogan")
        
        println("""
        	|我爱你中国
        	|亲爱的母亲
        """.strpMargin)
  }
}

选择结构

object ScalaDemo08{
    def main(args: Array[String]): Unit = {
        var weekDay:Int = 1
        if (weekDay == 1){
            println("周一")
        }else if (weekDay == 2){
            println("周二")
        }else if (weekDay == 3){
            println("周三")
        }else if (weekDay == 4){
            println("周四")
        }else if (weekDay == 5){
            println("周五")
        }else if (weekDay == 6){
            println("周六")
        }else{
            println("周日")
  	}
  }
}

循环结构

object ScalaDemo09{
    def main(args: Array[String]): Unit = {
        var count:Int = 0
        while(count<5){
            println(count)
            count += 1
        }
  }
}

object ScalaDemo10{
    def main(args: Array[String]): Unit = {
        //Range 1 to 5
        println(1 to 5)
        println(1.to(5))
        println(1 until 5)
        println(1.until(5))
        
        // <- 赋值
        for (i <- 0 until 5){
            println(i)
        }
        println("--------------------^_ ~ _^----------------------")
        // 求偶数值
        for (i <- 0 until 10){
            if (i % 2 == 0){
                println(i)
            }
        }
        println("--------------^_ ~ _^----------------")
        for (i <- 0 until 10 if i % 2 == 0){
            println(i)
        }
        println("--------------^_ ~ _^----------------")
        for (i <- 0 until 10 by(2)){
            println(i)
        }
        println("--------------------^_ ~ _^----------------------")
        // 增强for循环
        var courses = Array("Hadoop","Hive","Sqoop","Flume","Hbase","Phoenix","Presto")
        for (course <- courses){
            println(course)
        }
  }
}

函数

无参数无返回值

object ScalaDemo01{
    def main(args: Array[String]): Unit = {
    	sayHi()
  }
    // def 函数定义关键字 
    // sayHI 函数名称
    // () 函数参数
    // ：后面的数据类型为返回值数据类型
    // : Unit 无返回值的数据类型占位符
    // {} 方法体
    private def sayHi(): Unit = {
      println("无参数 无返回值 函数 sayHi")  
    }
}

有参数无返回值

object ScalaDemo02{
    def main(args: Array[String]): Unit = {
   	 sayHi(msg = "hello word")
  }
    private def sayHi(msg:String): Unit = {
        println("有参数 无返回值 函数 sayHi")
        println(s"参数是 >>> ${msg}")
    }
}

默认参数无返回值

object ScalaDemo03{
    def main(args: Array[String]): Unit = {
    	sayHi()
        sayHi(msg = "hello")
  }
    private def sayHi(msg:String = "hi"): Unit = {
        println("默认参数 无返回值 函数 sayHi")
        println(s"参数是 >>> ${msg}")
    }
}

# 输出结果：
默认参数 无返回值 函数 sayHi
参数是 >>> hi
默认参数 无返回值 函数 sayHi
参数是 >>> hello

有参数有返回值

object ScalaDemo04{
    def main(args: Array[String]): Unit = {
    	println(sum(10,20))
  }
    def sum(a:Int , b:Int): Int ={
        // 函数的最后一行为返回值
        a+b
    }
}

可变参数无返回值

public class JavaDemo04{
     public static void main(String[] args) {

    }
    private static String
}

object ScalaDemo05{
    def main(args: Array[String]): Unit = {
    	println(format())
        println(format(numbers = 1))
        println(format(numbers = 1,2))
  }
    def format(numbers: Int*): String = {
        // var result:String = null
        var result:Int = 0
    	if(numbers.size > 0){
            for(number <- numbers){
                result += number
            }
        }
        result
    }
}

面向对象

类与对象

object ScalaDemo01{
    def main(args: Array[String]): Unit = {
   		val person = new Person01
        person.name = "lhz"
        println(person.name)
  }
    class Person01{
        // _ 代表着 占位符 占位
        var name:String = _
    }
}

封装

scala中属性、方法默认为public

private只在类的内部和伴生对象中可用

protected，同类、子类可以访问，同包无法访问

private[包名]，增加包访问权限，包名下的其他类也可以使用

Scala提供进一步的封装，“public”属性底层实际上都是private，访问时本质上是调用了xxx(get) 和 xxx_eq$(set) 方法，

但这里的方法名并不是getXXX和setXXX，由于一些Java框架会利用反射调用getXXX和setXXX，

因此Scala也提供了上面提到过的@BeanProperty注解去生成某属性的这两个方法，

但注意@BeanProperty不能加在private修饰的属性上，

可以理解为由于“public”本身就是private，将变量修饰为private然后再提供getter、setter方法比较冗余，Scala不推荐这样做。

// 假 封装
object ScalaDemo02{
    def main(args: Array[String]): Unit = {
   		val person = new Person02
        person.setName("lhz")
        println(person.getName)
        person.name = "lz"
        println(person.name)
  }
    class Person02{
        // _ 代表着 占位符 占位
        @BeanProperty
        var name:String = _
    }
}

// private 不推荐
// 手写 set get 方法
object ScalaDemo03 {
  def main(args: Array[String]): Unit = {
   val person = new Person03
   person.setName("lhz")
   println(person.getName)
  }
  class Person03{
    private var name: String = _

    def getName: String = {
      this.name
    }

    def setName(name: String): Unit ={
      this.name = name
    }
  }
}

java代码混用

public class Person04 {
    private String realName;

    public String getRealName() {
        return realName;
    }

    public void setRealName(String realName) {
        this.realName = realName;
    }
}

object ScalaDemo04 {
  def main(args: Array[String]): Unit = {
    val person = new Person04
    person.setRealName("李昊哲")
    println(person.getRealName)
  }
}

构造函数

object ScalaDemo05{
    def main(args: Array[String]): Unit = {
   		val person01 = new Person05("person01","220422198311222011")
    val person02 = new Person05("person02","220422198311222011",15311484567L)
    val person03 = new Person05("person02","220422198311222011","我爱你中国")
    val person04 = new Person05("person02","220422198311222011",15311484568L,"我爱你中国")
    println(person01)
    println(person02)
    println(person03)
    println(person04)
  }
}
    //主构造函数
class Person05(val realName:String, val idCard:String){
	println("Person05 主构造器 执行了")
    var mobile: Long= _
    var slogan: String= _
        
    // 辅助构函数 辅助构函数不能有类型注解
    def this(realName: String , idCard: String, mobile: Long)={
            // 辅助构函数 的 第一行代码必须调用 主构造函数 或者其他 辅助构函数
            this(realName,idCard)
            this.mobile = mobile
        }
        def this(realName: String , idCard: String, Slogan: String)={
            // 辅助构函数 的 第一行代码必须调用 主构造函数 或者其他 辅助构函数
            this(realName,idCard)
            this.slogan = slogan
        }
        def this(realName: String , idCard: String, mobile: Long, slogan: String)={
            // 辅助构函数 的 第一行代码必须调用 主构造函数 或者其他 辅助构函数
            this(realName,idCard,mobile)
            this.slogan = slogan
        }
    override def toString: String =
    this.getClass.getSimpleName +
      ", realName:" + realName +
      ", idCard:"+ idCard +
      ", mobile:" + mobile +
      ", slogan:"  + slogan

}

运行结果

Person05 主构造器 执行了
Person05 主构造器 执行了
Person05 主构造器 执行了
Person05 主构造器 执行了
Person05, realName:person01, idCard:220422198311222011, mobile:0, slogan:null
Person05, realName:person02, idCard:220422198311222011, mobile:15311484567, slogan:null
Person05, realName:person02, idCard:220422198311222011, mobile:0, slogan:我爱你中国
Person05, realName:person02, idCard:220422198311222011, mobile:15311484568, slogan:我爱你中国

继承

object ScalaDemo06 {
  def main(args: Array[String]): Unit = {
    val worker = new Worker("李昊哲", "15311484568", "架构师")
    println(worker)
  }
}

// 主构造函数
class Person06(val realName: String, val mobile: String) {

  println("Person06 主构造器 执行了")

  override def toString: String =
    this.getClass.getSimpleName +
      ", realName:" + realName +
      ", mobile:" + mobile
}

class Worker(realName: String, mobile: String, job: String) extends Person06(realName, mobile) {
  println("Worker 主构造器 执行了")

  override def toString: String =
    this.getClass.getSimpleName +
      ", realName:" + realName +
      ", mobile:" + mobile +
      ", job:" + job
}

抽象类

object ScalaDemo07 {
  def main(args: Array[String]): Unit = {
    val teacher = new Teacher
    teacher.realName = "李昊哲"
    teacher.mobile = "15311484568"
    println(teacher)
    teacher.hi()
  }
}

abstract class Person07() {

  println("Person07 主构造器 执行了")

  var realName: String
  var mobile: String

  def hi(): Unit

  override def toString: String =
    this.getClass.getSimpleName +
      ", realName:" + realName +
      ", mobile:" + mobile
}

class Teacher extends Person07 {
  println("Teacher 主构造器 执行了")

  override def toString: String =
    this.getClass.getSimpleName +
      ", realName:" + realName +
      ", mobile:" + mobile

  override var realName: String = _
  override var mobile: String = _

  override def hi(): Unit = {
    println("接着奏乐 接着舞")
  }
}

伴生类与伴生对象

scala中的类不能定义静态成员，而代之以定义单例对象来替代
单例对象通过object关键字来声明
单例对象中的所有方法，可以直接通过object单例对象的名字直接来调用。
一个单例对象可以绑定在一个类，当单例对象和某个类写在同一个源文件且共享一个名字，它们就产生了绑定关系。
此时单例对象称之为该类的伴生对象，类称之为该对象的伴生类。

类和它的伴生对象可以互相访问其私有成员
单例对象不能new，所以也没有构造参数
可以把单例对象当做java中可能会用到的静态方法工具类。
作为程序入口的方法必须是静态的，所以main方法必须处在一个单例对象中，而不能写在一个类中。

object ScalaDemo08 {
  def main(args: Array[String]): Unit = {
    Food.printMsg()
    new Food().printSlogan()
  }
}

class Food {
  private val msg: String = "hello"
  def printSlogan(): Unit = {
    println(Food.slogan)
  }
}

object Food {
  private val slogan: String = "桃李不言下自成蹊"
  def printMsg(): Unit = {
    println(new Food().msg)
  }
}

apply

object ScalaDemo09 {
  def main(args: Array[String]): Unit = {
    // Drink() 相当于 Drink.apply
    Drink()
    new Drink().apply()
  }
}

class Drink{
  def apply(): Unit = {
    println("class Food 执行...")
  }
}

object Drink {
  def apply(): Unit = {
    println("object Food 执行...")
  }
}

内容来源于网络如有侵权请私信删除

文章来源: 博客园

原文链接: https://www.cnblogs.com/dream-come-true/p/17389339.html

标签： Windows Windows操作系统 Win7

你还没有登录，请先登录或注册！

还没有人评论，欢迎说说您的想法！

Scala 的学习

Scala 的学习

Scala

安装Scala

windows安装

idea安装与运行Scala

scala风格与java风格

Scala项目启动方式

使用main函数

使用App特质

Scala代码与Java代码混用

变量与常量

字符串基本使用

选择结构

循环结构

函数

无参数 无返回值

有参数 无返回值

默认参数 无返回值

有参数 有返回值

可变参数 无返回值

面向对象

类与对象

封装

构造函数

继承

抽象类

伴生类与伴生对象

apply

热门标签

推荐文章

无参数无返回值

有参数无返回值

默认参数无返回值

有参数有返回值

可变参数无返回值