标签：基本语法   spark   面向对象编程   初始   lin   静态变量   接收   nfa   细节   

Scala面向对象

前言：

　　Scala语言是面向对象的。

　　?  Java是面向对象的编程语言，由于历史原因，Java中还存在着非面向对象的内容:基本类型(int,float..) ，null，静态方法等。

　　?  Scala语言来自于Java，所以天生就是面向对象的语言，而且Scala是纯粹的面向对象的语言，即在Scala中，一切皆为对象。

1、类

　　?  如果我们不希望改变对象的引用(即：内存地址), 应该声明为val 性质的，否则声明为var, scala设计者推荐使用val ,因为一般来说，在程序中，

　　?  我们只是改变对象属性的值，而不是改变对象的引用。

　　?  scala在声明对象变量时，可以根据创建对象的类型自动推断，所以类型声明可以省略，但当类型和后面new 对象类型有继承关系即多态时，就必须写了。　

  定义： class 类名{
          成员变量
          val/var 名称=值
          成员方法
          def 方法名称（参数列表）：返回值类型={
              方法体
          }
      }
  创建对象：
      val 对象名称=new 类名（） //（）没有参数的时候可以省略

  /**
    * Person
    * name 不可变
    * age  可变
    * skill 数组
    * 方法：
    * def addSkill
    * def scanSkill
    */
  class Person {
    val name = "itcast"  //不可变 不需要setter 
    var age = 13  //可变 需要setter getter
    val skill = new ArrayBuffer[String]()

    // def addSkill
    def addSkill(subject: String): Unit = {
      skill += subject
    }

    def scanSkill(): Unit = {
      skill.foreach((x: String) => println(x))
    }
  }

2、方法的调用原则

　　?     ==加入字符串拼接==

/**
  * Teacher 类
  *   teach方法
  * 
  *   注意：teacher teach "spark" 这种调用方式只适用于一个参数的方法
  */
class Teacher{
  def teach(suject:String): Unit ={
    println(s"教学：$suject")
  }
}

object Scala_03_class {
  def main(args: Array[String]): Unit = {
    val teacher = new Teacher
    teacher.teach("hadoop")
    teacher teach("scala")
    teacher teach "spark"
    //0 to 10
    //0 until 10
    //1 + 2
  }
}

3、Scala构造器

　　构造器(constructor)又叫构造方法，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。

　　Java构造器的特点：

　　　　?  在Java中一个类可以定义多个不同的构造方法，构造方法重载

　　　　?  如果程序员没有定义构造方法，系统会自动给类生成一个默认无参构造方法(也叫默认构造器)，比如 Person (){super();}

　　　　?  一旦定义了自己的构造方法（构造器）,默认的构造方法就覆盖了，就不能再使用默认的无参构造方法，除非显式的定义一下,即: Person(){};

　　Scala构造器的介绍：

　　　　?  和Java一样，Scala构造对象也需要调用构造方法，并且可以有任意多个构造方法（即scala中构造器也支持重载）。

　　　　?  Scala类的构造器包括： 主构造器（一个） 和 辅助构造器(多个)。

Scala构造器的基本语法

class 类名(形参列表) {  // 主构造器
   // 类体
   def  this(形参列表) {  // 辅助构造器
   }
   def  this(形参列表) {  //辅助构造器可以有多个...
   }
} 
 辅助构造器 函数的名称this, 可以有多个，编译器通过不同参数（个数或类型）来区分.

　　Scala构造器注意事项和细节：

　　　　?  Scala构造器作用是完成对新对象的初始化，构造器没有返回值。

　　　　?  主构造器的声明直接放置于类名之后。

　　　　?  主构造器会执行类定义中的所有语句（把类中写的语句放入到主构造器），这里可以体会到Scala的函数式编程和面向对象编程融合在一起，

　　　　   即：构造器也是方法（函数），传递参数和使用方法和前面的函数部分内容没有区别

　　　　?  如果主构造器无参数，小括号可省略，构建对象时调用的构造方法的小括号也可以省略

