标签：
package per.xxl
/**
* @author Administrator
*/
class HelloScala {
}
//object声明类，表示此类为单例，在第一次调用的时候初始化
//类中的方法都是静态方法
object HelloScala{
def hello(name:String):String={
"hello "+name
}
//无参方法可以去掉(),如果没()则调用时不能有()
def helloScala(){
println("hello scala ,this is rocky!")
}
//默认参数
def helloDefault(s:String="addd"){
println("hello "+s)
}
//匿名函数
def add=(x:Int,y:Int)=>x+y
//函数编程的柯里化
def add2(x:Int)(y:Int)=x+y
//函数赋给常量
var sum=(x:Int,y:Int)=>x+y
//可变参数
def varliableParameters(s:String*)={
s.foreach ( x => println(x) )
}
def main(args:Array[String]){
println("hello Scala")
println(hello("scala1"))
helloScala
//隐藏()
helloScala
helloDefault()
//定义函数和表达式
println (add(1,2))
println (add2(1)(2))
println (sum(1,2))
varliableParameters("aa","bb","cc","123")
//if
println("if:"+(if(1>0)1 else 0))
//while
var (n,r)=(10,0)
while(n>0){
r=r+n
n-=1
}
println("while :"+r)
//for
for(i<- 1 to 10){
println("for:"+i)
}
//until 到10不再执行
for(i<- 1 until 10){
println("for until:"+i)
}
for(i<- 1 to 10 if i%2==0){
println("for if:"+i)
}
}
}
package per.xxl
/**
* @author Administrator
*/
class OOPInScala {
}
class Person{
//属性声明 var可以get,set val只有get相当于java的final属性
var name:String =_
val age=27
private[this] val gender="male"
}
//1，主构造器直接跟在类名后面，主构造器中的参数会被编译成类的字段；
//2，主构造器执行的时候会执行类中的所有不包含在方法体中的语句；
class Person1(val name:String,val age:Int){
println("this is p1 construct ")
}
//如果在 主构造器函数的参数中没有用val或者var去声明变量，
//那此时的变量是private[this]级别的，只能够被类内部访问
class Person2(name:String,val age:Int){
println("this is p2 construct ")
}
class Person3(val name:String,val age:Int){
println("this is p3 construct ")
var gender:String =_
val unit:String="PU"
//1， 附属构造器是用this来声明的；
//2， 附属构造器中必须调用主构造或者其它附属构造器；
def this(name:String,age:Int,gender:String){
this(name,age)
this.gender=gender
}
}
//继承，重写的方法或属性字必须加上override
class Students(name:String,age:Int,majoy:String) extends Person3(name,age){
println("this is student construct ")
//重写属性,var易变属性不能被重写，因为不需要，可以直接进行操作
//override var gender="female"
override val unit="AU"
//override def toString = "override to String"
/*override def toString():String={
//使用return 必须在方法后面指定返回类型
return "override to String"
}*/
override def toString()={
//不声明方法的返回类型，则默认最后一个表达式为返回值
"override to String"
}
}
object OOPInScala{
def main(args:Array[String]){
val p = new Person
p.name="Rocky"
println(p.name+":"+p.age)
//private 直接调用出错
//p.gender
val p1 = new Person1("rocky",27)
println("P1: "+p1.name+":"+p1.age)
val p2 = new Person2("rocky",22)
//println("P2: "+p2.name+":"+p2.age)
val p3 = new Person3("rocky",32,"man")
println("P3: "+p3.name+":"+p3.age+":"+p3.gender)
var stu = new Students("rocky",22,"computer")
stu.gender="man"
println("stu:"+stu.toString()+"\ngender:"+stu.gender+"\nunit:"+stu.unit)
}
}
package per.xxl
/**
* @author Administrator
*/
class AbstractScala {
}
//抽象类
abstract class People{
def speak
def speak2={
println("this is abstract!")
}
var age:Int
//"final"类型只能由子类实现
val name:String
}
class Worker extends People{
def speak={
println("hello speak!")
}
//已实现的抽象方法需要加上override,可以不用重写这个方法
override def speak2={
println("hello speak2!")
}
var age:Int=27
//"final"类型只能由子类实现
val name:String="worker"
}
//特质类，可以有实现方法
trait People1{
def speak
def speak2={
println("this is trait!")
}
var age:Int
//"final"类型只能由子类实现
val name:String
}
class leader extends People1{
def speak={
println("this is leader")
}
var age:Int=23
val name:String="leader"
}
//继承抽象类和特质类，可以extends和with多个特质类，抽象类只能单继承
class coder extends People with People1{
def speak={
println("this is coder")
}
//因为people和people1都实现了speak2，所以必须要重写
override def speak2={
println("hello coder speak2!")
}
var age:Int=23
val name:String="coder"
}
//App是scala定义的一个可执行接口
//App内部帮助我们实现了main方法并管理代码
object AbstractScala extends App{
val worker = new Worker
worker.speak
println(worker.age+":"+worker.name)
}
package per.xxl
/**
* @author Administrator
*/
class ApplyScala {
}
//apply相当于一个类的别名函数
//在单例类和普通类中有些区别
class ApplyTest{
def apply()={println("class apply在初始化val b = new ApplyTest()对象后，会当做b()的别名")}
def test(){
println("test")
}
}
//单例类，方法都是静态的
object ApplyTest{
def apply():ApplyTest={
println("object apply 会当做ApplyTest()的别名")
return new ApplyTest()
}
def static(){
println("static test")
}
}
object ApplyScala extends App{
ApplyTest.static()
val a = ApplyTest()
a.test
val b = new ApplyTest()
b()
b.test()
}
package per.xxl
import scala.collection.mutable.ListBuffer
/**
* @author Administrator
*/
class CollectionScala {
}
object CollectionScala extends App{
//list的元素值是不能变的l(2)=xx编译错误
//调用静态list的apply函数
var l = List(1,2,3,4,5,6)//
//声明list类型的方式
var ll:List[Int] = List(1,2,3,4,5,6)
//list头添加
l = 7::l
l = l.::(8)
println(l+" 取第1位值："+l(1))
//反向
println("反向:"+l.reverse)
//取头元素
println("取头元素:"+l.head+" 取尾元素："+l.last)
//取除头元素以外的元素
println("取除头元素以外的元素:"+l.tail+"\n取除尾元素以外的元素："+l.init)
//过滤
println("过滤:"+l.filter(_%2==0))
//list拼接
println("拼接:"+(l:::ll))
//zip操作,对应有unzip方法，zip会丢掉多余list的数据
println("zip:"+(l zip ll))
//切割，按规则划分为两个list。注意表达式和filter的表达式两种不同的方式都可以
println("切割:"+l.partition { x => x%2==0 })
println("切割1:"+(l.partition { x => x%2==0 })._1)
//合并
println("合并:"+List(l,ll,l).flatten)
//按规则合并
println("合并1:"+List(l,ll).flatMap { x => x.map { x => x+1 } })
//排序
println("降序:"+l.sortWith(_>_)+" 升序:"+l.sortWith(_<_))
//通常不建议直接对List进行编辑修改等操作如果需要用BufferList
var bl = ListBuffer(1,2,3,4,5)
println(bl)
bl(1)=99
println(bl)
println(bl.toList)
}
package per.xxl
/**
* @author Administrator
*/
class Implicit {
}
/**
* 隐式转换、隐式参数、隐式类
*/
class A{
}
class RichA{
def rich{
println("this is rich A")
}
}
object Implicit extends App{
//隐式函数的参数为A
implicit def AimRichA(a:A) ={
println("hei! implicit RichA")
//最后一个表达式为函数返回值
new RichA()
}
//val a= AimRichA(new A),不用写函数名，想想类的apply()函数
val a = new A
a.rich
//隐式参数
def impParam(implicit name:String){
println("implicit param:"+name)
}
implicit val name="hello!"
//使用了隐式参数 name,相当于impParam(name)
impParam
//也可以指定参数
impParam("hello2!")
//隐式类
implicit class inc(i:String){
def add(a:Int):Int={
return a+1
}
}
//相当于new inc("aa").add(1)
println("aa".add(1))
}
标签：
原文地址：http://my.oschina.net/laigous/blog/481360
