scala 编程思想 --类和对象
2021/4/26 1:26:34
本文主要是介绍scala 编程思想 --类和对象，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
对象是包括scala在内的众多现代编程语言的基础。在面向对象编程语言中
package com.test1
object Scala09_test3 {
def main(args: Array[String]): Unit = {
val r1 = Range(0,10)
//对于range来说，可用操作的数量非常惊人，对象是
//类和对象
//对象是包括
println(r1.toSeq.reverse)
//创建一个range对象并打印其Step值
println(r1.step)
val r2 = Range(0,10,3)
println(r2.step)
type r3=String
val fa:r3="fa fd as fa sd fa sf"
fa.split(" ").toSeq.foreach(print )
//创建一个string对象s1将其创建化sally。
var s1:r3 ="Sally"
var s2:r3 ="Sally"
if(s1==s2){
println("s1 and s2 are equals")
}else{
println("s1 and s2 are not equals")
}
//ScalaDoc scala提供了用于获取
}
}创建类
除了使用range这样的预定义类型，我们还可以定义自已的对象类型。
实际上，
package com.test1
object Scala09_test3 {
def main(args: Array[String]): Unit = {
//create some classes
class Giraffe
class Bear
class Hippo
//create some objects
val g1 = new Giraffe
val g2 = new Giraffe
val b = new Bear
val h = new Hippo
//每个对象都是唯一的
println(g1)
println(g2)
println(b)
println(h)
class Hyena{
println("This is in the class body")
}
val hyena = new Hyena
println(hyena)
class Zebra{
println("I have strips")
}
val zebra = new Zebra
}
}类中的方法
在类中可以定以属于这个类的方法，下面bark方法就属于dog类
package com.test1
object Scala09_test5{
def main(args: Array[String]): Unit = {
val cat = new Cat
val m2 = cat.meow()
assert("mew!"==m2,"Expeted new! got"+m2)
//方法对类中的其他元素有特殊的访问方式，例如，在类中无需使用圆点
//即可访问该类中的其他方法。
val hamster=new Hamster
val e1 = hamster.exercise()
import util.Random
//使用多个import导入
/* import util.Random
import util.Properties
val r = new Random
val r2 = Properties*/
//同一条语句导入多个项
/* import util.Random,util.Properties
val r = new Random
val p = Properties*/
//修改导入的名字
//甚至可以个重情重义导入的名字
import util.{Random=>Bob,Properties=>Jill}
val r = new Bob
val p = Jill
//也可以导入包里面的所有的事特，可以使用下划线
import util._
//也可以使用完全限定名
val r1 = new util.Random
val p2 = util.Properties
import pythagorean.RightTriangle
val rt = new RightTriangle
println(rt.Hypotenuse(3,4))
println(rt.area(3,4))
}
}至此，示例中使用的都是简单的脚本，但是最终你肯定编写出能够多处使用的代码，随便创建一个对象
package pythagorean
class RightTriangle {
def Hypotenuse(a:Double,b:Double):Double={
Math.sqrt(a*a+b*b)
}
def area(a:Double,b:Double):Double={
a*b/2
}
}测试
健壮的代码必须不断测试，即在每次修改后都需要测试。对代码中某个部分的可能会意外了影响基他代码，而通过测试，
自动tdd方法需要后面多看看。
域：域是构成对象一部分的var或val，每个对角都会为其域获取自已的存储
package com.test1
object Scala09_test6{
def main(args: Array[String]): Unit = {
//测试
//健装的代码必须不断的测试，即在每次修改后都需要测试，需要
//为了源代码易于测试，我们创建自已的微型测试系统，目标是提供具备下列特性的最小化方法
//紧挨表达式的右测写出其预期结果，使用代码更容易理解
import java.util.logging._
trait Logging{
val log = Logger.getLogger(".")
}
/* class Cup{
var percentFull = 50
}
val c1 = new Cup
c1.percentFull=100
println(c1.percentFull)
val c2 = new Cup
println(c2.percentFull)*/
class Cups{
var percentFull = 0
val max = 100
def add(Increase:Int):Int={
percentFull += Increase
if(percentFull > max){
percentFull = max
}
percentFull
}
}
}
}for循环
for循环遍历一个值序列，使用其中的每个值执行某些操作。for循环以关键字for开头，
package com.test1
object Scala09_test6{
def main(args: Array[String]): Unit = {
//测试
//健装的代码必须不断的测试，即在每次修改后都需要测试，需要
//为了源代码易于测试，我们创建自已的微型测试系统，目标是提供具备下列特性的最小化方法
//紧挨表达式的右测写出其预期结果，使用代码更容易理解
import java.util.logging._
trait Logging{
val log = Logger.getLogger(".")
}
/* class Cup{
var percentFull = 50
}
val c1 = new Cup
c1.percentFull=100
println(c1.percentFull)
val c2 = new Cup
println(c2.percentFull)*/
class Cups{
var percentFull = 0
val max = 100
def add(Increase:Int):Int={
percentFull += Increase
if(percentFull > max){
percentFull = max
}
percentFull
}
}
var result=""
for(i<-0 to 10){
result += i+" "
}
println(result)
result = ""
for(i <- 0 until 10 ){
result+=i+" "
}
println(result)
result = ""
for(i <- Range(0,10) ){
result+=i+" "
}
println(result)
result = ""
for(i <- Range(0,10,2) ){
result+=i+" "
}
println(result)
//增加一列
println(Range(0,10).inclusive)
//如果在红
for(i<- 1 to 10;if(i%2 == 0 )){println(i)}
for(i<- 1 to 10;if(i%2 == 0 )){println(i)}
//Vector
//Vector 是一个容器，即保存其他对象的对象，容器也称为集合
//verctor是标准scala包的一部分，因此不需要任何人就可以使用
println("========================================")
val v1 = Vector(1,3,5,6,11,13)
println(v1(4))
println("========================================")
var result1 = ""
for(i <- v1){
result1 += i+ " "
}
println(result1)
val v3 = Vector(1.1,2.2,3.3,4.4)
println(v3.reverse)
val v4 = Vector("Twas","Brilling","And","Slithy","Toves")
println(v4.sorted)
println(v4.head)
println(v4.tail(2 ))
//这里有些不同寻常的地方，创建所有Vector对象时都没有使用new关键字，为了方便起见
//scala允许
var v5:Vector[String]=Vector("Twas","Brilling","And","Slithy","Toves")
var v6=Vector(1,"111",2,22.22,333)
for(i <- Range('a','z').inclusive.reverse){
print( i.toChar )
}
var interVector:Vector[Int] = Vector(1,2,3,4,5,6,7,8,9)
var doubleVector:Vector[Double] = Vector(1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9)
println("interVector.sum: "+interVector.sum)
println("interVector.min: "+interVector.min)
println("interVector.max: "+interVector.max)
println("========================================")
println("doubleVector.sum: "+doubleVector.sum)
println("doubleVector.min: "+doubleVector.min)
println("doubleVector.max: "+doubleVector.max)
val stringVector:Vector[String]=Vector("iit1","iit2","iit3","iit4","iit5","iit6","iit7","iit8")
println("========================================")
//println("stringVector.sum: "+stringVector.sum)
println("stringVector.min: "+stringVector.min)
println("stringVector.max: "+stringVector.max)
println(Range(1,100).toVector.sum)
println(Range(1,100).sum)
var myVector1:Vector[Int]=Vector(1,1,2,3,4,565,7)
var myVector2:Vector[Int]=Vector(1,1,2,3,4,565,7)
println(myVector1 == myVector2)
println(Set(1,2,2,3,4,5,6,7,8,88))
println(List(1,1,1,1,2,2,3,4,5,6,7,8,88))
}
}更多条件表达式
package com.test1
object Scala09_test7{
def main(args: Array[String]): Unit = {
//更多的条件表达式
//让我们来练习如何创建方法，编写一些接受布尔类型参数的方法
def trueOrFalse(exp:Boolean):String={
if(exp){
"It's true"
}else{
"It's false"
}
}
val b = 1
println(trueOrFalse(b0))
val v = Vector(1)
val v2 = Vector(3,4)
println(trueOrFalse(v == v.reverse))
println(trueOrFalse(v2 == v2.reverse))
def checkTruth(exp1:Boolean,exp2:Boolean):String={
if(exp1 && exp2){
"Both are true"
}else if(!exp1 && !exp2){
"Both are false"
}else if(exp1){
"First:True ,second:false"
}else{
"First:True ,second:true"
}
}
println(checkTruth(true||false,true))
println(checkTruth(false||false,true))
println(checkTruth(true ,false))
println(checkTruth(false,true))
}
}
这篇关于scala 编程思想 --类和对象的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-25【机器学习(二)】分类和回归任务-决策树(Decision Tree,DT)算法-Sentosa_DSML社区版
- 2024-11-23增量更新怎么做？-icode9专业技术文章分享
- 2024-11-23压缩包加密方案有哪些？-icode9专业技术文章分享
- 2024-11-23用shell怎么写一个开机时自动同步远程仓库的代码？-icode9专业技术文章分享
- 2024-11-23webman可以同步自己的仓库吗？-icode9专业技术文章分享
- 2024-11-23在 Webman 中怎么判断是否有某命令进程正在运行？-icode9专业技术文章分享
- 2024-11-23如何重置new Swiper?-icode9专业技术文章分享
- 2024-11-23oss直传有什么好处？-icode9专业技术文章分享
- 2024-11-23如何将oss直传封装成一个组件在其他页面调用时都可以使用？-icode9专业技术文章分享
- 2024-11-23怎么使用laravel 11在代码里获取路由列表？-icode9专业技术文章分享