　　　　?  辅助构造器名称为this（这个和Java是不一样的），多个辅助构造器通过不同参数列表进行区分， 在底层就是构造器重载。

　　　　?  如果想让主构造器变成私有的，可以在()之前加上private，这样用户不能直接通过主构造器来构造对象了。

　　　　?  辅助构造器的声明不能和主构造器的声明一致,会发生错误(即构造器名重复)。

　　　　?  Scala类的主构造器的形参未用任何修饰符修饰，那么这个参数是局部变量。

　　　　?  如果参数使用val关键字声明，那么Scala会将参数作为类的私有的只读属性使用。

　　　　?  如果参数使用var关键字声明，那么Scala会将参数作为类的成员属性使用。

4、Scala中的object

　　object 相当于 class 的单个实例，通常在里面放一些静态的 field 或者 method；

　　==  在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的  ==

　　object作用：

　　　　1.存放工具方法和常量

　　　　2.高效共享单个不可变的实例

　　　　3.单例模式

5、Scala中单例对象

　　?  单例模式是指：保证在整个的软件系统中，某个类只能存在一个对象实例。

　　?  比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，

　　   一般情况下， 一个项目通常只需要一个SessionFactory就够，这是就会使用到单例模式。

　　?  Scala中没有静态的概念，所以为了实现Java中单例模式的功能，可以直接采用类对象(即伴生对象)方式构建单例对象。

6、伴生对象

　　   Scala语言是完全面向对象(万物皆对象)的语言，所以并没有静态的操作(即在Scala中没有静态的概念)。也没有static关键字, 但是为了能够

　　和Java语言交互(因为Java中有静态概念)，就产生了一种特殊的对象来模拟类对象，我们称之为类的伴生对象。这个类的所有静态内容都可以

　　放置在它的伴生对象中声明和调用。

　　  ?  Scala中伴生对象采用object关键字声明，伴生对象中声明的全是 "静态"内容，可以通过伴生对象名称直接调用。

　　  ?  伴生对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。

　　  ?  伴生对象中的属性和方法都可以通过伴生对象名直接调用访问。

　　  ?  从语法角度来讲，所谓的伴生对象其实就是类的静态方法和静态变量的集合。

　　  ?  从技术角度来讲，scala还是没有生成静态的内容，只不过是将伴生对象生成了一个新的类，实现属性和方法的调用。

　　  ?  从底层原理看，伴生对象实现静态特性是依赖于 public static final MODULE$ 实现的。

　　  ?  伴生对象的声明应该和伴生类的声明在同一个源码文件中(如果不在同一个文件中会运行错误!)，但是如果没有伴生类，

　　　  也就没有所谓的伴生对象了，所以放在哪里就无所谓了。

　　  ?  当单例对象的名称跟类名相同的时候，并且单例对象和类同时存在于同一个文件中， 这里这个对象就称之为类的伴生对象。

　　　  类是对象的伴生类。

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

　　举例说明：

package cn.itcast.object_demo

//伴生类
class Dog {
  val id = 1
  private var name = "itcast"
  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

7、main方法

　　  ?  同Java一样，如果要运行一个程序，必须要编写一个包含 main 方法的类；

　　  ?  在 Scala 中，也必须要有一个 main 方法，作为入口；

　　  ?  Scala 中的 main 方法定义为 def main(args: Array[String])，而且必须定义在 object 中；

　　  ?  除了自己实现 main 方法之外，还可以继承 App Trait，然后，将需要写在 main 方法中运行的代码，直接作为 object 的 constructor 代码即可，

　　　  而且还可以使用 args 接收传入的参数；

　　案例说明：

package cn.itcast.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!")
    }
}

//通过继承App的方式可以省略掉main 
//本质上 还是没有省略 App中包含main函数
object Scala_07_object extends App {
  println("hello app")
  println(args(0))
}

Scala面向对象

标签：基本语法   spark   面向对象编程   初始   lin   静态变量   接收   nfa   细节   

原文地址：https://www.cnblogs.com/chen2710/p/12370117.html