2023_Spark_实验五:Scala面向对象部分演示(一)(IDEA开发)

1、面向对象的基本概念

把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象,面向

对象的三大特征:

  •  封装

  •  继承

  •  多态

2、类的定义

简单类和无参方法


class Counter{

private var value =0;

def increment() { value+=1};

def current() =value;

}



//注意:class 前面没有public 关键字修饰

如果要开发main方法,需要将main方法定义在该类的伴生对象中,即:object对

象中,(后续做详细的讨论):


class Counter{

private var value =0;

def increment() { value+=1};

def current() =value;

}



//Scala 中类的定义

class Student1{

//定义属性

private var stuName:String = "Tom"

private var stuAge:Int =20



//成员方法

def getStuName():String = stuName

def setStuName(newName:String) =this.stuName=newName



def getStuAge():Int = stuAge

def setStuAge(newAge:Int) = this.stuAge=newAge

}



object student {

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

//测试student1

var s1 = new Student1



//第一次输出

println(s1.getStuName() + "\t" + s1.getStuAge())



//调用set方法

s1.setStuName("Mary")

s1.setStuAge(25)



//第二次输出

println(s1.getStuName() + "\t" + s1.getStuAge())



//第三次输出

// println(s1.stuName + "\t" + s1.stuAge)



}

}

3、属性的getter和setter方法

当定义属性是private时候,scala会自动为其生成对应的get和set方法,如下所

示:

private var stuName:String = "Tom"

get方法: stuName ----> s2.stuName() 由于stuName是方法的名字,所

以可以加上一个括号

set方法: stuName_= ----> stuName_= 是方法的名字

定义属性:private var money:Int = 1000 希望money只有get方法,没有

set方法??

办法:将其定义为常量private val money:Int = 1000

private[this]的用法:该属性只属于该对象私有,就不会生成对应的set和

get方法。如果这样,就不能直接调用,例如:s1.stuName ---> 错误


//属性的get 和 set 方法

/*

1.当定义属性是private 时候,scala会自动为其生成对应的get 和set方法

private var stuName:String = "Tom"

(1) get 方法:stuName ----> s2.stuName()

(2) set 方法:stuName_=



2.定义属性:private var money:Int = 1000 希望money只有get方法,没有set方法?

方法:将其定义为常量private val money:Int = 1000



3.private[this]

3.private[this]的方法:该属性只属于该对象私有,就不会生成对应的set和get方法

*/



class Student2 {

//定义属性

private var stuName:String = "Tom"

//private [this] var stuAge:Int =20

private var stuAge:Int = 20

private val money:Int = 1000



}



//测试

object Student2 {



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

var s2 = new Student2

println(s2.stuName + "\t" + s2.stuAge)

println(s2.stuName + "\t" +s2.stuAge + "\t" + s2.money)



//修改money的值 --》 error

//s2.money = 2000



}

}

4、内部类(嵌套类)

我们可以在一个类的内部在定义一个类,如下:我们在Student类中,再定义了

一个Course类用于保存学生选修的课程:


import scala.collection.mutable.ArrayBuffer



//嵌套类:内部类

class Student3 {

//定义一个内部类:记录学生选修的课程信息

class Course(val courseName:String,val credit:Int){

//定义其他方法

}

private var stuName:String = "Tom"

private var stuAge:Int = 20

//定义一个ArrayBuffer记录学生选修的所有课程

private var courseList = new ArrayBuffer[Course]()

//定义方法往学生信息中添加新的课程

def addNameCourse(cname:String,credit:Int): Unit ={

//创建新的课程

var c = new Course(cname,credit)

//将课程加入list

courseList += c

}

}



//测试

object Student3 {

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

//创建学生对象

var s3 = new Student3

//给该学生添加新的课程

s3.addNameCourse("Chinese",2)

s3.addNameCourse("English",3)

s3.addNameCourse("Math",4)

//输出

println(s3.stuName + "\t" + s3.stuAge)

println("*********选修课程***********")

for (s <-s3.courseList) println(s.courseName + "\t" + s.credit)

}



}

5、类的构造器

类的构造器分为:主构造器、辅助构造器

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

Student4(val stuName:String,val stuAge:Int)

(1) 定义类的主构造器:两个参数

(2) 声明了两个属性:stuName和stuAge 和对应的get和set方法

辅助构造器:可以有多个辅助构造器,通过关键字this来实现


/*

类的构造器

1.主构造器:和类的声明结合在一起;只能有一个主构造器

Student4(val stuName:String,var stuAge:Int)

(1)定义类的主构造器:两个参数

(2)声明了两个属性:stuName和stuAge 和 对应的get 和 set 方法

2.辅助构造器:可以有多个辅助构造器

通过关键字this 来实现

*/



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

//定义辅助构造器

def this(age:Int){

//调用主构造器

this("no name",age)

}

}



object Student4 {

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

//创建Student4的一个对象

var s4 = new Student4("Tom",20)

println(s4.stuName + "\t" +s4.stuAge)



//创建一个新的Student4 的对象

var s42 = new Student4(25)

println(s42.stuName + "\t" + s42.stuAge)

}



}

6、Scala中的Object对象

Scala没有静态的修饰符,但Object对象下的成员都是静态的 ,若有同名的

class,这其作为它的伴生类。在Object中一般可以为伴生类做一些初始化等操

作。下面是Java中的静态块的例子。在这个例子中,我们对JDBC进行了初始化:

而Scala中的Object就相当于Java中静态块。

在 Scala 中,是没有 static 这个东西的,但是它也为我们提供了单例模式的

实现方法,那就是使用关键字 object。

Scala 中使用单例模式时,除了定义的类之外,还要定义一个同名的 object 对

象,它和类的区别是,object对象不能带参数。

当单例对象与某个类共享同一个名称时,他被称作是这个类的伴生对象:

companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为

是这个单例对象的伴生类:companion class。类和它的伴生对象可以互相访问

其私有成员。

Object对象的应用

单例对象


//利用object 对象实现单例模式

object CreditCard {

//变量保存信用卡号,这里比较好的做法,是定义成private[this],即:该属性只属于该对象,这个方法由于定义在object中,所以是静态的,即:单例的



private[this] var creditCardNumber:Long = 0



//产生新的卡号

def generateNewCCNumber():Long = {

creditCardNumber += 1

creditCardNumber

}

//测试程序

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

//产生新的卡号

println(CreditCard.generateNewCCNumber())

println(CreditCard.generateNewCCNumber())

println(CreditCard.generateNewCCNumber())

println(CreditCard.generateNewCCNumber())

}

}

使用应用程序对象:可以省略main方法;需要从父类App继承。


//使用应用程序对象,可以省略main方法

object HelloWorld extends App{



/*

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

//这里的main就可以不写。相当于下面的代码是在main方法中执行的。

}

*/

println("Hello World")

///如何取得命令行的参数

if(args.length > 0) {

println(args(0))

}else{

println("no arguents")

}

}

你可能感兴趣的:(Scala,Spark实验,IDEA,spark,scala,intellij-idea)