下面的代码包含了基本的Scala的语法内容。包括:判断,循环代码片段,方法定义,调用。 虚拟类,继承,接口,case,package,单例模式
- package org.exinglo.scala
- class LearnScala {
- }
- object Test{
- val variable1 = "this is my first scala variable"
- def func1(): String = "hello world" //不带参数的函数被调用时,可以不加括号
- def func2(who : String): String = { return "hello world " + who}
- def func3 = (x : Int, y : Int) => x + y //这是个匿名函数的写法,调用的时候,func3(1,2)
- //这里给了y一个默认值,如果用户传过来,那就用用户的
- def func4(x: Int)(y : Int = 1): Int = x + y //加脂法的写法,调用时, func4(1)(2)
- // * 代表多个参数的意思,比如 printEveryChar("c","b", "a"),可以传递多个string
- def printEveryChar(c : String*) = {
- c.foreach(x => println(x))
- }
- def main(args : Array[String]) {
- println(variable1)
- for(i <- 0 to 10 if i%2 == 0){
- println("i is a even number: " + i)
- }
- for(i <- 0 until 10){
- println("")
- }
- var (n, r) = (10, 0)
- while(n > 0){
- n = n - 1
- }
- val p = new Person //这里可以省略括号
- println("information about person:" + p.name + " " + p.age) //如果p.name没有赋值的话,这里会显示为null
- }
- }
- package org.exinglo.scala
- class Person{ //类默认是public类型的
- var name : String = _ //会生成setter和getter方法
- val age = 10 //只会生成getter方法
- private[this] val gender = "male" //无法在下面的main方法访问gender,这个属性只能在对象内部访问
- }
- //生成对象时 val p = new Person2("Java", 10)
- //如果参数声明时不带val或者var,那么这个变量相当于内部变量,比如 class Person(name: String) 这里的name就无法在外部被访问到了
- class Person2(val name : String, val age : Int){//括号中的内容属于主构造器,其中的参数会作为类的属性存在
- println("this is the person2's constructor")//这里属于默认构造器,生成对象时,会执行这句话
- var gender : String = _ //这里要求初始化
- //附属构造器必须叫做this,必须首先调用已经存在的子构造器或者其他附属构造器
- def this(name : String, age : Int, gender : String){
- this(name, age)//必须调用默认的构造器,=
- this.gender = gender
- }
- }
- //成成Student对象的时候,会先打印父类构造器的打印语句,然后但因student类的语句
- class Student(val grade : Int, name : String, age : Int) extends Person2(name, age) {
- println("this is the subclass of Person, grade is:" + grade)
- override def toString() : String = {""} //覆盖父类的方法,一定要加上override关键字,其实不仅仅是父类的方法,覆盖父类的var val都要加上override
- }
- package org.exinglo.abstractandtrait
- class ABstractAndTrait {
- }
- //抽象类(abstract class)
- //• 类的⼀一个或者多个⽅方法没有没完整的定义, 当然也可以没有任何抽象方法。
- // 对于子类覆盖父类的非抽象方法,一定要override关键字
- //• 声明抽象⽅方法不需要加abstract关键字,只需要不写⽅方法体
- //• ⼦子类重写⽗父类的抽象⽅方法时不需要加override
- //• ⽗父类可以声明抽象字段(没有初始值的字段)
- //• ⼦子类重写⽗父类的抽象字段时不需要加override
- abstract class PersonX{
- def speak
- val name:String
- val age:Int
- }
- class Student extends PersonX{
- //必须要实现抽象方法,像这种不写等于号的情况,表示返回类型是Unit类型
- def speak{
- println("speak")
- }
- val name:String = ""
- val age:Int = 3
- }
- trait Logger{
- def log(msg:String)
- }
- //这里的trait consoleLogger可以不实现父类的方法,也可以覆盖父类的方法实现,也可以实现父类的虚方法
- trait ConsoleLogger extends Logger{
- def log(msg:String){
- println("save money:" + msg)
- }
- }
- //因为是覆盖上级的方法,必须使用override关键字
- trait MessageLogger extends ConsoleLogger{
- override def log(msg:String){
- println("save money to account:" + msg)
- }
- }
- //如果一个类没有继承其他的类,实现的第一个trait只能用extends,其他的用with关键字
- class Test extends ConsoleLogger{
- def test{
- log("hellp")
- }
- }
- abstract class Account{
- def save
- }
- class MyAccount extends Account with ConsoleLogger{
- def save{
- log("100")
- }
- }
- object Run extends App{
- //这里是一个很好玩的地方,单独给一个对象混入了一个特质trait,并且这个特质与类的定义继承的特质有冲突
- //打印出来的是MessageLogger中的log方法
- val acc = new MyAccount with MessageLogger
- acc.save
- }
- package org.exinglo.abstractandtrait
- class ApplyTest(val msg:String) {
- def apply() = msg
- def test{
- println(msg)
- }
- }
- object ApplyTest{
- //下面是apply方法的最常用的方式
- def apply() = new ApplyTest("object calls new")
- //object的方法相当于java中的静态方法
- def static{
- println("I am a static method")
- }
- }
- object Basic extends App{
- //类似于下面,嗲用object的方法
- ApplyTest.static
- val t = new ApplyTest("new")
- println(t())
- //据说下面这样可以调用object ApplyTest中的apply方法,但是我的编译器总是报错
- //后来发现是object的apply方法一开始声明没有加上小括号造成的,如def apply = xxxx
- val tt = ApplyTest()
- println(tt())
- // ApplyTest()是调用object的apply方法
- // val t = new ApplyTest(); t() 调用的是class ApplyTest的apply方法
- }
- package org.exinglo.abstractandtrait
- /*
- * package com.xyz{
- * //-------------
- * package spark
- * }
- * }
- *
- * { //这里只在程序块中可见
- * import com.yyy
- *
- * }
- *
- * import java.util.{HashMap =>JavaHashMap} //定义一个别名
- *
- *
- * package aa.bb.cc.dd
- *
- * class Xxx{
- * private[dd] def variable = {} //根据private[]中指定的不同,可见范围不同
- * }
- *
- * */
- class PackageAndCase {
- }
- object BasicT extends App{
- val value = 3
- val result = value match{
- case 1 => "one"
- case 2 => "two"
- case _ => "some other number"
- }
- val result2 = value match{
- case i if i == 1 => "one"
- case i if i == 2 => "two"
- case _ => "other number"
- }
- def t(obj : Any) = obj match{
- case x:Int => println("Int")
- case s:String => println("String")
- case _ => println("unkonwn type")
- }
- t(2)
- }