Scala之面向对象

1. Scala基础练习

  1. 不使用str.toLong,str.toInt/Integer.valueOf()/Long.valueOf/Integer.parseInt()等,将字符串"123456789" 转化成数字123456789

    def method3(): Unit = {
       val str = "123456789"
       var sum = 0L
       for(ch <- str) {//字符串本身就是一个字符数组
           sum = sum * 10 + (ch - '0')
      }
       println(sum)

       str.toCharArray.map(ch => ch - '0').reduce((v1, v2) => v1 * 10 + v2)
    }
  2. 使用scala完成选择排序

       def main(args: Array[String]): Unit = {
          val array = Array(1, 5, 3, 5, 6, 7, 2, 9)
          println("排序前的数组:" + array.mkString("[", ", ", "]"))
          selectSort(array)
          println("排序后的数组:" + array.mkString("[", ", ", "]"))
      }
      /**选择排序
        *
        */
      def selectSort(arr:Array[Int]): Unit = {
          for(i <- 0 until arr.length) {
              for (j <- i until arr.length) {
                  if(arr(i) > arr(j)) {
                      swap(arr, i, j)
                  }
              }
          }
      }
      /*
          位运算 ^ 相同为0,反之为1
          a=3 b=5
          a=0011
          b=0101
          a= a^b =0110
                  0101
          b= a^b =0011=3
                  0110
          a= a^b= 0101=5
          这里没有使用第三方变量完成两个数字的交换,其中使用^与那孙效率最高
       */
      def swap(arr:Array[Int], i:Int, j:Int): Unit = {
          /*arr(i) = arr(i) ^ arr(j)
          arr(j) = arr(i) ^ arr(j)
          arr(i) = arr(i) ^ arr(j)*/
          arr(i) = arr(i) + arr(j)
          arr(j) = arr(i) - arr(j)
          arr(i) = arr(i) - arr(j)
      }
  3. 使用scala完成二分查找

    在一个有序数组中找到某一个值,如果存在,返回索引,没有返回-1或者返回如果存在,应该在的位置
    def binarySearch(arr:Array[Int], key:Int):Int = {
          var start = 0
          var end = arr.length - 1
          while(start < end) {
              val mid = (start + end) / 2
              if (key < arr(mid)) {
                  //左边
                  end = mid - 1
              } else if (key > arr(mid)) {
                  //又变
                  start = mid + 1
              } else {
                  return mid
              }
          }
          return -(start + 1)
      }

     

2. scala面向对象

2.1. 类的基本操作

2.1.1. 类的创建与对象的构造

* 定义scala中的类使用关键字class
*     1、定义scala中的任意一种结构,都不可以使用public关键字修饰,因为scala中没有public关键字
*         不加任何访问权限修饰符就相当于java中的public
*     2、类中可以定义成员信息
*         成员变量
*         成员方法
*     3、创建类的实例--对象
*         在scala中和java中是一样,都使用关键字new来构建类的实例
object ClassOps {
   def main(args: Array[String]): Unit = {
       val p:Person = new Person()
       p.name = "刘梦男"
       p.age = 18
       p.show()
  }
}

class Person {
   var name:String = _
   var age:Int = _

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

2.1.2. 成员变量的封装getter和setter

*     4、scala没法直接为成员变量提供getter和setter方法,只能自己编写
*         scala做了一种尝试,通过注解(@BeanProperty)的方式来给成员变量提供getter和setter,
*         前提是该getter或者setter不能被private修饰,此时数据的安全性无法得到保证
*
*     5、这个getter和setter的的使用其实javabean中的规范,javabean的主要作用是什么?
*         封装、传递数据
*         javaee
*             dao
*             service
*             web
*             domain
*                 Person
*                 Order
*                 Cat
*                 OrderItem
*                 Category
object ClassOps {
   def main(args: Array[String]): Unit = {
       val p:Person = new Person()
//       p.name = "liumengn"
//       p.age = 18

       p.setName("liwei")
       p.setAge(-2)
       p.setSalary(123.0f)
       p.show()
  }
}

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

