scala类的介绍与操作02

最新推荐文章于 2024-07-26 16:01:19 发布
最新推荐文章于 2024-07-26 16:01:19 发布
阅读量264 收藏
点赞数
分类专栏： # scala 文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39331255/article/details/111350009
版权

1. 类的基本操作

1.1. 类的定义

object _01ClassOps {
	def main(args: Array[String]): Unit = {
		/*
			scala中类对应对象的构建，和java一模一样 使用关键字new，
			以及构造函数来完成实例的创建
			scala可以使用默认的无参构造器完成实例创建，
			同时一类如果有无参构造器，在创建对象的时候，可以省略掉()
		 */
		val p = new Person()
//		val p1 = new Person

//		p.name =
		p.setName("刘嘉豪")
		p.setAge(169)

		p.show()
	}
}


class Person {
	/*
		_的作用就相当于java中private String name代表默认值;
		如果要使用_,前面的成员变量就应该指定数据类型
	 */
	private var name:String = _

	private var age = 13
	def show(): Unit = {
		println(s"name=${name}\tage=${age}")
	}

	def setName(name:String):Unit = {
        //成员变量和局部变量命名冲突之后使用this关键字来进行区分
		this.name = name
	}

	def getName() = this.name
	//单行函数
//	def setAge(age:Int) = this.age = age
	def setAge(age:Int): Unit = {
		if(age < 0 || age > 150) {
			throw new RuntimeException("地球不欢迎你~")
		}
		this.age = age
	}

	def getAge = this.age
}

1.2. 类的构造

​ scala中有两类构造器——主构造器和辅助构造器。

object _02ConstructorOps {
	def main(args: Array[String]): Unit = {
		val p = new Person("华勇", 23)
		p.show()
	}
}

class Person() {

	private var name:String = _

	private var age:Int = _

	def Person(): Unit = {
		println("--Person()--是默认的构造器吗？")
	}

	//自定义构造器 自定义构造器的第一句话必须要调用其它构造器
	def this(name:String, age:Int) {
		this()
		this.name = name
		this.age = age
		println("---------this(name:String, age:Int)---------")
	}


	println("-------------构造器~----------------")
	def show(): Unit = {
		println(s"name=${name}\tage=${age}")
	}
}

