Scala中类、方法、对象、继承、特质的学习

一、类、方法、对象、继承、特质

1、类

1.1.1类的定义

类是对象的抽象，而对象是类的具体实例。类是抽象的，而对象是具体的。类是用于创建对象的蓝图，它是特定类型的对象中的方法,变量的软件模板

语法

class+类名（参数体）{方法体}

案例

class User{
	val user1 = new User
}

1.1.2方法的定义

语法

def 方法名（参数列表：参数类型）[返回值类型]={
	方法体
}

案例

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")
  }
}

2、对象

1.2.1 Scala中的object

object 相当于 class 的单个实例，通常在里面放一些静态的 field 或者 method；
在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的。
object作用：

• 1.存放工具方法和常量
• 2.高效共享单个不可变的实例
• 3.单例模式

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中的伴生对象

1.如果有一个class文件，还有一个与class同名的object文件，那么就称这个object是class的伴生对象，class是object的伴生类；

2.伴生类和伴生对象必须存放在一个.scala文件中；

3.伴生类和伴生对象的最大特点是，可以相互访问；

4.举例说明：

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 接收传参，返回 Array[T] 数组
// 通过 new 关键字创建 xs.length 长的 Array 数组
// 其实就是调用Array伴生类的 constructor进行 Array对象的初始化
//  def apply[T: ClassTag](xs: T*): Array[T] = {
//    val array = new Array[T](xs.length)
//    var i = 0
//    for (x <- xs.iterator) { array(i) = x; i += 1 }
//    array
//  }

object ApplyDemo {
  def main(args: Array[String]) {
    //调用了Array伴生对象的apply方法
    //def apply(x: Int, xs: Int*): Array[Int]
    //arr1中只有一个元素5
    val arr1 = Array(5)

    //new了一个长度为5的array，数组里面包含5个null
    var arr2 = new Array(5)
    println(arr1.toBuffer)
  }
}

1.2.3 Scala中的main方法

同Java一样，如果要运行一个程序，必须要编写一个包含 main 方法的类；
在 Scala 中，也必须要有一个 main 方法，作为入口；
Scala 中的 main 方法定义为 def main(args: Array[String])，而且必须定义在 object 中；
除了自己实现 main 方法之外，还可以继承 App Trait，然后，将需要写在 main 方法中运行的代码，直接作为 object 的 constructor 代码即可，而且还可以使用 args 接收传入的参数；

举例说明：

package cn.bw.object_demo

//1.在object中定义main方法
object Main_Demo1 {
  def main(args: Array[String]) {
    if(args.length > 0){
      println("Hello, " + args(0))
    }else{
      println("Hello World!")
    }
  }
}
//2.使用继承App Trait ,将需要写在 main 方法中运行的代码
// 直接作为 object 的 constructor 代码即可，
// 而且还可以使用 args 接收传入的参数。

object Main_Demo2 extends App{
    if(args.length > 0){
      println("Hello, " + args(0))
    }else{
      println("Hello World!")
    }
}

3、继承

• 1.Scala 中，让子类继承父类，与 Java 一样，也是使用 extends 关键字；

• 2.继承就代表，子类可继承父类的 field 和 method ，然后子类还可以在自己的内部实现父类没有的，子类特有的 field 和method，使用继承可以有效复用代码；

• 3.子类可以覆盖父类的 field 和 method，但是如果父类用 final 修饰，或者 field 和 method 用 final 修饰，则该类是无法被继承的，或者 field 和 method 是无法被覆盖的。

• 4.private 修饰的 field 和 method 不可以被子类继承，只能在类的内部使用；
  field 必须要被定义成 val 的形式才能被继承，并且还要使用 override 关键字。 因为 var 修饰的 field 是可变的，在子类中可直接引用被赋值，不需要被继承；即 val 修饰的才允许被继承，var 修饰的只允许被引用。继承就是改变、覆盖的意思。

• 5.Java 中的访问控制权限，同样适用于 Scala

	类内部	本包	子类	外部包
public	√	√	√	√
protected	√	X	√	X
private	√	X	X	X

举例说明：

package cn.bw.extends_demo

class Person1 {
  val name="super"
  def getName=this.name
}
class Student1 extends Person1{
  //继承加上关键字
  override
  val name="sub"
  //子类可以定义自己的field和method
  val score="A"
  def getScore=this.score
}

由于时间问题就写到这里。。。