Scala学习系列（八）面向对象编程(未更完)_scala面向对象编程案例-优快云博客

本文链接：https://blog.youkuaiyun.com/FreedomZzzzz/article/details/102940978

本文是Scala学习系列的第八篇，主要介绍了Scala中的面向对象编程，包括第一个案例、包声明、import的用法、类的属性（四种访问权限）以及类的方法。详细讲解了伴生类、伴生对象和构造方法的概念，并通过实例展示了类的创建和使用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一.面向对象：第一个案例

package com.zpark.bigdata.scala.chapter06

import com.zpark.bigdata.scala.chapter06.text.Emp


//面向对象
//TODO Scala是一个完全面向对象的语言
object Scala01_Object {
  def main(args: Array[String]): Unit = {
    //创建类的对象
    val user: User = new User()
    val emp = new Emp
    //调用对象的属性和方法
    user.username = "zhangsan"
    println(user.username)
  }
}
class User{
  //类的主体内容：类体
  //声明属性
  
  //TODO 下划线实现的功能是：默认初始化
  var username :String = _
  var age : Int = _
  def login():Boolean = true

}

二.Scala中的包声明

package com.zpark.bigdata.scala.chapter06

//面向对象
//TODO Scala是一个完全面向对象的语言
//Scala中的包声明方式默认与Java中基本一致。但是有其他的使用方式
//1)在同一源码文件中，可以多次声明
//  声明的类在最后那个包中
//  源码中的类所在的位置不需要和包路径相同
//2)scala中所有语法都可以进行嵌套
//  package可以使用小括号，小括号声明的类在这个包中，之外声明的类不在这个包中
//3)scala中可以声明父包和子包，父包中的类，子包可以直接访问，不需要再引入，其实就是作用域的概念
//4)scala中的package可以声明类，但是无法声明变量和函数（方法）
//5)scala为了弥补不足，使用了包对象的概念,其中可以声明属性和方法


package text{
   class Emp {

}
  package object text{
    val text = "123"
    def text1() ={

    }
  }
  package text1{
    object Scala02_Package {
      def main(args: Array[String]): Unit = {
        //println("xxxxx")
        val emp = new Emp
        println(emp)
      }
    }
  }
}

三.Scala中的import

import 用于导入类

package com.zpark.bigdata.scala.chapter06

//TODO import 用于导入类
//1)import 可以在任意的地方使用
//2)import 可以导入一个包中的所有类，采用下划线代替星号
//import java.util._
//3)import 导入相同包的多个类，采用大括号进行包含处理
//import java.util.{ArrayList,List,Date}
//4)import 可以采用特殊的方式来隐藏指定类：{类名=>_}
//import java.util.{Date=>_}
//5)import 可以真正的导入包
//6)scala可以在导入类的时候给类起别名
import java.util.{HashMap=>JavaHashMap}


object Scala03_Import {
  def main(args: Array[String]): Unit = {
    //import java.util.Date

    //val date = new java.util.Date()
    //println(date)

     val map = new JavaHashMap()
    println(map)
  }
}

scala 中如果想要从最开始的包中查找类，需要增加绝对路径，使用_root_开头

package com.zpark.bigdata.scala.chapter06

//scala 中如果想要从最开始的包中查找类，需要增加绝对路径，使用_root_开头
package java{
  package util{
    class HashMap{

    }

    object Scala04_Import01 {
      def main(args: Array[String]): Unit = {
        val map = new _root_.java.util.HashMap()
        println(map)

      }
    }
  }
}

四.Scala中的类的属性

package com.zpark.bigdata.scala.chapter06

import scala.beans.BeanProperty

//TODO 类的属性
object Scala05_Field {
  def main(args: Array[String]): Unit = {

    val user = new User
    //getter
    println(user.username)
    //setter
    user.username = "zhangsan"

//    user.setAddress()
    //user.getAddress


  }
}
class User{

  //类的声明属性
  //下划线是让系统默认初始化   值为null
  //scala中给类声明的属性，默认为私有的，但是提供了公共的setter和getter方法
  var username : String = _

  //如果给属性增加private修饰符，那么属性无法在外部访问，因为底层生成的getter和setter方法都是私有的
  private var age : Int = _

  //如果声明的属性使用val，那么属性为私有的，并且使用final修饰，底层只提供getter方法，而没有setter方法
  val email : String = " "

  //scala为了和java bean规范统一，scala提供了注解，生成了java中对应的set，get方法
  @BeanProperty var address : String = _
}

//TODO scala中也有四种访问权限
//1)public 是默认访问权限，没有关键字
//2)protected 访问权限只能子类访问，同包访问不了
//3)private 私有访问权限，只能当前类访问
//4)包访问权限需要特殊的语法规则：private[包名]
/*
package p1{
  package p2{
    class Userp2{
      var username = "zhangsan"
      private var password = "123456"
      protected var email = "@qq.com"
      private [p3] var address = "xxxxxx"

    }
  }
  package p3{

    import com.zpark.bigdata.scala.chapter06.p1.p2.Userp2

    class Emp3 extends Userp2{
      def test(): Unit ={
        val user = new Userp2
        user.email
      }
    }

  }
}

 */

