Scala学习第三天

------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
应用程序对象
-------------------------------------------------------------------------------------
每个Scala程序必须从对象的main方法开始，方法的类型为Array[String] => Unit
object Hello {
def main(args: Array[String]){
println("Hello World");
}
}
还可以直接扩展App特质
object Hello2 extends App {
println("Hello World");
}
通过args属性得到命令行参数
object Hello2 extends App {
if(args.length > 2) {}
println("Hello World");
}
}

------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
包和引用
包：相当于java中的命名空间，管理大型程序中的名称；


------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
继承
-------------------------------------------------------------------------------------
A:扩展类
Scala扩展类的方式和Java一样，使用extends关键字
----------------------------
class Employee extends Person {
var salary = 0.0;
}
可以声明泪为final,使其不可被扩展；
final class Employee extends Person {
var salary = 0.0;
}

B:重写方法
使用修饰符override一个非抽象方法
public class Person {
override def toString = getClass.getName + "name";
}
子类调用超类的方法使用super关键字；

C:类型检查和转换
测试某个对象是否属于某个给定的类，使用isInstanceOf[];
使用asInstanceOf[]方法转换为子类的引用；
classOf[]方法 
p.getClass == ClassOf[Employee]

使用模式匹配是更好的选择
----------------------------
class Person {
val id: Int = 10;
val name: String = null;
}

class Employee extends Person {
var eid: Int = 0;
}
p match {
case s: Employee => println("I am a employee"); //作为Employee处理
case _ => //p不是Employee对象
}

D:受保护的字段和方法
将字段和方法声明为protected,成员可被任何子类访问，但不能从其他位置看到；


E:Scala继承层级
与Java中基本类型相对应的类和Unit类型都扩展AnyVal类型；
其他类都是AnyRef的子类；
AnyVal和AnyRef都是继承Any类；Any类是根类；
所有的Scala类都实现ScalaObject标记接口；ScalaObject没有定义任何方法；

------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
特质
-------------------------------------------------------------------------------------
A: 当作接口使用的特质
--------------------
trait Logger {
def log(log: String) //抽象方法
}
转换的java类为
public interface Logger {
public abstract void log(java.lang.String);
}

子类实现
class ConsoleLogger extends Logger {
def log(log: String) { println(msg);} //不需要override
}

trait还可以包含具体的实现方法
trait ConsoleLogger {
def log(msg: String) { println(msg);}
}
转换后的Java类代码为
public interface ConsoleLogger {
public static void log$(ConsoleLogger, java.lang.String);
public void log(java.lang.String);
public static void $init$(ConsoleLogger);
}

类使用trait 
---------------------
class Person with ConsoleLogger {
def cond(x: Int) {
if(x < 3) {
log("too little");
} 
else 
println("OK");
}
}

创建对象时使用trait
var x = new Person with Logger; //对象可以使用Logger的方法；

多个trait叠加
var m = new Person with Logger with ConsoleLogger;

对trait的扩展使用extends 

trait中定义具体字段
trait Animal {
val name: String = "nothing";
}

trait中定义抽象字段
trait Animal2 {
var name: String ; //抽象字段
}

自身类型
trait ExceptionLogger extends Logger {
this: Exception = >
def log(msg: String) { println("log..........."); }
}
该类不扩展Exception类，而是自身拥有一个自身类型Exception

------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
操作符
-------------------------------------------------------------------------------------
A:中置操作符(左右两边是变量)
a 操作符 b
a to b
a -> b
B:一元操作符
a 操作符 //后置操作符 
操作符 b //前置操作符
+-!~ 相当于 unary_+() unary_-() unary_!() unary_~()
C:结合性
在Scala中除以 (:)和赋值操作符外的操作符都是左结合；
构造列表的(::)操作符是右结合； Nil是个对象
1::2::3::Nil; ===> List[Int] = List(1, 2, 3);

------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
------------<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>----------------------------------------
高阶函数
-------------------------------------------------------------------------------------
函数式编程
函数的参数可以是参数；

A: 作为值的函数
--------------------
import scala.math._
val num = 3.14;
val fun = ceil _ //定义了函数型变量， ceil是个函数；
val fun1: (Double) => Double = ceil _;

val result = fun(num); //函数型变量使用

B:定义高阶函数
def add(a: Int, b: Int): Int = a + b; //定义一个add函数
def sub(a: Int, b: Int): Int = a - b; //定义一个add函数
//定义高阶函数op，传入一个函数类型的变量f和两个操作数a，b;

// 将函数作为函数的参数
def op(f:(Int, Int) => Int, a: Int, b: Int) = f(a,b) 
val res = op(add _, 1, 2) //返回3； 

// 返回函数的函数定义
def returnFunc(x : Int): (Int, Int) => Int = {
if(x > 0) return add _;
else return sub _;
}
returnFunc(1)(2,3); //根据返回的函数直接调用函数；返回5；
val fun = returnFunc(0); //使用fun变量接函数返回的值；
fun(2,3)

def momb(f1: (Int, Int) => Int,f2: (Int, Int) => Int, c: Int, d: Int, e: Int, f: Int): Int = {
val a = f1(c, d);
val b = f1(e, a);
return f2(b, f);
}

匿名函数
-----------------------------
定义一个匿名函数
val fun = (x: Int) => x * 3:Int;
val fun = (x: Int) => {x * 3}:Int;

用法：作为函数的参数

def momb(f1: (Int, Int) => Int,f2: (Int, Int) => Int, c: Int, d: Int, e: Int, f: Int): Int = {
val a = f1(c, d);
val b = f1(e, a);
return f2(b, f);
}