hello是java关键字吗_scala和java的关键字对比

1、scala里面的Trait是接口的意思，java里面是关键词是interface

//scala的接口

trait Htt {

def Htt (name:String)

}

//java的接口

Interface Htt{

void Ya(String name);

}

2、scala不支持对类进行多继承，但是支持多重继承trait，使用with关键字即可

类继承trait后，必须实现其中的抽象方法，实现时不需要使用override关键字,相当于java里面的interface

class Person(var name:String) extends SayHello with MakeFriends {

def sayHello (otherName:String) = println("hello , "+otherName)

override def mkFriends(p: Person): Unit = {

println("hello (MakeFriends) : "+p.name +", i am " +name)

}

}

3、Scala中，如果子类要覆盖一个父类中的非抽象方法，则必须使用override关键字

在子类中覆盖抽象类的抽象方法时，不需要使用override关键字

4、val相当于java里面的final，var相当于一个变量

5、scala中的unit相当于java中的void

6、scala中的通配符是_，java中的通配符是*

7、scala中没有static，但是可以用object来达到java中相同的效果，scala中的object可以实现单例对象

8、scala中的变量或函数的类型总是写在变量或者函数名的后面

9、没有静态类型，通过object 定义单例类，main方法就是放在object类型中。如下就是简单的hello world

object MyMain {

def main(args: Array[String]): Unit = {

println("hello world!")

}

}

10、 语法行后面的分号是可选的，可以省略

11、 Scala中== 等效于Java中的Equal，同时支持引用以及实际内容的比较，Scala纯粹的引用比较有新的关键词 eq 和ne

12、当调用无参数时，空括号()可以省略

13、当调用对象的无参数方法时， . 以及() 都可以省略。例如： List(1,2,3).size()写成  List(1,2,3)size

14、类中的无参函数定义

class Complex(real: Double, imaginary: Double) {

def re = real

def im = imaginary

}

15、数字序列语法to、 until

例如2 to 10，表示会2到10之间的数字，如不希望包括10，则可用 2 until 10

16、 match分支匹配关键字，对应于Java中的switch，但是可以支持任意的类型。同时可以返回值。

17、for语法不一样，有for( a

18、for循环在scala中除了以上常规的循环外，还有多重功能

1) 嵌入 if语句，可以过滤,例如下面例子，过滤出偶数

for( a

19、函数定义结构和Java存在较大差异

1) 函数使用def 开头

2) 返回值的类型是在函数声明后面

3) 函数参数定义的类型是在变量后面

4) 返回值不需要return，最后一个值就可以做为返回值。

5) 所有的函数参数都val 不可变类型，不可以修改

6) 函数体 前面有 =

def test(a:String, b:Int):String =

{

var c = b + 1

a + b

}

20、函数字面量以及简短格式。

1) 函数可以作为变量

var increase = (x:Int) => x  +1

increase(10)

2) 函数字面量的简单格式 ,例如传入filter函数中的短格式

List(1,2,3,4).filter(x => x% 2==0)

3)函数字面的占位符语法_，更简短格式

List(1,2,3,4).filter(_% 2 ==0)

这些语法形式在Java 8也已经有了类似lambda 形式

21、函数变量以及匿名函数

(a:Int)=>  形式来定义函数变量

object Timer {

def oncePerSecond(callback: () => Unit) {

while (true) { callback(); Thread sleep 1000 }

}

def timeFlies() {

println("time flies like an arrow...")

}

def main(args: Array[String]) {

oncePerSecond(timeFlies)

}

}

还可以通过 () =>xx 直接定义匿名函数

oncePerSecond(() =>println("time flies like an arrow..."))

22、类中 public 在scala中为默认属性级别，可以不加

23、泛型的括号为[] ，而Java中为<>

例如Array[Int]

24、集合索引使用()，而Java中为[]

例如 List(1,2,3)(0)

25、 数组为一个单独类型Array

26、List在scala中默认为一个不可变的集合类型

27、以List 为例介绍特有用法

1)：：：  连接多个List

2)：： 连接值和List

3)符合条件的奇数 count(s => s % 2 ==0)

4) exists(条件)、 filter(条件)、

5)foreah(遍历函数)

6) map 转换

用法非常丰富，详见的api文档

7)alist sort (_ < _)

28、有元祖的概念，var a = (2,3)

29、Set、Map默认都为不可变，可以通过import定义为可变

mportscala.collection.mutable.Set

30、for循环枚举和条件过滤：

枚举：

