乐趣区

关于scala:三Scala面向对象

jiezi

一. 面向对象编程根底

1.1 包

1）申明包：罕用命名形式 域名反写 + 项目名称 + 模块名 + 程序类型名称
2）根本语法：和 java 相似

package cn.leaf.demo03

3）Scala 在根底语法上进行了扩大，性能更加弱小

  • package 关键字嵌套申明
package cn{
  package leaf{
    package demo03{
      object Scala_Object{def main(args: Array[String]): Unit = {println("demo")
        }
      }
    }
  }
}
  • Scala 中包和类的物理门路没有关系
  • 子包能够间接拜访父包内容，不须要 import 导入

示例

package cn{
  package leaf{
    class Test{def fun(): Unit ={println("test")
      }
    }
    package demo03{
      object Scala_Object{def main(args: Array[String]): Unit = {
          // 间接应用父包中的 Test 类
          val t = new Test()
          t.fun()}
      }
    }
  }
}

1.2 导入 import

1）根本语法和 Java 统一
2）Scala 同样对 import 进行扩大

  • import 能够在任意地位应用
object Scala_Object{def main(args: Array[String]): Unit = {
    import java.util.ArrayList
    new ArrayList[String]()}
}
  • Scala 中 import 能够在同一行导入多个类
import java.util.{List, ArrayList}
  • 屏蔽包
import java.sql.{Date=>_, Array=>_}
  • 给包起别名
import java.util.{Date=>UtilDate}

1.3 类

Scala 中没有 static 成员存在，然而 Scala 能够通过某种形式达到应用 static 成员的目标，这个就是伴生机制。
在语法层面上，把 static 成员和非 static 成员用不同的表达方式，就是 class 和 object。

class 在编译时只会产生以后类的 class 文件，其作用就是润饰一般的类。

object 在编译时会产生两个类文件，一个是以后类的文件，另一个是单例的类文件，object 中的属性和办法都能够通过类名间接拜访，相似动态语法。

个别将 object 申明的类称之为伴生类，对应的单例文件称之为伴生对象。

但通常将雷同名称的 class、object 申明的类进行辨别：
应用 class 申明的类为伴生类
应用 object 申明的类为伴生对象

1.4 属性

示例

object Scala_Object{def main(args: Array[String]): Unit = {
    // 类中申明的属性等同于类中申明局部变量，应用 var 和 val 申明
    val person1 = new Person
    person1.name = "张三"
    person1.age = 18
    person1.addr = "Beijing"
  }
}

class Person{
  var name:String = _ // 下划线示意默认初始化
  var age:Int = _
  var addr:String = _
  val heigh = 0 // 如果应用 val 申明，则须要显示赋值，同时应用 val 申明的属性也不能批改。}

Scala 类中申明的属性 ：
1）编译时，类中申明的属性都是 private
而后同时提供公共办法进行拜访
2）编译生成的办法为：

相似 java 中 Bean 对象的 get 办法，用于返回属性的值
相似 java 中 Bean 对象的 set 办法，用于设定属性的值

3）在应用时

因为属性是公有，所以给属性赋值，等同于调用 set 办法
因为属性是公有，所以获取属性值，等同于调用 get 办法

4）应用 val 申明的属性

编译时，属性会被 final 润饰，应用过程中不提供 set 办法

5）Scala 编译生成 get、set 办法并不遵循 bean 标准，这导致在很多框架中无奈应用，为了兼容其余框架，能够采纳注解 @BeanProperty。

@BeanProperty
var name:String = _

构建对象:
1) 应用 class 申明的类，能够间接应用 new 的形式

object Scala_Object{def main(args: Array[String]): Unit = {
    // new 对象，构造方法无参，则小括号可省略
    val person1 = new Person
  }
}

class Person{}

2）应用 apply 构建对象，个别用于 object 伴生对象中构建对象。
示例

object Scala_Object{def main(args: Array[String]): Unit = {val person = Person()
    val person2 = Person("张三")
  }
}

class Person{

}

object Person{
  // apply 办法能够重载
  def apply(): Person = new Person()

  def apply(name:String): Person = {println("Person name==>"+name)
    new Person
  }
}

1.5 拜访权限

