JAVA和Scala的语法对比

目录

原创作品,转载请表明出处
近期,学习了scala这门语言。老师交给我们一个任务，对比scala和java的差别，我就整理了一下两者语法方面的区别。和各位一起分享，如果你感觉有帮助，那就点着赞，收藏一下吧！

类的定义

java中如何运行一个程序呢?

我们来看java如何输出HelloWorld:

public class TestDemo {//类名
    public static void main(String[] args) {//主函数
        System.out.println("Java Says Hello Word!");//打印语句
    }
}

接下来我们看看Scala:

object HelloWorld {//类名,和java不同的是,scala采用object修饰
  def main(args: Array[String]): Unit = {//Scala中def用来定义函数
    println("Scala says Hello World!")//可以看出,scala中无需;来进行结尾
  }
}

object HelloWorld extends App {//scala的另一种运行程序的方式
  println("Scala says Hello World!")
}

那么scala中这两个方法有什么区别呢?（此处回答引用了他人博客的讲解）

App是scala语言内置的一个特质，使用它，则把对应object内部的整体作为scala main的一部分，有延迟启动的特性。同时，命令行参数args也作为App特质的一部分，可以被开发者直接使用。而main函数则是scala的默认启动方式。

参数定义以及打印

java中怎么输出参数呢?

public class canshu {
    public static void main(String[] args) {
        int a=10;//整型
        short sh=2;
        byte b=0;
        long l=20200311;
        double dou=3.14;//浮点型
        float f=5.21F;
        char ch='j';//字符型
        boolean boo=true;//逻辑型
        System.out.println(a);//输出后换行
        System.out.println(sh);
        System.out.println(b);
        System.out.println(l);
        System.out.printf("%.1f\n%f\n",f,dou);//类似C语言,方便取小数位数
        System.out.println(ch);
        System.out.print(boo);//输出后不换行
    }
}

对比一下Scala:

object canshu {
  def main(args: Array[String]): Unit = {
    var a:Int = 520//scala中var和val用来申请变量,可以指定数据类型
    val b:Byte =1//scala基本数据类型和java一致,但是多了一个unit
    val scala ="hello scala"//scala可以自己判定数据类型
    var temp = 's'
    printf("%d\n",a)//类似C语言,按照类型输出
    println(s"$b")//插值法类似于PHP
    println(temp)
    temp = 'b'//给temp赋值,若temp为val修饰,则不可以改变赋值
    print(temp)
    /**
     * 多行字符串
     */
    val str=
      """
        |此处,|的作用是提示你用了换行符,并且有对齐线的效果
   3个"的作用时把里面包裹的东西
                          去掉|的话,就会原封不动的打印出来
        |             7个tab    4个空格????
        |                            28个空格  1个tab...
        |!!!!!!
        |""".stripMargin//如果带.stripMargin的话,按照|对齐
    println(str)
    println(str)
    val  - =3//于java不同的是,scala中运算符也是一个对象,可以用来当作变量名
    println(-)
  }
}

运算符

我们来看一下java的运算符

public class YunSuan {
    public static void main(String[] args) {
        int res1 =5+6;
        int res2 =6-5;
        double res3=3.1*4;
        int res4=10/3;//自动取整
        int res5=20%3;
        boolean flag=res1>res2?true:false;//于scala不同的是,java支持三目运算
        System.out.println(res1);
        System.out.println(res2);
        System.out.println(res3);
        System.out.println(res4);
        System.out.println(res5);
        System.out.println(flag);
    }
}

对比一下Scala

object YunSuan {
  def main(args: Array[String]): Unit = {
    val res1=5+6
    val res2=6-1
    val res3=6*1
    val res4=6/1
    val res5=6%4//自动取整
    val flag=if (res1<res2) true else false //scala没有三目运算,但是可以借助if和else语句实现
    /*上面的赋值体现出来scala可以讲一个函数语句赋值给变量*/
    println(res1)
    println(res2)
    println(res3)
    println(res4)
    println(res5)
    println(flag)
  }
}

程序控制

顺序结构就是一步一步执行

直接看java的分支结构和循环结构

import java.io.PrintStream;

public class ChengXuKongZhi {
    public static void main(String[] args) {
        /*单分支*/
        int a =60;
        if(a>59){
            System.out.println("及格");
        }else{
            System.out.println("你完蛋了");
        }
        /*多分支-方法一*/
        int b=80;
        if (b>79){
            System.out.println("你真秀");
        }else if (b>59 && b<80){
            System.out.println("中庸之才");
        }else{
            System.out.println("你真垃圾,不过我们都有美好的未来");
        }
        /*多分支-方法二*/
        int bi = 2;
        switch (bi){
            case 1:
                System.out.println("正面");
                break;
            case -1:
                System.out.println("反面");
                break;
            case 0:
                System.out.println("百年一遇");
                break;
            default:
                System.out.println("天神降临?");
                break;
        }
        /*循环-方法一*/
        for (int i = 0; i < 3; i++) {
            System.out.println(i);
        }
        /*循环-方法二*/
        int i=0;
        while (i<3){
            System.out.println(i);
            ++i;
        }
        /*循环-方法三*/
        i=0;
        do {
            System.out.println(i);
            ++i;
        }while (i<3);
    }
}

---------------分割线2020-03-11,未完待续.--------------

来看看Scala的程序控制.