   @BeanProperty var salary:Float = _
   def setName(n:String) = {
       name = n //单行函数
  }

   def getName = name

   def setAge(a:Int) = {
       if(a < 0) {
           throw new RuntimeException("what are you fucking 赋值!")
      }
       age = a
  }

   def getAge = age

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

2.1.3. case class模拟javabean

/*
    在scala中一般不用这些普通的class类进行封装数据、传递数据,那用什么呢?
 *         case class样例类
 *             作用就相当于java bean
 *   case class的定义非常简单,在class关键字的前面加上另外一个关键字case即可
 *  
 *   样例类的定义必须要有一个参数列表---->构造器,
 *   case class的应用是非常广泛的,但凡数据的传递,一般都用case class
*/
object _02CaseClassOps {
   def main(args: Array[String]): Unit = {
val category = Category(1, "手机")
       println(category.id)
       println(category.name)
  }
}
//定义了一个case class Category
case class Category(id:Int, name:String)

2.1.4. scala类的构造器

*  2、构造器:
*     按照java中的知识,val stu = new Student是使用Student类的无参构造器创建对象
*     在一个类中,如果局部变量和成员变量名发生冲突,便通过给成员变量加this关键字进行区分
*  3、如何定义构造器:
*        尝试使用def Student(name:String, age:Int)定义构造器,
*        调用的时候:
*         new Student("陈达", 20) too many arguments to constructor报错
*         所以该方法就不是scala中的构造器
*  4、scala的构造,分为主构造器和辅助构造器,
*     主构造器的定义和类的定义交织在一起,如何去定义一个主构造器
*     class Xxx(参数列表) {
*     }
*     类名后面的内容就是主构造器,如果参数列表为空的话,()可以省略
*     主构造器的函数体,就是类体的内容,所以如果我们使用主构造器创建对象
*  5、scala的类有且仅有一个主构造器,要想提供更加丰富的构造器,就需要使用辅助构造器
*     def this(参数列表)
*     scala中的辅助构造器,在函数体的第一行,必须以调用其它辅助构造器或者主构造器开始
*     也就是说要使用this(参数列表)去调用其它构造器
*     但是归根到底,一个辅助构造器最终还是要从主构造器的调用开始
*  6、scala和java的构造器的区别
*     java的构造器没有主构造器和辅助构造器之分,但是有默认的无参构造器和有参构造器之分
*     scala中默认的构造器就是类名后面的构造器,被称之为主构造器,同时还拥有辅助构造器
*     java的构造器名称和类名一直,而scala中的构造器名称就是this,其余和java一模一样
class Student(n:String, a:Int) {

   private var name:String = _
   private var age:Int = _

   def Student(name:String, age:Int): Unit = {
       this.name = name
       this.age = age
  }
   //辅助构造器
   def this() {
       this("张钟方", 18)
       println("---辅助构造器def this()-----")
  }

   def this(age:Int) {
       this()
       this.age = age
       println("---辅助构造器def this(age:Int)-----")
  }

