专栏首页python3Scala 学习之面向对象(3)

Scala 学习之面向对象(3)

==> 类

        ---> 类的定义

class Student{
    // 定义属性
    private var stuName:String = "Tom"
    private vat stuAge:Int = 18
    
    // 定义方法
    def getStuName():String = stuName
    def setStuName(newName:String) = {
        this.stuName = newName
    }
    
    
}

        ---> 伴生类和伴生对象    object 相当于 Java 中的 static

            ---- object 对象可以跟类名不一样,如果跟类名一样,这个对象就是该类的伴生对象,反之,这个类就是这个伴生对象的伴生类

        ---> set 和 get 方法  

            ---- Scala 中,会自动给 private 定义的属性生成get和set 方法,使用 val 可以使其只生成 get 方法,而不会生成set 方法

            ---- 在定义变量时使用 this 关键字,可以使其成为此类的私有属性,不会生成 get 和 set 方法,如:

 // 定义正常的属性,可自动生成get 和 set  方法
 private var aaa:String = "hello"
 
 // 定义只可自动生成 get 方法的属性
 private val aaa:String = "hello"
 
 // 使用this 关键字,使其定义的属性成为此类的私有属性,不允许外界访问
 private[this] var aaa:String = "hello"

        ---> 嵌套类(内部类)

            ---- 内部类中的参数可以当做类的参数传递

        ---> 类的构造器

            ---- 主构造器 和类的声明在一起,只能有一个主构造器

class Student(val stuName: String, val stuAge: Int){

}

object Student{
    def main(args: Array[String]): Unit = {
        var stu = new Student("Tom", 20)
        println(stu.stuName + "\t" + stu.stuAge)
    }
}

            ---- 辅助构造器  可以有多个辅助构造器,使用 this 关键字

class Student(val stuName:String, val stuAge:Int){
    // 定义一个辅助构造器
    def this(age:Int){
    // 调用主构造器
    this("No Name", age)
    }
}

object Student{  // 
    var stu = new Student(22)
    println(stu.stuName + "\t" + stu.stuAge)
}    // 输出结果为 NoName   22

        ---> Object 对象: 相当于 Java 中的 static 关键字

            ---- 单例模式: 一个类只有一个对象

// 生成信用卡的卡号
object CreditCard{
    // 定义变量: 保存信用卡的卡号
    // 该属性只属于该对象 
    private[this] var creditCardNumbe:Long = 0
    
    // 产生卡号
    def generateNewCCNumber():Long = {
        creditCardNumbe += 1
        creditCardNumber
    }
    
    // 测试程序
    def main(args:Array[String]): Unit = {
    // 得到新的卡号
        println(CreditCard.generateNewCCNumber)
        println(CreditCard.generateNewCCNumber)
        println(CreditCard.generateNewCCNumber)
        println(CreditCard.generateNewCCNumber)
    }
}

            ---- 应用程序对象: App   ----- 可以省略 main 方法

object testApp extends App {
    // 省略了 main 方法,可以直接将结果输出
    println("hello")
}

        ---> 类的 apply 方法

            ---- 作用: 创建对象时,省略 new 关键字,需要定义在类的伴生对象中

class Student(stuName:String){

}

object Student{
    // 定义 apply 方法,必须定义在类的伴生对象中
    def apply(stuName: String) = {
        // 调用主构造器
        new Student(stuName)
    }
    def main(args: Array[String]): Unit = {
        var stu = Student("Tom")
    }
}

==> 继承

        ---> 简单继承

// 测试
object DemoExtends{
  def main(args: Array[String]): Unit = {
    // 创建一个 Person 对象
    val p1:Person = new Person("Tom", 20)
    println(p1.sayHello())            // My name is Tom,age is 20

    // 创建一个子类
    val p2:Person = new Employee("Marry", 32, 1233)
    println(p2.sayHello())            // 子类中的 sayHello

    // 创建一个匿名子类
    val p3:Person = new Person("Jerry", 33){
      override def sayHello(): String = "匿名函数中的 sayHello 方法"
    }
    println(p3.sayHello())            // 匿名函数中的 sayHello 方法
  }
}
// 父类
class Person(val name:String, val age:Int){
  def sayHello():String = "My name is " + name + ",age is " + age
}

// 子类    如果需要子类的值覆盖父类的值,需要加上 override 参数
class Employee(override val name:String, override val age:Int, val salary:Int) extends Person(name, age){
  override def sayHello(): String = "子类中的 sayHello"
}

        ---> 继承抽象类和抽象字段