scala中四种访问权限

//TODO scala中也有四种访问权限
//1)public 是默认访问权限，没有关键字
//2)protected 访问权限只能子类访问，同包访问不了
//3)private 私有访问权限，只能当前类访问
//4)包访问权限需要特殊的语法规则：private[包名]

package p1{
package p2{
class Userp2{
var username = "zhangsan"
private var password = "123456"
protected var email = "@qq.com"
private [p3] var address = "xxxxxx"

}
}
package p3{

import com.zpark.bigdata.scala.chapter06.p1.p2.Userp2

class Emp3 extends Userp2{
def test(): Unit ={
val user = new Userp2
user.email
}
}

}
}

五.类的方法

1.所谓的方法，就是类中声明的函数，所以声明方式和函数一样

package com.zpark.bigdata.scala.chapter06

//TODO 类的方法
//所谓的方法，就是类中声明的函数，所以声明方式和函数一样
object Scala06_Method {
  def main(args: Array[String]): Unit = {
    //创建对象
    //val user = new User06
    //val str:String = user.+("xxxx")
    //println(str) //输出：com.zpark.bigdata.scala.chapter06.User06@4cdbe50fxxxx
    //user.login()
  }
}
class User06{
  //登录
  def login(): Unit ={

  }

  //登出
  def logout(): Boolean ={
    true
  }
}

2. 伴生类，伴生对象

package com.zpark.bigdata.scala.chapter06

//TODO 伴生类(成员)
//伴生类中的东西都是通过对象来访问的
class Student {
  private val  name = "zhangsan"
}

//TODO 伴生对象(静态)
//伴生对象中的东西都是通过类名来访问的
//伴生对象可以访问伴生类的私有属性
//创建伴生类对象，需要提供特殊的方法，实现相应的功能
object Student{

  //scala自动识别apply方法，用于创建伴生类对象
  def apply(s:String): Student = new Student()

  def test(): Unit ={
    
    //new Student().name

  }
}

3.采用伴生对象来创建伴生类

package com.zpark.bigdata.scala.chapter06

object Scala07_Method01 {
  def main(args: Array[String]): Unit = {

    //采用伴生对象来创建伴生类
    val student = Student("wangwu")
    //等同于编译器自动调用了一下 student.apply  这个方法

    println(student)
  }
}

4.构造方法

package com.zpark.bigdata.scala.chapter06


//TODO 构造方法

object Scala08_Method02 {
  def main(args: Array[String]): Unit = {
    //创建对象
    val user = new User08()
    //println(user)
  }
}

//TODO scala中构造方法分为两类：主构造方法 & 辅助构造方法
//scala构造对象可以通过辅助构造方法创建，但是必须调用主构造方法
//scala是一个完全面向函数的语言，所以类也是函数
//类是函数，可以使用小括号作为函数的参数列表
//类所代表的函数其实就是这个类的构造方法
//默认情况下，scala也是给类提供无参构造方法，所以小括号可以省略
//在类后面声明的构造方法就是主构造方法
//在主构造方法中声明的构造方法就是辅助构造方法
class User08(s:String){
  //类体 & 构造方法体
    println("主构造方法")
    println(s)

  def this(s:String,ss:String){
    this(s)
    println("辅助构造方法2")
  }

  //声明辅助构造方法，方法名为this
  //TODO 构造方法调用其他构造方法时，应该保证被调用的构造方法已经声明过
  def this(){
    this("辅助构造方法1","xxxxxx")
  }

}

5.类

package com.zpark.bigdata.scala.chapter06

//TODO 类
object Scala09_Class {
  def main(args: Array[String]): Unit = {
        val user = new User09()
        //user.test()

    val user1:Person = new User09()
        user1.test1()
  }
}
//声明类
//父类，继承
//类可以声明为抽象的 abstract
//TODO 抽象方法和类的关系
//如果一个类中有抽象方法，那么这个类一定是抽象类。如果一个类是抽象类，它里面的方法不见得是抽象方法。
 abstract class Person{
      var name : String = _

     //声明抽象方法，方法只有声明，没有实现，不需要abstract关键字声明
     def test()

     def test1(): Unit ={
       println("person test1.......")
     }
}
class User09 extends Person{

  //子类继承抽象的父类    需要重写抽象方法：补全方法
  def test(): Unit ={
    println("xxxxxxxxx")
  }

  //TODO scala如果子类重写父类的方法（不是抽象），需要增加Override关键字
   override def test1(): Unit ={
     println("child test1.........")
   }
}