scala对象

最新推荐文章于 2024-04-28 21:03:00 发布

zhaoxiaoba123

最新推荐文章于 2024-04-28 21:03:00 发布

阅读量147

点赞数

文章标签： scala

本文链接：https://blog.csdn.net/zhaoxiaoba123/article/details/108575909

版权

1、面向对象概述
在这里插入图片描述
2、类的定义和使用
package com.imooc.scala.scala4

object class_use {

def main(args: Array[String]): Unit = {
//调用人的类
val people = new People
//给people（人）类里面的属性name（姓名）赋值
people.name = “张三”
//调用people（人）类里面的属性 name 和年龄
println(people.name + " … " + people.age)

//调用people（人）类里面的 eat(吃饭)方法
println("窗边的那个 " + people.eat())

//调用people（人）类里面的 watchFootball(看球)方法
people.watchFootball("NBA的比赛")

//调用people（人）类里面的 printInfo(性别)方法
people.printInfo

}
}

/**

定义一个人的类
*/
class People {

//定义类属性
//在java中get和set方法需要我们自己去定义
//在scala中回自动给我们定义好了get和set方法
//val只有get方法
//var有get和set
// _ 为占位符
var name:String = _
val age:Int = 10

//private [this] 修饰的属性只能在本类中使用，外部是直接使用不了的
private [this] val gender = “男性”
//定义人的吃饭方法
def eat():String = {
name + “正在吃饭…”
}

//定义人的看球的方法
def watchFootball(teamName:String): Unit ={
println(name + “正在看” + teamName)
}

//定义人的性别方法
def printInfo: Unit ={
println("王五的性别是 " + gender)
}
}
3、主构造器和附属构造器
package com.imooc.scala.scala4

/**

主构造器和附属构造器
*/
object ConstructorApp {
def main(args: Array[String]): Unit = {
//传两个参数的主构造器
val person = new Person(“张三”,12)
println(person.name + “;” + person.age + “:” + person.school)

//传三个参数的附属构造器
val person2 = new Person(“张三”,12)
println(person2.name + “;” + person2.age + “:” + person2.school + “:” + person2.gender)
}
}

//val name:String, val age:Int 这些就叫做主构造器
class Person(val name:String, val age:Int){
println(“人类（Person）开始。。。。。。”)
val school:String = “北京人民大学”
var gender:String = “重点大学”
println(“人类（Person）结束。。。。。。”)

//附属构造器,主构造器有的附属构造器在用就可以不加val，附属构造器还可以添加自己的属性
def this(name:String,age:Int,gender:String){
this(name,age)//附属构造器的第一行必须调用主构造器或者其他附属构造器
this.gender =gender
}

}
4、继承
package com.imooc.scala.scala4

/**

主构造器和附属构造器
*/
object ConstructorApp {
def main(args: Array[String]): Unit = {
// //传两个参数的主构造器
// val person = new Person(“张三”,12)
// println(person.name + “;” + person.age + “:” + person.school)
//
// //传三个参数的附属构造器
// val person2 = new Person(“张三”,12)
// println(person2.name + “;” + person2.age + “:” + person2.school + “:” + person2.gender)

//学生主构造器
val student = new Student(“马六”,18,“计算机”)
println(student.name + “:” + student.age + “:” + student.zhuanye)

//学生附属构造器
val student2 = new Student(“马六”,20,“计算机”,100)
println(student2.name + “:” + student2.age + “:” + student2.zhuanye + “:” + student2.fenshu)
}
}

//人的类（Person）
//val name:String, val age:Int 这些就叫做主构造器
class Person(val name:String, val age:Int){
println(“人类（Person）开始。。。。。。”)
val school:String = “北京人民大学”
var gender:String = “重点大学”
println(“人类（Person）结束。。。。。。”)

}

//创建一个学生类（student）继承人类（Person）
//继承用函数 extends 子类继承父类，父类有的属性子类可以不写var 父类没有的定义时一定要写var
class Student(name:String, age:Int, var zhuanye:String) extends Person(name, age) {
println(“学生类（student）开始。。。。。。”)
var fenshu:Int = _
println(“学生类（student）结束。。。。。。”)

def this(name:String,age:Int,zhuanye:String,fenshu:Int){
this(name,age,zhuanye)
this.fenshu=fenshu
}
}