object TestExtendsDemo {
  def main(args: Array[String]): Unit = {
    var apple:Fruit = new Apple()
    var orange:Fruit = new Orange()

    println(apple.name())        // 结果为 apple
    println(orange.name())        // 结果为 orange

  }
}

abstract class Fruit{
  var id:Int
  def name():String
  
}

class Apple extends Fruit{
   // 实现抽象字段
   var id:Int = 1
  // 实现抽象方法
  def name():String = {
    "apple"
  }

}

// 可以通过构造方法对抽象字段进行处理
class Orange() extends Fruit{
  def name:String = {
    "orange"
  }

}

        ---> 特质trait: 有点像接口,也有点像抽象类    支持多重继承,可以定义抽象方和字段,也可以定义完整的方法和字段

object Demo1 {

  def main(args: Array[String]): Unit = {
    var com:Computer = new Computer(1)
    println(com.run())
    println(com.movedown())
  }

}

class Computer(var monitorid:Int) extends Monitor with Mouse with Keyboard {
  def run():String = {
    "running"
  }

  def moveup(): String = {
    "moveup"
  }

  override def movedown(): String = {
    "movedown"
  }

  override def press(): String = {
    "press"
  }

}

trait Monitor{
  var monitorid:Int
  def run():String

}

trait Mouse{
  def moveup():String
  def movedown():String
}

trait Keyboard{
  def press():String
}

==> 包的定义和使用

        ---> 包的定义:

// 定义格式一
package com.mytest
class Demo{}

// 定义格式二
package com.mytest{
    class Demo{}
}

        ---> 包的使用(引入):

import com.mytest.Demo        // 可以不写Demo 的全路径
import com.mytest._            // 引入mytest 包下所有的属性
import com.mytest.Demo._        // 引入 Demo 类中所有的属性

==> 包对象

package object MyPackageDemo{
    // 常量
    val a:Int = 1
    // 变量
    var a:String = "hello"
    // 方法
    def Demo():String = {
        "Demo"
    }
    // 类
    class Demo{
        
    }
    // 对象 object
    object Demo{
    
    }
    // trait(特质)
    trait Demo{
    
    }
}

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • python3:装饰器的5大用法总结

    装饰器,顾名思义,就是给函数作装饰作用的,相当于只是给函数化了一个装,并没有给他添加额外的代码,但是却增加了新功能,就如同我们在冬天很冷的情况下,想要变暖和(添...

    py3study
  • ubuntu - sublime tex

    在网上可以找到比较多的用于解决fcitx在st3无法输入中文的问题的方法,但是用于ibus的解决方法较少

    py3study
  • python 进程池pool简单实例

       在利用Python进行系统管理的时候,特别是同时操作多个文件目录,或者远程控制多台主机,并行操作可以节约大量的时间。当被操作对象数目不大时,可以直接利用m...

    py3study
  • Scala学习笔记

    3、方法的声明格式 def(x:Int,y:Int) : Int ={} 最后一个冒号后面是返回类型,不加则没有返回值

    用户3003813
  • Scala学习笔记(二)

    声明类(一个源文件中可以包含很多public的类) getter和setter 构造函数(主构造器和附属构造器) 继承(extends) 重写父...

    chaplinthink
  • Zzreal的大数据笔记-ScalaDay02

    昨天整理了一下Scala的一些基本内容,不是很全面,不过作为学习Spark的基础足够了, 如果需要系统的学习Scala,建议还是去菜鸟教程一步步的看下来会比较条...

    企鹅号小编
  • Spock 测试框架的介绍和使用详解

    Spock 框架是一个基于groovy语法的测试框架,由于使用groovy,所以使用起来比 junit 更加灵活,测试用例的写法更加简单易懂,一目了然。

    yawn
  • Akka(18): Stream:组合数据流,组件-Graph components

       akka-stream的数据流可以由一些组件组合而成。这些组件统称数据流图Graph,它描述了数据流向和处理环节。Source,Flow,Sink是最基础...

    用户1150956
  • 树莓派上运行RT-Thread并通过esp8266连接网络

    树莓派上使用网络也是一个非常重要的功能,有了网络之后,可以在树莓派上扩展的功能更加丰富了。本文主要是通过树莓派上接8266模块,利用rt-thread的AT网络...

    bigmagic
  • SparkContext源码阅读

    SparkContext是spark的入口,通过它来连接集群、创建RDD、广播变量等等。

    用户3003813

扫码关注云+社区

领取腾讯云代金券