object ChengXuKongZhi {
  def main(args: Array[String]): Unit = {
    /**
     * scala中,顺序和分支和java基本相同.我在此不再演示.来看看scala中的循环
     * scala中的循环主要是for循环,相比java.功能更加强大,称为for循环表达式
     */
    /*to的应用*/
    for (i <- 1 to 10){
      print(i+" ")//会从一输出到10
    }
    /*until的应用*/
    for(x <- 1 until(10)){
      print(s"$x"+" ")//会从一输出到9,左闭右开
    }
    /*Range的应用*/
    /*scala中表达式可以用{}包围,也可以用()包围,Range是左闭右开的,而且可以指定步长值*/
    for {x <- Range(1,10,3)}{
      print("\n"+x+" ")
    }
    //循环守卫,相当于增加条件来控制循环进行.类似于java的continue
    for {a <- 1 to 10 if a%2==0}{
      print(a+" ")//求[1,10]中的偶数
    }
    /*因为Scala强大的for循环表达式,所以有些复杂的循环在scala中就变得非常简单*/
    //Scala中还可以将for循环的结果赋值给变量,配合yield使用效果绝佳
    // (for循环中的 yield 会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。)
    val res= for{temp <- 1 to 6} yield temp*2
    print(res)//打印[1,6]的二倍
  }
}

函数与方法

从C语言开始我们就开始接触函数了.java中更是大量使用函数给对象增加一些神奇操作.

public class Function {
    public static void main(String[] args) {
        PrintStr();//无参返回
        boolean res1= false;
        ISRight(res1);//有参数,无返回
        String str="start";
        String ResStr=RunJava(str);//有参数,有返回值
        System.out.println(ResStr);
    }

    private static String RunJava(String str) {
        return str+"\trunning \tover!";
    }

    private static void ISRight(boolean res1) {
        if (res1==true){
            System.out.println("That is True");
        }else{
            System.out.println("That is False");
        }
    }
    private static void PrintStr() {
        System.out.println("Java is So Cool!");
    }
}

scala和java相比,函数/方法的功能更加强大。种类更多

import scala.util.Random

object Function {
  //Scala 中使用 val 语句可以定义函数，def 语句定义方法
  def m(x: Int) = x + 3 //定义方法
  val f = (x: Int) => x + 3 //定义函数
  /*
  Scala 定义方法用的是def关键字,默认方法的返回类型是unit(类似java的void)
  基本上java可以定义的:,无参数的,含参数无返回,含参数有返回值的.scala也可以定义
  我来说一下scala那些高级的方法功能吧!
  */
  def scalaFun(): Unit = { //普通方法
    print("this is a scala Funtion\n")
  }

  /*Scala可以向方法传入可变长度参数列表。通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)*/
  def fun1(a: Int*): Unit = {
    var sum = 0
    for (i <- a) {
      sum += i
      print(sum + " ")
    }
  }

  /*scala指定函数的参数来进行传递*/
  def printInt(a: Int, b: String): Unit = {
    println(b)
    println(a)
  }

  def main(args: Array[String]): Unit = {
    scalaFun() //如果没有参数,加不加括号都可以调用
    scalaFun //如果没有参数,加不加括号都可以调用
    fun1(1, 2, 3) //scala中返回值为Unit的都可以称之为过程
    printInt(b = "\nscala", a = 520)
    println(student(classRoom, "skj"))
    println(classRoom("a student"))
    teacher(IDcard, "jam") //把函数当作一个返回值传递给另一个函数
    val res = intAdd1(9) - 1
    println(res)
    val res2 = addN1andN2(9, 8)
    println(res2)
    printLove()
    println(add1(1, 2))
    println(add2(1)(2))
    val factor=10
    val allover=(i:Int) => i*factor//allover就是一个闭包
    print(allover(52))
  }

  /*高阶函数:Scala 中允许使用高阶函数, 高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果*/
  def student(classRoom: String => String, name: String) = classRoom(name)

  def classRoom(str: String) = str + " is in class of 182"

  def teacher(IDcard: String => Int, name: String): Unit = {
    println(name + "'s ID is " + IDcard(name))
  }

  def IDcard(name: String): Int = {
    Random.nextInt(10000)
  }

  /*匿名函数,匿名函数的使用可以简化代码*/
  var intAdd1 = (x: Int) => x + 1
  /*多参数的匿名函数*/
  var addN1andN2 = (a: Int, b: Int) => a + b
  /*不含参数的匿名函数*/
  var printLove = () => {
    println("love is you and me,together")
    println("love is you and me,forever")
  }

  /*函数的柯里化
  柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。
  新的函数返回一个以原有第二个参数为参数的函数。*/
  def add1(a: Int, b: Int) = a + b

  def add2(a: Int)(b: Int) = a + b

  //从add1变成add2的过程,叫做函数的柯里化,其实就是拆分函数
  /*闭包,闭包也是一个函数.它只不过是可以引用外部的参数*/
  def endFun(str1: String): Unit = {
    def over(str2: String): String = {//此处的str2就是一个闭包
      str1 + str2
    }
    over _ //此处的_表示阻止over的运行
  }
}

导包

java导包:

import java.util.Scanner;//java的导包用的关键字是import
/*如果一次导入多个,可以写成下面的形式*/
import java.util.*;//*就是通配符
public class JavaPackage {
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        int a=input.nextInt();
        System.out.println(a);
    }
}

接下来看看scala

//import java.util.Scanner//scala导包也是import
import java.util._//导入util下的所有包
import java.util.{ArrayList, Scanner}//导入多个包
object ScalaPackage {
  def main(args: Array[String]): Unit = {
    val input =new Scanner(System.in)
    val a=input.nextInt()
    println(a)
  }
  /*其实,scala在任何位置都可以导入包,不像java那样只能在头部事先声明.而且,scala中的包还可以嵌套*/
}

--------------------更新日期2020-02-13,未完待续------------------------