5、重写
package com.imooc.scala.scala4

/**

主构造器和附属构造器
*/
object ConstructorApp {
def main(args: Array[String]): Unit = {
// //传两个参数的主构造器
// val person = new Person(“张三”,12)
// println(person.name + “;” + person.age + “:” + person.school)
//
// //传三个参数的附属构造器
// val person2 = new Person(“张三”,12)
// println(person2.name + “;” + person2.age + “:” + person2.school + “:” + person2.gender)

//学生主构造器
val student = new Student(“马六”,18,“计算机”)
println(student.name + “:” + student.age + “:” + student.zhuanye)

//学生附属构造器
val student2 = new Student(“马六”,20,“计算机”,100)
println(student2.name + “:” + student2.age + “:” + student2.zhuanye + “:” + student2.fenshu)

//学生主构造器从写主类人的类（Person）的学校属性后
val student3 = new Student(“马六”,18,“计算机”)
println(student3.name + “:” + student3.age + “:” + student3.zhuanye + “:” + student3.school)

println(student)
}
}

}

//重写父类人类（Person)的属性school
override val school:String = “父哦罗伦啥大学”

var fenshu:Int = _
println(“学生类（student）结束。。。。。。”)

def this(name:String,age:Int,zhuanye:String,fenshu:Int){
this(name,age,zhuanye)
this.fenshu=fenshu
}

//重写toString
override def toString: String = “Person: …”

}
6、抽象类
package com.imooc.scala.scala4

/**

抽象类，抽象类就是类的一个或者多个方法没有完整的实现（只有定义，没有实现）
抽象类不能被实例化，只能被继承，然后实现抽象类中的所有方法和属性
*/
object AbstractAPP {
def main(args: Array[String]): Unit = {
val person4 = new Person4()
println(person4.name + person4.age)
person4.speak()
}
}

//定义一个抽象的人的类Person
abstract class Person3{
val name:String
val age:Int

def speak(): Unit ={

}
}

//定义一个继承人类抽象类Person
class Person4 extends Person3{
override val name: String = “_”
override val age: Int = 10

override def speak(): Unit = {
println("--------------------------")
}
}
7、伴生类和伴生对象
在这里插入图片描述
8、apply方法
package com.imooc.scala.scala4

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

//通常我们在调用class的时候，需要new 这个类来做初始化
//对象不需要，直接 对象名 加 方法名 或者 属性名 就可以调用

// for(i <- 1 to 10){
// ApplyTest.incr
// }
//
// println(ApplyTest.count)
//这个东西ApplyTest()从表面是不是看不出来是啥
//因为我们又同名字的orject和class
//那我们运行下看看这个是怎么执行的
//他默认走的是object ApplyTest 下我们创建的apply方法，这个方法中我们初始化了类ApplyTest
//如果我们相同名字ApplyTest里面也有apply方法，默认走的还是object ApplyTest 下我们创建的apply方法，而不是类中的
val b = ApplyTest()
b()

//如果我们初始化类
val c = new ApplyTest()
println(c)
c()  //现在我们把 new 过后的类 c = new ApplyTest() 给加上C() 他走的是ApplyTest 类下的 apply

//总结：类名()= 走的是 object.apply
//总结：对象()= 走的是 class.apply

}

/**

伴生类和伴生对象
如果又一个class,还有一个于class同名的object
那么就称这个object是class的伴生对象，class是object的伴生类
*/

//伴生类
class ApplyTest{
def apply(): ApplyTest = {
//在伴生对象中创建了一个apply方法，又在这个方法中初始化了ApplyTest类
println(“class ApplyTest apply。。。。。。。。”)
new ApplyTest()
}
}

//伴生对象
object ApplyTest{
println(“object ApplyTest 开始。。。。。。。。”)

var count = 0

//对象下的求和方法
def incr = {
count = count + 1 //说明object是个单例的对象
}

def apply(): ApplyTest = {
//在伴生对象中创建了一个apply方法，又在这个方法中初始化了ApplyTest类
println(“object ApplyTest apply。。。。。。。。”)
new ApplyTest()
}

println(“object ApplyTest 结束。。。。。。。。”)

}
9、case class
package com.imooc.scala.scala4

/**