Scala的学习笔记_第二天

来源：互联网发布：北京酒店推荐知乎编辑：程序博客网时间：2024/05/24 07:37

1.scala

1.元组

valx = (,,,,);

valx = (1,100) //对偶,特殊元组

valx = "001" -> "tomcat" //

valx = Array(1,2,3) //Array.apply()

valmap = Map("001" -> "tom",...) //

importscala.collection.mutable.Map ;

valmap = Map("001" -> "tom",...) //

class{

}

objectUtil{

}

private[this]

//包

//类 //成员非静态

//object //静态成员

package //类、 object、trait

package object //和同包相关的包对象.里面放置方法。

import .... ;

import xx.x.x._ //_通配,不含子包.

class Person{

importxx.x.x.x ;

}

import xx.x.x.x.{a,b,c,d} //导入指定的几个类

import xx.x.x.{Util => MyUtil} //类别名

overload //重载

overwrite //重写

override //覆盖

2.默认包

importjava.lang._

importscala._

importPredef._

3.继承

classAnimal {

defcry = println("hahha") ;

}

classDog extends Animal{

overridedef cry = { //重写cry 的方法

super.cry; //调用父类

println("xxx")

}

instanceof //模糊判断

Class() == Class() //精确判断。

scala的语法判断是不是某一个类型

Object o = xx ;

if(o instanceof Dog){

((Dog)o).cry();

}

//实例类型判断

if(o.isInstanceOf[Dog]){

p.asInstanceOf[Dog];

}

classOf[Dog] //相当于java中的Dog.class

d.getClass() //通过对象拿到类的信息,取得对象的类

scala>class Cat{def cry =println("mmm")}

scala>val c = new Cat()

scala>c match{

casea:Dog => println("is Dog");

case_ => println("none")

}

//超类构造

相当于super(name)

scala>class Person(name:String){}

scala>class Man(n:String,age:Int)extends Person(n){}

scala>val p = new Man("tom",12);

4.java对象的创建过程

1.开辟内存空间

2.成员变量默认值.

3.成员变量赋值 | 构造代码块优先级相同,从上到下按序执行

4.构造函数

//抽象方法

abstract class xx{

valid ; //抽象字段,没有初始化,有get方法

varid ; //抽象字段,没有初始化,有get/set方法

defxxx ; //抽象方法

}

class subclass extends xxx{

defxxx = ... //重写父类的抽象方法不需要override

}

//Scala类型等级

Any //相当于scala Root

AnyVal --|>Any //基本类型

AnyRef --|>Any //相当于java.lang.Object

5.IDEA中安装scala IDE插件

1.settings

2.plugins

3.install plugin from disk...

4.指定scala-intellij-bin-2016.3.6.zip文件。

创建的时候没有上面的内容右边的new找目录就好了!

如果想引入maven的以来就好了

在创建的时候加上组ID就好了.

6.执行命令

scala>import sys.process._

scala>"ls " ! //

scala>"ls " !! //以string形式返回

目前这样输出的话有问题,待解决!!!

7.Trait特质

scala>trait Logger{

deflog ; //抽象方法

}

//java中接口与抽象类的写法

class MyLogger extends Logger{

deflog = println("xxx") ;

}

8.scala shell中导入定义的scala文件

scala>:load xxx.scala

9.创建对象可以携带多个trait(特质)

scala>trait Logger{def log =println("loger.....")} //定义特质

scala>val x = newPerson("tom") with Logger //创建对象，携带特质

scala>x.log //通过对象，调用特质的方法

10.特质自身类型

scala>trait Logged{

this: Exception => def log = println("xxx") ; //只有Exception类型才能实现给特质相当给了一个特定的要求

}

scala>class Cat extends Logged{} //错误

scala>class Cat extends Exception with{} //可以.继承Exception之后才有特质的内容

11.操作符

1.中置(infix)操作符，放在中间操作符

scala>a + b //+在中间 infix(中置)

scala>val x "001" ->"tom" //+在中间 infix(中置)

2.一元操作符(后置操作符postfix)

scala>1.toString() //方法

scala>1 toString //操作符

2’.一元操作符(前置操作符) //unary_

scala>val a = 100 ;

scala>-a //等价于a.unary_-

scala>+a //等价于a.unary_+

scala>~a //等价于a.unary_~取反

12.操作符结合性

1.默认的都是左结合

2.:结尾的是右结合

3.=也是右结合.

scala>1::2::3::Nil //(3::Nil) Nil是结尾的操作符第一步先和3结合

//2::(3::Nil)) 和2结合

//1::(2::(3::Nil))) 最后和1结合

13.applay|update

scala>val a = Array(1,2,3,4);

scala>a(3) //a.apply(3)

scala>a(3) = 100 //a.update(3,100)

14.提取器,带有unapply方法的对象

scala>apply(1,2,3) //apply :数据 --> 对象

scala>unapply //unapply:对象 --> 数据

scala>class o{

varx = "tom" ;

defisEmpty : scala.Boolean = { false }

}

scala>object o { //伴生对象 ,就是伴随着类O产生的

defapply(a:Int,b:Int) : String = "[" + (a + b) + "]"

defunapply(xx:String) : o = {val oo = new o() ; oo.x = xx ; oo }

}

scala>object Number{ //解释出来这个传过去的参数

defunapply(x:String) : Option[Int]= Some(Integer.parseInt(x.trim))

}

15.高阶函数*********

scala>import scala.math._

scala>val fun = ceil _ //定义函数性变量, val f = add _

scala>def add(a:Int,b:Int):Int = a + b

scala> val fun= add _ //将这个函数赋给fun函数 ,用fun也可以传递参数

scala>def sub(a:Int,b:Int):Int = a – b

scala>val f:(Int,Int)=>Int = add _ //将add的方法给f 就是高级函数,

scala>def op(f:(Int,Int)=>Int, a:Int, b:Int):Int = {f(a,b)}// 在之前的基础上定义一个高级函数op,传递的参数是一个函数f,f的类型是两个Int,返回值类型也是一个Int,f的参数是a,b.调用的时候首先将自己的函数传递给fun即可看下面截图

def getFunc(n:Int): (Int,Int)=>Int = {

if(n> 0) add _ else sub _

}

得到需要的函数类型

例子:

//f1:前处理函数 , f2:收尾函数

combo(f1,f2,1,2,3,4) int //

f1(1,2) => a

f1(a,3) => b

f2(b , 4) => c

scala>defcombo(f1:(Int,Int)=>Int,f2:(Int,Int)=>Int,a:Int,b:Int,c:Int,d:Int):Int ={

valr = f1(a,b);

valrr = f1(r,c);

f2(rr,d);

}

scala>combo(add _ , sub _ ,...)

16.匿名函数

scala>(x:Int)=>x * 3 //函数声明=> 函数体

//复杂函数

scala>defcombo(f1:(Int,Int)=>Int,f2:(Int,Int)=>Int,a:Int,b:Int,c:Int,d:Int):Int ={

valr = f1(a,b);

valrr = f1(r,c);

f2(rr,d);

}

练习:

对combo函数进行增强，返回一个函数，该函数提取四个Int的最大值乘以原函数.
defcombo(f1:(Int,Int)=>Int,f2:(Int,Int)=>Int,a:Int,b:Int,c:Int,d:Int):(Int,Int,Int,Int)=>Int= {

varr = f1(a,b);

r= f1(r,c);

valfactor = f2(r,d) ;

(x:Int,y:Int,z:Int,k:Int)=>{

defmax(e:Int,f:Int) = if(e > f) e else f;

max(max(max(x,y),z),k)* factor;

}

阅读全文

1 0