Scala之面向对象

时间  2019-12-07
标签 scala 面向对象 栏目 Scala 繁體版
原文   原文链接

1. Scala基础练习

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

    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完成选择排序web

       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中的成员内部类实例app

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");
       }
   }
}

为啥要有内部类？dom

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

scala的内部类如何定义this

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

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

在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中的单例(必须掌握)

/**
 * 单例
 *     恶汉式
 *     懒汉式
 * 一个类只能建立一个对象，
 * 定义的步骤：
 *   恶汉式：
 *     一、私有构造器
 *     二、提供一个public的static的返回值为本类引用的方法
 *     三、为了给第2步中提供实例，建立一个private的static的成员变量
 *   懒汉式：
 *     一、私有构造器
 *     二、建立一个private的static的成员变量，没有初始化
 *     三、提供一个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：特质

 

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程