for (i

31、占位符语法

例如我们写一个f函数：

val f = (_:Int) +(_:Int)

println(f(2, 3))

占位符还可以用来设置函数的别名：

val a=f _

这样a和函数f是等效的，f不用传入参数，直接加个占位符就可以了

除了上面的做法，还可以：

val f = (_:Int)+(_:Int)

val b = f(1,_:Int)

println(b(10))

32、scala可以通过“*”来定义函数的可变参数：

object Rational {

def echo(args :String*) =

for(arg

33、import关键字

scala的import和java的import存在以下区别，在scala中：

1.可以出现在任何地方。

2.可以指的是(单例类或者正统的)对象或包。

3.可以重命名或者隐藏一些被引用的成员。

用例：

//将Rational这个类引入

import cha06.scala.Rational

//将静态方法Element.elem引入

import Element.elem

//将obejct Element的所有方法引入

import Element._

除了上诉方法外，import除了可以出现在编译单元的起始位置之外，还可以出现在任何地方。

例如：

private class LineElement(s:String) extends Element{

//将Rational这个类引入

import cha06.scala.Rational

val rational = new Rational( 2, 5)

//....

}

重命名和隐藏：

//只能访问ArrayBuffer 的 concat和newBuilder两个方法，其他方法被隐藏

import scala.collection.mutable.ArrayBuffer.{concat ,newBuilder }

//只能访问ArrayBuffer 的 concat和newBuilder两个方法，其他方法被隐藏,并且给 concat加了个别名conc，你可以通过conc访问concat

import scala.collection.mutable.ArrayBuffer.{concat =>conc,newBuilder}

//可以访问除了newBuilder 外的所有成员

import scala.collection.mutable.ArrayBuffer.{newBuilder =>_,_}

34、类中的apply方法

这个方法在scala中比较特殊，类中定义了apply的方法后，调用这个方法不需要显示的写apply。直接写"实例名(参数列表)"的形式就好。

例如：

tuple(1)事实上是调用了tuple.apply(1)

List(1,2,3,4)事实上是调用了List(1,2,3,4)

35、在类的主构造器中加入参数的时候，如果没有写val或者var，那么主构造器中的参数默认为private，在类实例化之后不能被外部访问，如果加了val或者var表示参数可以被外部访问，等同于private[this] val。

36、嵌套类：

import scala.collection.mutable.ArrayBuffer

class Network{

class Member(val name:String){

val contacts = new ArrayBuffer[Member]

}

private val members = new ArrayBuffer[Member]

def join(name:String) = {

val m = new Member(name)

members += m

m

}

}

val chatter = new Nework

val myFace = new Network

注意：

在scala中chatter.Member和myFace.Member是两个不同的类

所以以下语句会报错

var mym = new chatter.Member("yang");

mym = new myFace.Member("face")

37、scala三引号的作用和python三引号的作用相同

38、String Interpolation (String 插值器)

1.s插值器：

例1：

val name = "James"

println(s"Hello, $name") // Hello, James

例2：

println(s"1 + 1 = ${1 + 1}")

2.f插值器：

val height = 1.9d

val name = "James"

println(f"$name%s is $height%2.2f meters tall") // James is 1.90 meters tall

3.raw插值器：

scala> raw"a\nb"

res1: String = a\nb

scala> s"a\nb"

res0: String =

a

b

39、":"结尾的方法是右结合的：

首先我们要知道，scala的语法中"(1).to(10)"是可以写成"1 to 10"的。在通常情况写，这种表达式的写法是从左到右结合的，除了用":"结尾的方法外。用":"结尾的方法属于从右到左结合的。例如：List的"::"方法，在List中"::"的定义如下：

def ::[B >: A] (x: B): List[B]

但是我们使用的时候可以这样：

val newList = "a" :: "b" :: List()

自定义例子：

object Log { def >>:(data:String):Log.type = { println(data); Log } }

"Hadoop" >>: "Spark" >>: Log

40、for - yield语法

for{子句}yield{循环体}

41、Singleton对象：

单例对象使用object定义，普通对象使用class定义

当单例对象与某个类共享同一个名称时，他被称作是这个类的伴生对象： companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类： companion class。类和它的伴生对象可以互相访问其私有成员。object对象在第一次被调用的时候实例化。

object和class可以在内部再定义class。

new关键字不能使用在没有伴生类的伴生对象上，因为伴生对象是单例类，在第一使用的时候就会创建。

new关键字是用来产生类实例的，单例对象只有一个实例就不需要使用new关键字了。

例子：

//互相访问私有变量的例子：

class Myclass{

private var para = 0 //如果使用private[this]修饰，伴生对象就不能访问

def param = para

def param_=(newPara:Int){para=newPara}

}

object Myclass{

val myc = new Myclass

def objpara = myc.para

}