Scala学习笔记之面向对象

Scala

目录(?)[-]

创建对象

val greetStrings = new Array[String](3)

如果类还实现了apply方法，那么可以简写

val greetStrings = Array[String](3)

object

1.object声明时和类声明时一样

2.一个object可以继承一个类的实现,并可以覆盖方法

3.java中的所有接口在scala中都可以用做特质

4.特质可以继承，如果要实现抽象方法要加上abstract override

5.对象中可以混入特质，如果一个类声明混入一个接口，那么在对象声明时可以动态混入特质

6.混入特质的类中必须实现所有的抽象方法，负责必须设为abstract

7.如果一个类混入了多个同中方法，那么在最后的特质的方法被调用。

scala继承结构

1.scala把所有类统一到Any下

2.java中的基本类型在Anyval下

3.其他类都在AnyRef下，

4.任何引用都可以设为null。

包

1.scala中的包和文件路径无关

2.scala中包可以嵌套，而且包也有作用域，这意味着子包可以引用父包。

3.可以使用java中的包声明方法来简化scala中的包声明。

4.在包中可以有一个包的类，和包名相同。

5.包权限控制：private[package-name]//注意scala中的权限有方向性

6.引入import或者import _或者 import java.awt.{Color,Font}

7.可以在任何地方引入包

8.scala默认导入java.lang scala以及Predef

9.scala支持静态导入

前缀方法

前缀就是把操作符放在对象前面来调用，scala仅仅支持+,-,!, 和 ~。每一个前缀方法都会被翻译成unary_prefix

对象相等

scala的==和!=用于比较两个对象的内容，而eq和ne用来表示比较两个对象的引用相等性。而这和Java恰恰相反

导入

// easy access to Fruit

import bobsdelights.Fruit

// easy access to all members of bobsdelights

import bobsdelights._

// easy access to all members of Fruits

import bobsdelights.Fruits._

import Fruits.{Apple => McIntosh, Orange}

把Apple和Orange导入并且把Apple重命名为McIntosh

构造器

1.scala有一个主构造器和多个辐构造器

class Person(private var i:Int,val s:String){

print("Person contronstant");

def this(value:Int){this();i = value}

可以看到，在主构造器中可以声明类字段，且可以提供默认的参数，在类体中的语句都在构造时执行，且可以在主构造器前面加private来表示主构造器是私有的。

2.scala中的主构造器中的参数仅仅用于传递参数，在类中一定要声明类中使用的变量

3.辅助构造器的第一个语句必须是其他构造器

4.在scala中可以使用require来是数据符合一定的条件

5.在scala中，只有主构造器可以调用父类的构造器，java中任意的构造方法都可

6.为了克服2中的缺陷可以使用如下的声明

class Queue[T](private val leading: List[T],private val trailing: List[T]){

private def mirror =

if (leading.isEmpty) new Queue(trailing.reverse, Nil)

else this

def head = mirror.leading.head

def tail = {

val q = mirror

new Queue(q.leading.tail, q.trailing)

}

def enqueue(x: T) =

new Queue(leading, x :: trailing)

}

7.把主构造其设为私有的方法

class Queue[T] private (

private val leading: List[T],

private val trailing: List[T]

)

java和scala中的构造顺序问题

问题：java在子类构造过程中调用父类的构造器可能会子类覆盖的方法，但是这时子类仅仅产生并未初始化，也就是说父类得到的结果是没有定义的，因此构造结果也无法定义。在C++中父类构造过程中调用的是父类的方法。

解决方法：父类的使用未定义字段的字段设为lazy

预初始化

预初始化中，子类预初始化字段在父类初始化之前就已经初始化

对于匿名类

new {

val numerArg = 1 * x

val denomArg = 2 * x

} with RationalTrait

对于继承

object twoThirds extends {

val numerArg = 2

val denomArg = 3

} with RationalTrait{...}

抽象类

1.使用abstract关键字

2.抽象方法没有abstract，例子:def incl(x: Int): IntSet,子类实现时要用override关键字

3.抽象字段，没有初始值。

类型的收放问题

class Food

abstract class Animal {

def eat(food: Food)

}

class Grass extends Food

class Cow extends Animal {

override def eat(food: Grass) {} // This won’t compile,

} // but if it did,...

class Fish extends Food

val bessy: Animal = new Cow

bessy eat (new Fish) // ...you could feed fish to cows.

在java中无法禁止上面的问题，在继承结构中的子类无法精确控制它的方法参数

引用相关类型

定义：scala类中可以有type用来声明一个占位符，这样类型可以由各个子类控制，这样的好处就是有了精确的类型就可以调用特殊的方法。这个和继承具体的模板的方法得到效果类似

scala提供更加先进的类型控制，使用scala可以有效的控制子类的参数类型

class Food

abstract class Animal {

type SuitableFood <: Food //<:用来表示SuitableFood的上界是Food

def eat(food: SuitableFood)

}

class Grass extends Food

class Cow extends Animal {

type SuitableFood = Grass

override def eat(food: Grass) {}

}

声明

无参方法

val height = contents.length

空参方法

val height() = contents.length

继承

1.scala覆盖非抽象方法和抽象字段时使用override

2.调用父类用super

3.scala也支持protected

4.scala中只有主构造器可以调用父类的构造器，注意可以是父类任意的构造器。

as:class Employ(var name:String,var age:Int,val salary:Int) extends Person(name,age)

5.匿名子类，new Person("Fred"){def greeting="Greeting Fred"}

6.var只能覆盖抽象字段，而val可以在任何类中覆盖，覆盖普通类字段时要加上override

7.加上final就无法覆盖

混入

1.混入会把所有在特质中定义的公有属性和方法都集成到混入类，但是特质中的抽象字段必须在子类中重定义

类混入

如果一个类没有继承父类，那么应该使用extends混入特质，当有一个继承时用with

class SavingAcount with Logged{}

trait FileLogged extends Logged{}

对象混入

var s = new SaveAccount with FileLogged

对象混入不能把特质混入final类

妙用

1.scala中的特质可以用来向一个类动态加入方法

as:trait RectangeLike{def grow(),def tanslate()}

val egg = new Double() with RectangeLike

这儿Double中原来并没有grow和translate方法，但是egg对象却可以使用这两个方法

2.打破Java中的单继承

由于trait可以继承自一个类，那么一个类就可使用通过混入一个特质来进行多继承。但是这是有限制的，如下

as:trait LoggedException extends Exception{}

classs UnhappyFrame extends JFrame with LoggedException{}//error

这儿UnhappyFrame继承的类必须是混入的接口所继承的类的子类。

3.装饰器

装饰器

trait Doubling extends IntQueue {

abstract override def put(x: Int) { super.put(2 * x) }

}

1.这人的特质继承了一个类，因此它仅能混入它继承类的子类中

2.特质使用abstract override来表明它要作为修饰器

3.traits further to the right take effect first. When you call a method on a class with mixins, the method in the trait furthest to the right is called first. If that method calls super, it invokes the method in the next trait to its left, and so on.