Scala-面向对象引入（包、类和对象）

open_test01

已于 2023-02-24 11:30:26 修改

阅读量550

点赞数 1

分类专栏： Scala 文章标签： scala java 开发语言

于 2023-02-24 10:09:14 首次发布

本文链接：https://blog.csdn.net/dafsq/article/details/129193831

版权

Scala 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

包

Scala 包的三大作用（和 Java 一样）：

区分相同名字的类
当类很多时，可以很好的管理类
控制访问范围

基本语法

 package 包名

Scala 有两种包的管理风格，一种方式和 Java 的包管理风格相同，每个源文件一个包（包名和源文件所在路径不要求必须一致），包名用“.”进行分隔以表示包的层级关系，如 com.pp.scala。另一种风格，通过嵌套的风格表示层级关系。

//使用嵌套风格定义包
package com {

  import com.pp.scala.Inner

  //在外层包中定义单例对象
  object  Outer{
    //外层包定义变量
    var out = "out"
    def main(args: Array[String]): Unit = {
      //在外层不能直接访问内层 如要访问则需要导包
      println(Inner.inner)
    }
  }

  package pp{

    package scala{

      //在内层包中定义单例对象
      object Inner{
        //内层包定义变量
        var inner = "inner"
        def main(args: Array[String]): Unit = {
          //内层包中可以直接访问外层包的东西
          println(Outer.out)
          //可更改外部包的变量
          Outer.out = "Inner"

          println(Outer.out)
        }
      }
    }
  }
}

包对象

在 Scala 中可以为每个包定义一个同名的包对象，定义在包对象中的成员，作为其对应包下所有 class 和 object 的共享变量，可以被直接访问。

在包对象中定义共享属性

在同名包下的Obj文件中实现访问

导包

和 Java 一样，可以在顶部使用 import 导入，在这个文件中的所有类都可以使用。
局部导入：什么时候使用，什么时候导入。在其作用范围内都可以使用
通配符导入：import java.util._
给类起名：import java.util.{ArrayList=>JL}
导入相同包的多个类：import java.util.{HashSet, ArrayList}
屏蔽类：import java.util.{ArrayList =>_,_}
导入包的绝对路径：new _root_.java.util.HashMap

Scala 中的三个默认导入分别是：

import java.lang._
import scala._
import scala.Predef._

类和对象

一般，一个.java 有一个 public 类

注意：Scala 中没有 public，一个.scala 中可以写多个类。

Scala 语法中，类并不声明为 public，所有这些类都具有公有可见性（即默认就是 public）

object cll {
  def main(args: Array[String]): Unit = {
    //创建对象测试
    var stu = new student()
    println(stu.getName)
    println(stu.getAge)
  }

}

//定义一个类
class student {

  //实现JavaBean的方法则要声明注解
  //如果要定义成私有的则可加上private修饰符
  private val aa : String = "定义私有属性"
  @BeanProperty
  //定义属性
  val name: String = "aaa"
  @BeanProperty
  val age : Int = 10
  
}

方法和构造器

方法：

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

构造器：

和 Java 一样，Scala 构造对象也需要调用构造方法，并且可以有任意多个构造方法。

Scala 类的构造器包括：主构造器和辅助构造器

class 类名(形参列表) { // 主构造器
 // 类体
 def this(形参列表) { // 辅助构造器
 }
 def this(形参列表) { //辅助构造器可以有多个...
 }
}

辅助构造器，函数的名称 this，可以有多个，编译器通过参数的个数及类型来区分。
辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。
构造器调用其他另外的构造器，要求被调用构造器必须提前声明。

object gou {
  def main(args: Array[String]): Unit = {
    //创建对象
    val s1 = new Student
    println(s1.name)
    //传参创建对象
    val s2 = new Student("b",20)
    
  }
}

//定义一个类
class Student(){
  //定义属性
  var name : String = "a"
  var age : Int = 1
  println("主构造方法被调用")

  //声明辅助构造方法
  def this(name : String){
    this() //直接调用主构造器
    println("辅助造方法1被调用")
    this.name = name
    println(s"$name $age")
  }
  def this(name : String , age : Int){
    //方法重载
    this(name)
    println("辅助造方法2被调用")
    this.age = age
    println(s"$name $age")
  }
}

构造器参数：

Scala 类的主构造器函数的形参包括三种类型：未用任何修饰、var 修饰、val 修饰

未用任何修饰符修饰，这个参数就是一个局部变量

object gou {
  def main(args: Array[String]): Unit = {
    val student2 : Student2 = new Student2("cc",20)
    //调用方法
    student2.Printt()
  }
}

//定义一个类
//主构造器无修饰
class Student2(name : String,age : Int){ //相当于已定义属性
  def Printt(): Unit ={
    println(name)
    println(age)
  }
}

var 修饰参数，作为类的成员属性使用，可以修改

object gou {
  def main(args: Array[String]): Unit = {
  val s : Student1 = new Student1("name",12)
    println(s.age)
    println(s.name)
  }
}

//定义一个类
class Student1(var name : String,var age : Int){ //相当于已定义属性
}