一.面向对象编程根底

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{
 
}

关于scala:三Scala面向对象

一.面向对象编程根底

1.1 包

1.2 导入import

1.3 类

1.4 属性

1.5 拜访权限

1.6 办法

1.7 构造方法

二. 面向对象编程进阶

2.1 继承

2.2 封装

2.3 形象

2.4 特质

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于scala:三Scala面向对象

一.面向对象编程根底

1.1 包

1.2 导入import

1.3 类

1.4 属性

1.5 拜访权限

1.6 办法

1.7 构造方法

二. 面向对象编程进阶

2.1 继承

2.2 封装

2.3 形象

2.4 特质

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复