   def show(): Unit = {
       println(s"name: ${n}\tage: ${a}")
  }
   println("如果这是构造器的方法体的话,这句话应该会被调用!")
}

2.1.5. 嵌套类

scala中称之为嵌套类,在java中称之为内部类

java中的成员内部类实例

public class InnerClassOps {
   public static void main(String[] args) {
       Outer.Inner oi = new Outer().new Inner();
       oi.show();
  }
}
class Outer {
   class Inner {
       public void show() {
           System.out.println("inner show");
      }
  }
}

为啥要有内部类?

从业务逻辑上理解,定义复杂是否在外部类内部定义更加合理,这样便有了内部类,比如,定义一个类Person,类有心脏,Heart优势一个复杂的抽象事物,显然应该把Heart定义在Person内部更加的准确与合理。

scala的内部类如何定义

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

class Outer { oo => //外部类的引用
   var x = 5
   class Inner {
       var x = 6
       def show(): Unit = {
           var x = 7
           println("Inner: x=" + x)//7
           println("Inner: x=" + this.x)//6
           println("Inner: x=" + Outer.this.x)//5
           println("Inner: x=" + oo.x)//5 简写方式
      }
  }
}

2.1.6. 对象object

scala并没有像java中的静态,所以按照java中的观点的话,主函数是没有办法被执行public static void main(xxx)

scala为了来模拟java中的static这个关键字,设计出了object这一结构,它是和class平级。

在object定义的方法我们可以理解为函数,class中的行为称之为方法,而且在object中定义的变量和函数都是可以当做java中的静态来进行调用。

object _04ObjectOps {
  def main(args: Array[String]): Unit = {
      val ret = Tool.add(13, 14)//相当于java的静态方法
  }
}
object Tool {
  val x = 5
  def add(a:Int, b:Int) = a + b
}

如何在scala中去定义单例对象呢?

java中的单例(必须掌握)

/**
* 单例
*     恶汉式
*     懒汉式
* 一个类只能创建一个对象,
* 定义的步骤:
*   恶汉式:
*     1、私有构造器
*     2、提供一个public的static的返回值为本类引用的方法
*     3、为了给第2步中提供实例,创建一个private的static的成员变量
*   懒汉式:
*     1、私有构造器
*     2、创建一个private的static的成员变量,没有初始化
*     3、提供一个public的static的返回值为本类引用的方法
*/

恶汉式:

class Singleton {//恶汉式
   private Singleton(){}
   //成员位置
  {//构造代码块

  }
   private static Singleton instance = new Singleton();
//   static {
//       instance = new Singleton();
//   }

   public static Singleton getInstance() {
       return instance;
  }
}

懒汉式:

class Singleton {
   private Singleton(){}
   private static Singleton instance;

   public static Singleton getInstance() {
       if(instance == null) {
           synchronized (Singleton.class) {
               if(instance == null)
                   instance = new Singleton();
          }
      }
       return instance;
  }
}

scala中的单例

object _05SingletonOps {
   def main(args: Array[String]): Unit = {
       val s1 = Singleton
       val s2 = Singleton
       println("s2.x=" + s2.x)//1
       s1.x = 5
       println("s1 == s2? " + (s1 == s2))//true 单例
       println("s2.x=" + s2.x)//5
  }
}
object Singleton {
   var x = 1
}

2.1.7. 伴生对象和伴生类

为什么要有伴生对象?

我们都知道,在scala中是没有静态这个概念,而在java中一个类是既可以有非静态的成员,也可以有静态成员,表达非常丰富。scala由于没有静态的概念,类只能拥有非静态成员。所以scala为了弥补这个缺憾,定义这么一个和该类同名的object结构,而且该object结构必须要和该类在同一个.scala源文件中被定义

这样我们就可以让该类拥有了静态和非静态的成员。

把这个和类同名的object称之为该类的伴生对象,反过来,该类称之为该object的伴生类。

object _06CompanionOps {
   def main(args: Array[String]): Unit = {
       val worker = new Worker("old李", 38)
       worker.show()
       println("-----------------------------")

       val w1 = Worker()
       w1.show()
       println("静态属性:" + Worker.x)
       val w2 = Worker("蔡金廷", 13)
       w2.show()

//       val arr = new Array[Int](5)
//       val arr1 = Array(1, 2, 3, 4)
  }
}

class Worker /*private ()*/ {
   private var name:String = _
   private var age:Int = _

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

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

object Worker {
   var x = 123
   //apply方法必须要重写
   def apply(): Worker = new Worker()

   def apply(name: String, age: Int): Worker = new Worker(name, age)
}

2.1.8 没有main函数如何执行scala程序

object _07AppOps extends App {
   /*def main(args: Array[String]): Unit = {
       println("xxxxxx")
   }*/
   println(args.mkString("[", ",", "]"))
   println("yyyyyyyyyyyy")
}
extends:扩展
trait:特质

 

posted @ 2019-06-12 22:56  Sonnyb  阅读(286)  评论(0编辑  收藏  举报