本例中的这个和类的定义交织在一起的默认的构造器，是scala类中最重要的一个构造器——主构造器（默认的构造器是无参主构造器，定义在类名和类的{之间，省略了()）。

其余的自定义构造器，也就是在类中通过def this(xxx)定义的构造器称之为辅助构造器，同时辅助构造器的第一句话，必须要通过this来调用本类主构造器或者其它辅助构造器。

object _02ConstructorOps {
	def main(args: Array[String]): Unit = {
		val _3p = new Person(77)
		_3p.show()
	}
}

class Person(var name:String, var age:Int) {

	def Person(): Unit = {
		println("--Person()--是默认的构造器吗？")
	}

	def this() {
		this("嘿嘿", 33)
		println("---this() ---")
	}

	def this(name:String) {
		this()
		this.name = name
		println("---this(name:String) ---")
	}

	def this(age:Int) {
		this("龚天明")
		this.age = age
		println("---this(age:Int) ---")
	}
	println("-------------构造器~----------------")

	def show(): Unit = {
		println(s"name=${name}\tage=${age}")
	}
}

-------------构造器~----------------
—this() —
—this(name:String) —
—this(age:Int) —
name=龚天明 age=77

1.3. 内部类

object _03InnerClassOps {
	def main(args: Array[String]): Unit = {
		val outer = new Outer
		val inner = new outer.Inner()
		inner.show()
	}
}

class Outer { ooo =>
	 val x = 5

	class Inner { iii =>
		val x = 6

		def show(): Unit = {
			val x = 7
			System.out.println("x = " + x)
			System.out.println("inner class x = " + iii.x)
			System.out.println("Outer class x = " + ooo.x)
		}
	}
}

总结：scala的内部类和java的内部类的主要区别就在内部类对象的创建方式不一样。其次scala为了灵活的在内部类的局部访问内部类成员或者外部类的成员，可以给内部类和外部类的引用提供一个别名，方便操作。
也就是说，上例中这iii.x <=> this.x， ooo.x <=> Outer.this.x
内部类使用蛮多的一个地方：就是匿名内部类。

1.4. object对象

1.给scala类提供程序运行的入口，静态的main函数

2.给scala类也来提供静态成员——scala类的伴生对象来实现。
object中的所有的成员都是static静态

1.4. 单例

object _05ObjectOps {
    def main(args: Array[String]): Unit = {
        val s1 = Singleton.getInstance()
        val s2 = Singleton.getInstance()
        println(s1 == s2)
    }
}

//单例
class Singleton private () {
    var x = 5
}
/* 饿汉式
object Singleton {
    private val instance = new Singleton
    def getInstance(): Singleton = {
        instance
    }
}
 */
//懒汉式
object Singleton {
    private var instance:Singleton = _
    def getInstance(): Singleton = {
        if(instance == null) {
            Singleton.synchronized {
                if(instance == null) {
                    instance = new Singleton
                }
            }
        }
        instance
    }
}

1.5. 伴生对象

scala伴生对象的作用
1、给伴生类提供了类似于java中的静态成员
2、可以给scala的class提供一种新的对象构造方式
3、 在伴生对象中创建一个名为apply的方法，该apply方法的参数列表为class的构造函数的参数列表，二者保持对应
4、 返回值为本类，通过该apply方法来完成对象的构造
5、伴生对象，不仅可以访问对应伴生类的非私有成员，同时还可以访问对应伴生类的私有成员

object _06ObjectOps {
    def main(args: Array[String]): Unit = {
        val worker = Worker()
        worker.show()
        println("--------------")
        val w1 = Worker("柳泽宁", 15)
        w1.show()
    }
}
class Worker(name: String, age: Int) {
    def this() {
        this("old李", 35)
    }
    def this(name: String) {
        this()
    }
    def show(): Unit = {
        println(s"name: ${name}, age: ${age}")
    }
}
object Worker {//伴生对象
    def apply(): Worker = {
        new Worker()
    }
    def apply(name: String, age: Int): Worker = {
        new Worker(name, age)
    }
}

2. 类的继承体系

类与类之间的一个很重要关系——继承/扩展(extends)。

2.1. 类的扩展

继承的特点：

  1. 子类可以继承父类的所有非私有(private)，非静态的成员(变量和成员方法)。
  2. 可以对父类的相关方法进行覆盖/重写
  3. 也可以添加自己独有的成员
  4. 被final修饰的父类成员，子类不可以继承
  5. 被protected修饰的父类成员，子类可以继承
  6. 子类覆盖父类的方法的异常，必须要大于等于父类的异常
  7. 子类的访问权限必须要大于等于父类
class Person {
	private var name:String = _
	protected var age:Int = 0


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

	def show(): Unit = {
		println(s"person's name is $name")
	}
}

class Student extends Person {
	age = 15
	def this(age:Int) {
		this()
		this.age  = age
	}
	override def show(): Unit = {
		super.show()//子类调用父类的成员通过super关键字
		println(s"Student's age is $age")
	}
}

person’s name is null
Student’s age is 18

override在java中是一个注解，用来表示该方法是继承的，scala中是一个关键字，必须要添加在重写的方法前面，除非该方法是抽象的。

2.2. 类型检查和转换

使用isInstanceOf来进行类型判断，asInstanceOf进行类型转换。需要注意的是这两个操作都是对象的方法。

object _02EqualsOps {
	def main(args: Array[String]): Unit = {
		val w1 = new Worker("雷德言", 33)
		val w2 = new Worker("雷德言", 33)
		println(w1.equals(w2))
	}
}

class Worker {
	private var name:String = _
	private var age:Int = _
	def this(name:String, age:Int) {
		this()
		this.age = age
		this.name = name
	}
	override def equals(obj: Any): Boolean = {
		if(!obj.isInstanceOf[Worker]) //类型检查
			false
		else {//类型转换
			val that = obj.asInstanceOf[Worker]
			this.name.eq(that.name) && this.age == that.age
		}
	}
}

同时scala提供另一种更加简洁的写法，来处理这些类型检查和类型转换——模式匹配

override def equals(obj: Any): Boolean = {
    obj match {//模式匹配
        case that:Worker => {
            this.name.eq(that.name) && this.age == that.age
        }
        case _ => false
    }
}

2.3. 受保护字段和方法

被修饰为protected的age字段，不能在子类中被访问，但是通过scala的特定访问权限修饰设置，

  • 在访问修饰符后面使用[]指定要访问的package，比如protected[extendz]——代表了该字段只能在extendz包及其子包下面被访问。
  • 这实际上是更加精准的访问权限控制。
  • private后面也可以加[extendz]，和上面类似
object _01ProtectedOps {
    def main(args: Array[String]): Unit = {
        val stu = new Student
        val person = new Person()
        person.name = "清华学姐"
        person.age = 23

        stu.makeFriends(person)
    }
}
class Person {
    var name: String = "刘照路"
    protected[extendz] var age: Int = 18
//    protected[this] var age: Int = 18
    private[extendz] var gender = "guy"

    def show(): Unit = {
        println(s"${name}, age: ${age}, gender: ${gender}")
    }
}

class Student extends Person {
    name = "刘照路2"
    age = 19
    def makeFriends(person: Person): Unit = {
        println(s"姓名为:${this.name}, 年龄为${this.age}的小哥哥和${person.name}, 年龄为:${person.age}的小姐姐成为了红颜知己~")
    }
}

被protected[this]所修饰的变量，只能在本类，及其子类中被调用，但不可以被子类对象调用。
在这里插入图片描述

2.4 访问权限修饰符

scala中的访问权限修饰符就只有这么两个：private、protected，缺省相当于public

2.5 子类调用父类构造

super.show()调用父类的方法
子类只能通过主构造器来调用父类的构造器。

object _01ExtendsOps {
	def main(args: Array[String]): Unit = {
		val stu = new Student("李烨培")
		stu.show()
	}
}

class Person {
	private var name:String = _
	protected var age:Int = 0

	println("父类Person的主构造器-------")
	def this(name:String, age:Int) {
		this()
		this.name = name
		this.age = age
		println("----父类Person的辅助构造器this(name:String, age:Int)------")
	}
	def this(name:String) {
		this(name, 0)
		this.name = name
		this.age = age
		println("----父类Person的辅助构造器this(name:String)------")
	}
	def show(): Unit = {
		println(s"person's name is $name")
	}
}

class Student(name:String) extends Person(name) {
	println("子类Student的主构造器")
	age = 15
	def this(age:Int) {
		this("zhangsan")
		this.age  = age
		println("----子类Student的辅助构造器------")
	}
	override def show(): Unit = {
		super.show()
		println(s"Student's age is $age")
	}
}

父类Person的主构造器-------
----父类Person的辅助构造器this(name:String, age:Int)------
----父类Person的辅助构造器this(name:String)------
子类Student的主构造器
person’s name is 李烨培
Student’s age is 15

2.5. 重写字段和方法

​ 说白了就是在字段前面加上一个override关键字即可。最主要的作用就是父类中定义的非私有非protected的字段，子类如果想要定义个同名的字段，此时就需要使用override关键字完成覆盖，如果不用报错。

​ 被覆盖的字段只能被val修饰。

​ 方法的覆盖和java的覆盖是一样的。

2.6 匿名子类

匿名子类，其实说白了就是没有名字的类，通常匿名的类就是只调用一次的，没有必要进行定义，在运行时完成创建即可。

object _03AnonymousSubClassOps {
    def main(args: Array[String]): Unit = {
        fire(new Manager("黄世仁"))
        println("---------------------------------------")
        val m = new Manager("黄世仁"){
            override def manage(): Unit = {
                super.manage()
                println("还有升级版：克扣工资")
            }
            def haha(): Unit = {
                println("哈哈哈")
            }
        }
        m.haha()

        fire(m)

    }
    def fire(manage: Manager): Unit = {
        manage.manage()
        println("所以要炒了经理的鱿鱼~")
    }
}
class Manager(name: String) {
    def manage(): Unit = {
        println(s"行为为${name}的经理正在对员工吆五喝六~")
    }
}

2.7抽象类和抽象方法、字段

  • scala中的抽象类 抽象方法 抽象字段(这在java中不存在)
  • 一个类中的方法或者字段只有定义，没有实现，那么吧这些方法或者字段称之为抽象的方法和字段，
  • 而又抽象方法或者字段的类，我们称之为抽象类，用abstract关键字来进行修饰
  • 同样，抽象方法和字段的abstract关键字可以省略，而类上面abstract可不能省略。
  • 子类如果复写了父类的抽象的成员，是可以省略掉override关键字的，但是复写非抽象成员该关键字必须要加。
object _04AbstractOps {
    def main(args: Array[String]): Unit = {
        val cat = new Cat()
        cat.sleep()
        println("------------------------------")
        val fish = new Fish()
        fish.sleep()
    }
}

/**
 * 定义一个抽象类
 */
abstract class Animal {
    val leg: Int
    def sleep():Unit
    def dead(): Unit = {
        println("动物固有一死，或清蒸，或红烧，或爆炒，这真的是太难了~")
    }
}
class Cat extends Animal {
    val leg: Int = 4

    def sleep(): Unit = {
        println("喵星人，蜷缩成一团睡觉~")
    }
}
class Horse extends Animal {
    override val leg: Int = 4

    override def sleep(): Unit = {
        println("站着睡觉的还有谁！")
    }
}
class Fish extends Animal {
    override val leg: Int = 0

    override def sleep(): Unit = {
        println("睁着眼睛睡觉，太难了我~")
    }
}

2.8 trait特质

  • trait特质：
  • 不管是java还是scala的继承，有一个特点：只能单继承，不能多继承，在java中来弥补这个缺陷怎么解决：
  • 1、可以多层继承
  • 2、进行多实现(implements interface)
  • 在多实现这个接口的时候，比较痛苦，如果接口方法比较少还好，但是如果方法很多，实现起来非常的麻烦
  • 所以scala有了trait这样一个概念来弥补java中的interface只能由抽象方法的缺陷
  • 所以scala中的trait比java中的接口interface内容更加的丰富，既可以拥有抽象，也可以有拥有非抽象，当trait特质中的所有
  • 方法都抽象的时候，我们就可以理解其为java中的接口。
  • trait在进行调用的时候和scala的类的调用一样，都要使用关键字extends，而java的接口实现用implements
  • java的实现多接口的时候通过多个,来进行分割。很遗憾scala扩展多个trait的时候使用关键字with来进行分割。
  • 比java中的接口还牛的一点是，可以做到动态的运行时的扩展特质————特质的混入
  • 如果scala的一个类，既要扩展一个类，又要扩展特质，那么先写类，其次用with连接trait特质
object _05TraitOps {
    def main(args: Array[String]): Unit = {
        val logger = new ConsoleLogger
        logger.log("roma was not built in one day~")
        println("--------------------------")
        val fileName = "E:/data/out/scala/fileLogger.txt"
        val fLoger = new FileLogger(fileName) with MySerializable
        fLoger.log("god help those who help themselves.")
        fLoger.log("love is blind.")
        fLoger.close()
        fLoger.serialize("书到用时方恨少，绝知此事要躬行。")
    }
}

trait Logger {
    def log(msg: String): Unit

    def show(): Unit = {
        println("show~")
    }
}

trait MySerializable {
    //完成了序列化
    def serialize(msg: String): Unit = {
        println("serilaize: " + msg)
    }
}

class ConsoleLogger extends Logger {
    override def log(msg: String): Unit = {
        println("consoleLogger: " + msg)
    }
}

class FileLogger(fileName: String) extends Logger /*with MySerializable */{
    private val bw = new FileWriter(fileName, true)
    override def log(msg: String): Unit = {
        bw.write(msg)
        bw.write("\r\n")
        bw.flush()
    }
    def close(): Unit = {
        if(bw != null) {
            bw.close()
        }
    }
}
五块兰州拉面
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala 操作Redis使用连接池工具类RedisUtil
08-25
Scala 操作Redis使用连接池工具类RedisUtil 在 Scala 中操作 Redis 时，连接池工具类 RedisUtil 是非常重要的。下面我们将详细介绍 RedisUtil 的使用方法和实现原理。 首先，我们需要了解什么是 Redis。Redis 是一...
Scala常用List列表操作方法示例
08-25
本文将详细介绍Scala常用List列表操作方法示例，包括创建列表、获取列表元素、修改列表元素、判断列表元素、列表排序、列表过滤等多种操作。 创建列表 在Scala中，可以使用多种方式创建列表，例如使用`List`对象的...
【Scala】类和对象的介绍与使用
qq_41369191的博客
05-08 258
目录 类和对象 创建类和对象 定义和访问成员变量 使用下划线初始化成员变量 定义成员方法 访问修饰符 类的构造器 主构造器 辅助构造器 单例对象 在单例对象中定义成员方法 main方法 实现App Trait来定义入口 伴生对象 private[this]访问权限 继承 override和super 类型判断 isInstanceOf/asInstanceOf getClass/classOf 抽象类 匿名内部类 特质(trait) 继承单个特质 继承多个特
Scala、Spark SQL 常用方法
发财糕
05-13 1507
一样的操作，为每一条输入返回一个迭代器（可迭代的数据类型），然后将所得到的不同级别的迭代器中的元素全部当成同级别的元素，返回一个元素级别全部相同的。与合并不同，连接会对键相同的值进行合并，连接方式多种多样，包含内连接、右外连接、左外连接、全外连接，不同的连接方式需要使用不同的连接方法。Scala定义一个数组的语法格式如下。reduceByKey()方法用于合并具有相同键的值，作用对象是键值对，并且只对每个键的值进行处理，当。方法用于合并具有相同键的值，作用对象是键值对，并且只对每个键的值进行处理，当。
java调用scala内部类_Scala笔记整理（三）：Scala面向对象—类详解1
weixin_29338295的博客
02-26 454
[TOC]getter和setter简单类和无参方法需要说明的是，官方给出的参考资料对于这方面讲解得十分详细，目前入门来说，不需要达到这样的理解，只需要可以进行开发即可，这一部分我给出的是官方的一些文档说明，但是后面的定制和注解，就直接简单说明能用就好了。class PersonOps {private var age = 0 //你必须初始化一个字段def increment() {age +=...
02 Scala 变量的基本介绍
朱古力的博客
05-24 116
文章目录变量1. 变量使用说明2. 数据类型3. 值类型隐式转换4. 值类型与 String 类型的转换4.1 基本类型转 String 类型4.2 String 类型转基本类型 变量 1. 变量使用说明 scala 要求变量声明时初始化。 声明变量时，类型可以省略（编译器会自动进行类型推导）。 类型确定后，就不可以再修改了（Scala 是强数据类型语言）。 在声明/定义一个变量时，可以使用 var 或者 val 来修饰， var 修饰的变量可改变，val 修饰的变量不可改。 val 没有线程安全问题，因
Scala集合介绍
Faith_xzc
08-07 416
Scala集合介绍集合简介不可变集合继承图可变集合继承图数组不可变数组基本介绍案例实操可变数组基本介绍案例实操不可变数组与可变数组的转换基本介绍案例实操多维数组多维数组定义案例实操列表 List不可变 List基本介绍案例实操可变 ListBuffer基本介绍案例实操Set 集合不可变 Set基本介绍案例实操可变集合基本介绍案例实操Map 集合不可变 Map基本介绍案例实操可变 Map基本结束案例实操元组基本介绍案例实操 集合简介 1）Scala 的集合有三大类：序列 Seq、集 Set、映射 Map，所有
Scala的队列与并行集合
m0_46168848的博客
09-02 734
在 Scala 中，队列和并行集合是常用的数据结构和并发编程工具。
Scala入门系列终章：类与对象
小数志
02-27 212
导读截至本篇，Scala入门系列即将告一段落，先后用7篇文章将Scala语言的四梁八柱进行了简要介绍，虽然阅读量相较于其他文章更为惨淡，但相信对于有一定编程语言基础又想快速入门Scala的...
Scala基础教程--06--类与对象的详解
kc44601的博客
05-05 549
1.类和对象介绍 2.初始化及定义访问成员 3.访问权限修饰符 4. 类的构造器 5.单例对象 6.main方法 7.伴生对象 8.定义工具类
Scala介绍
DamoLLL的博客
01-04 419
Scala介绍 java和scala关系 java — JVM xxx.java —javac— yyy.class ----- java 真正在jvm中能够运行的是.class字节码文件 Scala之父：Martin Odersky 马丁·奥德斯基 Scala也是JVM系的语言。 xxx.scala —scalac ---- yyy.class ---- scala scala和java是可以混合编程。 scala底层用到的还是java,只是在java上套了一层壳，由于scala最终被编译为.class
Scala 类型参数
mxk4869的博客
07-12 325
Scala 类型参数
scala 操作数据库的方法
08-25
Scala 提供了多种方式来操作数据库，这篇文章将详细介绍 Scala 操作数据库的方法。 定义数据库连接 在 Scala 中，定义数据库连接是操作数据库的第一步。我们可以使用 DruidDataSource 来定义数据库连接。Druid...
Scala 【 5 数组常见操作和 Map 】
01-20
在 Scala 中，数组和 Map 是两种非常常用的数据结构。...这些是 Scala 中数组和 Map 的基本操作，它们提供了丰富的功能，使得在处理数据时具有很高的灵活性和效率。理解并熟练运用这些操作是 Scala 编程的基础。
Scala的文件读写操作与正则表达式
08-26
Scala文件读写操作与正则表达式 Scala语言提供了多种文件读写操作的方式，包括读取文本文件、读取二进制文件等。在Scala中，可以使用scala.io.Source对象来读取文件，该对象提供了多种方法来读取文件，例如getLines...
Scala学习笔记20: Future 和Promise
最新发布
Taerge0110的博客
07-26 282
在 Scala 中, `Future` 和 `Promise` 是用于处理异步操作的强大工具 ; 它们就像一对搭档, 协同工作, 优雅地管理着那些需要花费时间的任务 .
Hadoop、Hive、HBase、数据集成、Scala阶段测试
m0_58050808的博客
07-24 1007
ResourceManager 是 YARN 架构中的核心组件之一，负责接收客户端提交的作业（如 MapReduce 任务、Spark 任务等），并为这些作业分配资源（如内存、CPU）以在集群中的 NodeManager 上执行。spark的任务调度流程：driver端，遇到action算子触发任务执行，将任务提交到有向无环图，DAGscheduler中，根据RDD的血缘关系划分划分stage，将RDD中的分区封装成taskset任务，发送到TASKscheduler。
探索Perl的图形用户界面开发：工具、技巧与实践
2402_85762143的博客
07-23 1134
Perl的GUI开发提供了多种工具和方法，允许开发者根据项目需求和个人偏好选择合适的工具包。通过遵循最佳实践和利用Perl的强大功能，开发者可以创建出既美观又实用的GUI应用程序。随着技术的不断发展，Perl社区也在不断推出新的工具和库，以支持更高效、更现代的GUI开发。本文只是一个入门指南，深入学习Perl GUI开发还需要阅读更多的文档、参与社区讨论和实践项目。希望本文能为你的Perl GUI开发之旅提供一些帮助和启发。
Scala集合操作详解：数据变换与函数示例
这篇摘要主要以List类型为例，介绍了如何进行集合的变换操作。 1. 常用操作符（函数） Scala的List类型支持多种操作符，这些操作符本质上都是函数，用于处理列表中的元素。例如： - `++[B](that: ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值