scala 编程思想 --类和对象

其他 2020-02-18 11:54:31 阅读次数: 0

对象是包括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(b<3))
    println(trueOrFalse(b>0))

    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))

  }
}
半_调_子
发布了131 篇原创文章 · 获赞 27 · 访问量 32万+
私信 关注

猜你喜欢

转载自blog.csdn.net/wangjunji34478/article/details/104129417
今日推荐
周排行
成为C++高手之宏与枚举
在CAD二次开发中使用进度条
Js插件ECharts，HighCharts学习网址整理
Celery提交任务出错(on windows.)
cephfs内核客户端性能追踪
thinkphp中PHPExcel用法
EntityFramework动态组合多排序字段
汇编语言（八）实验9 根据材料编程
安装ubuntu后必须做的事情（对我而言）
JS函数式编程
每日归档
更多
2024-10-22(0)
2024-10-21(0)
2024-10-20(0)
2024-10-19(0)
2024-10-18(0)
2024-10-17(0)
2024-10-16(0)
2024-10-15(0)
2024-10-14(0)
2024-10-13(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022