scala入门 类、方法、对象、继承、特质

1. 类、方法、对象、继承、特质
   Scala的类与Java、C++的类比起来更简洁，学完之后你会更爱Scala！！！
   1.1. 类
   1.1.1. 类的定义
   package cn.bw.class_demo

/**

• 在Scala中，类并不用声明为public类型的。

• Scala源文件中可以包含多个类，所有这些类都具有共有可见性。
  */
  class Person {
  //用val修饰的变量是可读属性，有getter但没有setter（相当与Java中用final修饰的变量）
  val id=“9527”

  //用var修饰的变量都既有getter，又有setter
  var age:Int=18

  //类私有字段，只能在类的内部使用或者伴生对象中访问
  private var name : String = “唐伯虎”

  //类私有字段，访问权限更加严格的，该字段在当前类中被访问
  //在伴生对象里面也不可以访问
  private[this] var pet = “小强”

}

//伴生对象（这个名字和类名相同，叫伴生对象）
object Person{
def main(args: Array[String]): Unit = {
val p=new Person

//如果是下面的修改，发现下面有红线，说明val类型的不支持重新赋值，但是可以获取到值
//p.id = "123"
println(p.id)
//打印age
println(p.age)
//打印name,伴生对象中可以在访问private变量
println(p.name)
//由于pet字段用private[this]修饰，伴生对象中访问不到pet变量
//p.pet(访问不到)

}
}

1.1.2. 方法的定义
1.基本语法

//基本语法
def eat(food:String): Unit ={
println(s"吃${food}很爽啊----------")
}

Def :定义方法的关键字
eat :方法名
Unit :返回值类型 可以使用return 也可以不使用 ,scala中尽量不使用

方法的调用
object Person{
def main(args: Array[String]): Unit = {
val person = new Person
person.eat(“红薯”)
}
}

1.1.3. 构造器
Scala中的每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起。
注意：主构造器会执行类定义中的所有语句。
package cn.bw.class_demo

/**
*每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起
*/
class Student(val name:String,var age:Int) {
println(“执行主构造器”)
private var gender=“male”
def this(name:String,age:Int,gender:String){
//每个辅助构造器执行必须以主构造器或者其他辅助构造器的调用开始
this(name,age)
println(“执行辅助构造器”)
this.gender=gender
}
}

object Student {
def main(args: Array[String]): Unit = {
val s1=new Student(“zhangsan”,20)

val s2=new Student("zhangsan",20,"female")

}
}

1.2. Scala面向对象编程之对象
1.2.1. Scala中的object
 object 相当于 class 的单个实例，通常在里面放一些静态的 field 或者 method；
在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的。
object作用：
1.存放工具方法和常量
2.高效共享单个不可变的实例
3.单例模式
 举例说明：
Java 单例对象
public class ImageLoader {
//创建一个对象
private static ImageLoader instance = new ImageLoader();
//私有化构造
private ImageLoader(){}
//提供一个静态的方法,返回实例化的对象
public static ImageLoader getInstance(){
return instance;
}
}
测试
public class JavaTest {
public static void main(String[] args) {
ImageLoader instance = ImageLoader.getInstance();
//打印实例对象1
System.out.println(instance);
ImageLoader instance01 = ImageLoader.getInstance();
//打印实例对象2
System.out.println(instance01);
}
}

package cn.bw.object_demo
import scala.collection.mutable.ArrayBuffer

class Session{}
object SessionFactory{
//该部分相当于java中的静态块
val session=new Session
//在object中的方法相当于java中的静态方法
def getSession(): Session ={
session
}
}
object SingletonDemo {
def main(args: Array[String]) {
//单例对象，不需要new，用【单例对象名称.方法】调用对象中的方法
val session1 = SessionFactory.getSession()
println(session1)
//单例对象，不需要new，用【单例对象名称.变量】调用对象中成员变量
val session2=SessionFactory.session
println(session2)
}
}

1.2.2. Scala中的伴生对象
 如果有一个class文件，还有一个与class同名的object文件，那么就称这个object是class的伴生对象，class是object的伴生类；
 伴生类和伴生对象必须存放在一个.scala文件中；
 伴生类和伴生对象的最大特点是，可以相互访问；
 举例说明：
package cn.bw.object_demo

//伴生类
class Dog {
val id = 1
private var name = “bw”
def printName(): Unit ={
//在Dog类中可以访问伴生对象Dog的私有属性
println(Dog.CONSTANT + name )
}
}
//伴生对象
object Dog {
//伴生对象中的私有属性
private val CONSTANT = "汪汪汪 : "
def main(args: Array[String]) {
val p = new Dog
//访问私有的字段name
p.name = “123”
p.printName()
}
}
//执行结果 汪汪汪 : 123

1.2.3. Scala中的apply方法
 object 中非常重要的一个特殊方法，就是apply方法；
 apply方法通常是在伴生对象中实现的，其目的是，通过伴生类的构造函数功能，来实现伴生对象的构造函数功能；
 通常我们会在类的伴生对象中定义apply方法，当遇到类名(参数1,…参数n)时apply方法会被调用；
 在创建伴生对象或伴生类的对象时，通常不会使用new class/class() 的方式，而是直接使用 class()，隐式的调用伴生对象的 apply 方法，这样会让对象创建的更加简洁；
 举例说明：
1.简化创建对象
package com.bw.myclass
//伴生类
class Foo(name:String) {

}
//伴生对象
object Foo {
def apply(foo: String) : Foo = {
new Foo(foo)
}
}
//测试类
object Client {

def main(args: Array[String]): Unit = {
val foo = Foo(“Hello”)
}
}

2.工厂方法
package cn.bw.object_demo
/**

• Array 类的伴生对象中，就实现了可接收变长参数的 apply 方法，
• 并通过创建一个 Array 类的实例化对象，实现了伴生对象的构造函数功能
  /
  // 指定 T 泛型的数据类型，并使用变长参数 xs 接收传