小菜鸟

java菜鸟号正在起航

0%

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 2.2k 阅读时长 ≈ 2 分钟

scala特质(特征)

在java中是存在接口interface的，而scala中使用特质trait来代替接口，多个类具有相同的特质时，就可以将这个特质独立出来，采用关键字 trait声明。 理解trait 等价于(interface + abstract class)

语法

1
2
3
trait 特证名 {
  trait体
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// 定义特质
trait Breathable{
  def breath()
}

trait Flyable{
  def fly()
}

trait Swimmable{
  def swig()
}

// 没有父类，直接继承特质
// class 类名 extends 特质
// 如果同时继承多个特质的话需要使用with     class 类名 extends 特质1 with 特质2 with 特质3
class Animal extends Breathable {
  var name: String = "动物"

  def sayHello: Unit = {
    println("你好，我是" + name)
  }

  override def breath(): Unit = {
    println("我会呼吸")
  }
}

// 有父类，需要先继承父类，再继承特质
//  class 类名 extends 父类 with 特质1 with 特质2 with 特质3
class Bird extends Animal with Flyable{
  override def fly(): Unit = {
    println("我会飞")
  }
}

class Dog extends Animal with Swimmable{
  override def swig(): Unit = {
    
    println("我会狗刨")
  }
}


阅读全文 »

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 1.5k 阅读时长 ≈ 1 分钟

scala继承

scala与java一样，也存在继承，且也支持单继承，同样使用extends关键字(如果将类声明为final，就不能被继承。如果将方法或字段声明为final，就不能被重写)

语法

1
class 子类名 extends 父类名 { 类体 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
object TestExtends {
  def main(args: Array[String]): Unit = {
    val tiger = new Tiger
    tiger.name = "东北虎"
    tiger.sayHello
    tiger.run
  }
}

class Animal {
  var name: String = _

  def sayHello: Unit = {
    println("你好，我是" + name)
  }
}

class Tiger extends Animal {

  def run: Unit = {
    println("I can run")
  }
}
阅读全文 »

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 1.7k 阅读时长 ≈ 2 分钟

scala伴生类和伴生对象

在之前的例子中也看到过有的文件中既声明了class又声明了object，这两个有什么区别呢，为什么main方法要在object中而不能和java一样在class中呢？

这是因为scala中将static关键字去掉了，采用了伴生类和伴生对象的概念来区分静态和非静态，在伴生类中的都是非静态的，而在伴生对象中声明的都是静态的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 伴生类
class Cat{
  // _表示赋默认值
  var name:String = _
  var color:String = _
}

// 伴生对象
object Cat{
  var count:Int = _
  
}


    val cat= new Cat
    cat.name = "小花"
    cat.color = "黄白"
    // 可以直接使用类来调用伴生对象中的字段和方法
    Cat.count
阅读全文 »

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 461 阅读时长 ≈ 1 分钟

scala访问修饰符

在java中有四种访问修饰符，public、protected、default、private，那么scala中呢？

  • 当属性访问权限为默认时，从底层看属性是private的，但是因为提供了 xxx_$eq()[类似setter]/xxx()[类似getter] 方法，因此从使用效果看是任何地方 都可以访问)

  • 当方法访问权限为默认时，默认为public访问权限

  • private为私有权限，只在类的内部和伴生对象中可用

  • protected为受保护权限，scala中受保护权限比Java中更严格，只能子类访问， 同包无法访问(这里是编译器限制的，编译完成java之后其实是public的)

  • 在scala中没有public关键字，即不能用public显式的修饰属性和方法

  • 包访问权限（表示属性有了限制。同时包也有了限制），这点和Java不一样， 体现出Scala包使用的灵活性

    1
    2
    3
    4
    class Dog {
      // 包访问权限 表示service包可以使用
      private[service] var name: String = _
    }

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 2.4k 阅读时长 ≈ 2 分钟

scala包

scala也像java一样有包这个概念，但是功能更加强大
Scala包的三大作用(和Java一样)

  • 区分相同名字的类
  • 当类很多时，可以很好地管理类
  • 控制访问范围

包定义方式

scala中包名和源码所在系统文件目录结构可以不一致，这点与java不一样，但是编译之后的字节码路径会和包名保持一致
这也就意味着scala中一个源文件可以包含多个包
且scala有三种包定义方式

阅读全文 »