Scala 中有 4 种拜访权限：

  • private：公有权限，同类中拜访
  • private[包名]：包公有权限，同类或同包中拜访
  • protected: 受爱护的权限，同类中拜访或者子类中拜访
  • (default) : 公共权限，任意地位，留神 Scala 中没有 public 关键字

1.6 办法

Scala 中类的办法就是函数，申明形式齐全一样，但 Scala 中的办法具备重载和重写机制，同时调用办法必须通过对象。

1.7 构造方法

当应用 new 关键字创建对象时，就在调用类的构造方法。
Scala 中构造方法有两种类型：
1）主构造方法：在类名后的构造方法
2）辅助构造方法：为实现类的初始化提供的构造方法

class Person(){ // 主构造方法
  var person_name:String = _
  def this(name:String){ // 辅助构造方法
    this()
    person_name = name
  }
}

含有参数的主构造方法

class Person(name:String){ // 主构造方法能够有参数
  // name 参数是作为局部变量存在，不能通过对象在内部拜访
  // person_name 同样是局部变量，但同时也是类的属性，能够通过对象在内部调用
  // 如果咱们须要通过对象拜访 name 属性，那传参时，能够应用 val name:String, 如下边类 Person2
  val person_name:String = name
}

class Person2(val name:String){}

二. 面向对象编程进阶

2.1 继承

这个跟 Java 没有多少区别，同样是单继承，应用 extends 关键字

class Person{

}

class Student extends Person{}

不同之处，如果子类要重写父类的非形象办法，则必须应用 overwrite 关键字。
子类重写父类办法后，如果在子类中调用父类的被重写的办法，应用 super 关键字。

class Person{def speak(): Unit ={println("Person")
  }
  
}

class Stu extends Person{override def speak(): Unit = {super.speak()
    println("Student")
  }
}

2.2 封装

面向对象编程，封装大同小异，跟没有多少差别。

2.3 形象

1）抽象类
在父类中，有某些办法没有实现，子类继承时，须要重写来实现，这类办法就是形象办法。
而含有形象办法的类，就是抽象类，须要应用 abstract 申明，跟 Java 相似。
抽象类不能实例化。

abstract class Car {def car_color():Unit
}

class BaoMa extends Car{override def car_color(): Unit = {println("red")
    println("blue")
  }
}

2）形象属性
形象属性，就是说属性只有申明，而没有初始化
类中存在形象属性，那么这个类也是抽象类。

形象属性在编译时，不会产生类的属性，而是产生属性的 get、set 办法，且都是形象的。
重写形象属性，等同于重写一般属性的申明：get、set 办法

子类重写父类的形象属性，那么只须要将属性申明补充残缺即可。
子类重写父类的惯例属性，则须要应用 overwrite 关键字润饰。

Scala 中类的属性编译时，主动生成公有属性和对应的 set、get 办法，这点通过反编译能够查到。
示例

abstract class Car {
  // 形象属性
  var car_height:Int
  // 惯例属性
  @BeanProperty
  val car_weight:Int = 20
}

class BaoMa extends Car{
  var car_height: Int = 30
  @BeanProperty
  override val car_weight: Int = 30
}

2.4 特质

Scala 没有接口的概念，也就没有 interface 关键字。
然而 Scala 提供 Trait 作为接口来应用，也就是特质。
简略来说，就是 Scala 可能从多个类中将雷同的特色抽离进去，造成非凡的语法结构。
Java 中所有的接口都能够当做特质来应用。

1）特质能够看做 Interface，类混入特质，就等同于实现接口 interface。

示例

// 应用 trait 关键字申明特质
trait DemoTrait{def hello(info:String)
}

// 类应用 extends 关键字混入特质
class Person extends DemoTrait{def hello(info: String): Unit = {println("hello"+info)
  }

2）特质中除了定义形象办法外，还能定义具体方法
示例

object Scala_Object{def main(args: Array[String]): Unit = {
    // 申明实例对象，应用 with 关键字混入特质
    val person = new Person with DemoTrait
    person.hello("world")
  }
}

// 应用 trait 关键字申明特质
trait DemoTrait{def hello(info:String):Unit = {println("hello:"+info)
  }
}

class Person{}
退出移动版