Scala总结之基础练习和面向对象

最新推荐文章于 2023-11-12 11:32:46 发布

baiyabai

最新推荐文章于 2023-11-12 11:32:46 发布

阅读量598

点赞数 1

分类专栏：学习总结文章标签： Scala

本文链接：https://blog.csdn.net/Baiyabai/article/details/93299628

版权

学习总结专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一. scala基础练习

1.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)
}

1.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)
   }

1.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)
    }

二. 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的主要作用是什么？
*         封装、传递数据

object ClassOps {
    def main(args: Array[String]): Unit = {
        val p:Person = new Person()
//        p.name = "郭靖"
//        p.age = 18

        p.setName("黄蓉")
        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(" 赋值错误！")
        }
        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("乔峰", 38)
        worker.show()
        println("-----------------------------")

        val w1 = Worker()
        w1.show()
        println("静态属性：" + Worker.x)
        val w2 = Worker("段誉", 20)
        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：特质

2.2. 继承体系

2.2.1. 扩展类

2.2.2. 重写方法

* scala的继承或者扩展
*    如何去实现继承或者扩展，在scala中使用的关键字和java的继承是一模一样extends
*    总结：
*     1、子类可以拥有父类的非私有的成员(成员变量和成员方法)
*     2、子类可以扩展|复写父类的方法，但是在复写的时候，必须要添加override关键字(除非该方法是抽象方法)
*     3、哪些成员无法被子类继承
*         private
*             如果private关键字不加如何限制，就和java中的private作用是相同的，但是我们在scala中可以更加精准
*          的控制被private或者被protected关键字修饰的成员的权限。
*             private[可以被访问的包package]
*                 这就意味着，该成员可以在包package，及其子包下面被访问
*             private[this] <=> private
*                 只能在前类中被访问
*         static scala中没有
*         final
*     4、子类要想使用父类的某些行为，可以使用super关键字来调用，和java中一致

class Dog {
    private[extendz] var id:String = "哺乳类的人类的好朋友"
    var eyes:Int = 2
    var name:String = _

    def eat(): Unit = {
        println("吃吃吃")
    }

    private def cry(): Unit = {
        println("汪汪汪汪")
    }
}

class ZHTYQ extends Dog {
    name = "大黄"

    override def eat(): Unit = {
        super.eat()
        println("大黄啃骨头。。。")
    }
    id = "haha"
    def keepDoor(): Unit = {
        println("大黄在看家")
    }
}

2.2.3. 类型检查和转换

多态：一种事物有多重状态的表现，是继承体系中非常重要的概念。

反映到编程语言中的体现：父类引用指向子类对象。这个在java中是很明显的，但是在scala不明显，因为一般在定义变量的时候，可以不添加类型，直接做类型推断，所以要想很直接的体现出，就应该像java定义那样，eg.

val obj:Fu = new Zi() —> 父类引用指向子类对象 val obj = new Zi()

同时在进行多态操作中，一般都会涉及到类型转化，scala中也有类似java中的类型检查和类型转化，不同之处在于具体操作方式略有差异，进行类型检查是：引用.isInstanceof[类型]，进行类型转化使用引用.asInstanceof[类型]。

class Person {
    var name:String = _
    var age:Int = _
    def this(name:String, age:Int) {
        this()
        this.name = name
        this.age = age
    }
    override def equals(obj: scala.Any): Boolean = {
        if(!obj.isInstanceOf[Person]) {
            return false
        }
        val that = obj.asInstanceOf[Person]
        if(this.name.equals(that.name) && this.age == that.age) {
            return true
        }
        return false
    }
}

但是，考虑到scala是一个非常简约的编程语言，又为大家提供了一个类型检查和转化的简化的操作方式——模式匹配，和java中switch case很像，但是要比java中的switch case强大的多的多的多。

private def method3 = {
    val dh: Dog = new ZHTYQ
    dh.eat()
    if (dh.isInstanceOf[ZHTYQ]) {
        //会避免出现ClassCastException
        val gg = dh.asInstanceOf[ZHTYQ]
        gg.keepDoor()
    }
    println("-----------------------")
    //使用模式匹配的操作方式 和switch case很像
    dh match {
        case gg:ZHTYQ => {
            gg.keepDoor()
        }
        case p:Person => {
            p.name
        }
            //还有默认的操作
        case _ => {
            println("没有匹配到任何")
        }
    }
}

2.2.4. 受保护字段和方法

所谓受保护的字段或者方法，就是被protected修饰的field或者method。

被protected有啥特点？本类及其子类方法。

> **被protected[this]修饰了成员，便无法在实例（包括本类对象和子类对象）中被调用，只能在定义中被调用**

举例：

/**
* 因为salary被protected[this]修饰了，便无法在实例中被调用，只能在定义中被调用
*/
class Staff {
 var name:String = _
 var age:Int = _
 protected[this] var salary:Float = 2120

 def doWork(): Unit = {
     println(this.name + " is working sth.")
 }
}

class Programmer extends Staff {
 name = "郭靖"
 age = 52
 salary = 1000000000
 override def doWork(): Unit = {
     println(this.name + " 监督杨过练武")
 }

 def makeFields(staff: Staff): Unit = {
     println(this.name + "准备要和" + staff.name + "建立革命友谊")
     println(staff.name + "的薪资是多少呢？" + staff.salary)
 }
}

上述代码出现如下异常：
在这里插入图片描述

2.2.5. 超类的构造

/**
  * 子父类的构造
  *     子类在构造的过程中，先要初始化相关的父类构造器
  */
object _04ExtendsOps {
    def main(args: Array[String]): Unit = {
        val zi = new Zi
        zi.name = "郭靖"
        zi.age = 22
        zi.show()
    }
}

class Fu {
    println("-----Fu---main-constructor---")
    var name:String = _
    var age:Int = _
    def this(name:String, age:Int) {
        this()
        this.name = name
        this.age = age
        println("-----Fu---assist-constructor(name:String, age:Int)---")
    }
}

class Zi(gender:Int) extends Fu {
    println("-----Zi---main-constructor(gender:Int)---")
    def this() {
        this(1)
        println("-----Zi---assist-constructor()---")
    }

    def show(): Unit = {
        println(s"name:${name}, age: $age, gender:$gender")
    }
}
执行过程：
-----Fu---main-constructor---
-----Zi---main-constructor(gender:Int)---
-----Zi---assist-constructor()---
name:郭靖, age: 22, gender:1

子类调用父类有参构造

class Fu {
    println("-----Fu---main-constructor---")
    var name:String = _
    var age:Int = _
    def this(name:String, age:Int) {
        this()
        this.name = name
        this.age = age
        println("-----Fu---assist-constructor(name:String, age:Int)---")
    }
}

class Zi(name:String, age:Int, gender:Int) extends Fu(name, age) {
    println("-----Zi---main-constructor(gender:Int)---")
    def this() {//辅助构造器
        this("zhangsan", 14, 1)
        println("-----Zi---assist-constructor()---")
    }

    def show(): Unit = {
        println(s"name:${name}, age: $age, gender:$gender")
    }
}
执行过程：
-----Fu---main-constructor---
-----Fu---assist-constructor(name:String, age:Int)---
-----Zi---main-constructor(gender:Int)---
-----Zi---assist-constructor()---
name:zhangsan, age: 14, gender:1

总结：

scala在加载子类构造器的同时去加载父类构造器，其道理和java中是一致的，不同点在于，scala只有主构造器才 
可以直接调用父类的构造器(主构造器和辅助构造器)，辅助构造器是无法直接调用父类的构造器，因为在辅助构造
器的第一句话必须是this,去调用其他辅助构造器或者主构造器，所以辅助构造器只能通过主构造器来间接的调用父
类的构造器。

2.2.6. 匿名子类

其实说白了就是匿名内部类，啥叫匿名类？匿名子类？

没有名字的类就叫匿名类，没有名字的类就叫做匿名子类。

什么又叫做有名字的类。

public class Person{}—>这就是有名字的，定义好有名字的类。源码阶段的概念

new Person() {} —>这就是一个没有名字的类 —>运行时的概念

匿名子类最常见的作用，一般都在某个操作仅仅出现一次的时候被使用，在方法的参数上面多出现匿名子类，

在java中出现最多的匿名类或者匿名子类，就是接口或者抽象类。

java中匿名类的使用

public class DynamicProxyOps {
    public static void main(String[] args) {

        /*
            构建一个Singer动态代理的对象
            类加载器
            源代码 .java --->编译-->.class --类加载器-> jvm
         */
        final Singer singer = new Singer("郭靖", 22);
        Singers proxySinger = (Singers) Proxy.newProxyInstance(
                singer.getClass().getClassLoader(),
                singer.getClass().getInterfaces(),
                new InvocationHandler() {
                    //代理的方式

                    /**
                     *
                     * @param proxy 这个就是代理之后的对象
                     * @param method    要代理的对象上面的方法
                     * @param args      当前method对应的参数
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("出任丐帮帮主");//前置通知
                        Object result = method.invoke(singer, args);
                        System.out.println("打狗棒法传授一下");//后置通知
                        return result;
                    }
                }
        );
        proxySinger.sing();

    }
}
interface Singers {
    void sing();
}
class Singer implements Singers {
    private String name;
    private int age;

    public Singer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sing() {
        System.out.println(name + " 正在练武");
    }
}

scala中使用匿名类

object _05ExtendsOps {
    def main(args: Array[String]): Unit = {
        val worker = new Worker("郭靖", 22)
        val 警察叔叔 = new Worker("阿 sir.", 28){//匿名子类
            override def work(): Unit = {
                super.work()
                println("为莘莘学子保驾护航~~~")
                println("阿 sir。辛苦了")
            }
            def fetchThief(): Unit = {
                println("阿 sir专抓偷心贼")
            }
        }
        警察叔叔.fetchThief()
        worker.makeFriend(警察叔叔)
    }
}
class Worker {
    var name:String = _
    var age:Int = _

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

    def makeFriend(worker: Worker): Unit = {
        println(this.name + "和 " + worker.name + "成为了工友")
        worker.work()
    }

    def work(): Unit = {
        println("劳心者治人，劳力者治于人")
    }
}

2.2.7. 抽象类和抽象字段

what is abstract?

编程语言中的抽象，就是只给出了定义，并没有给出实现。只能交由具体的实现者来完成，为了表示抽象和非抽象(具像，具体)，在java或者scala中使用关键字abstract来进行标识。

> 需要指出的是，在java中只有抽象方法，没有抽象字段，但是在scala既有抽象方法，又有抽象字段。

特点

scala既有抽象方法，又有抽象字段
抽象方法和抽象字段，不用abstract进行修饰，只有类采用abstract进行修饰
所谓抽象字段，只有在抽象类中才可以存在，也就是没有进行初始化的值
子类去覆盖父类的抽象的时候，不想非抽象类，可以省略掉override关键字

object _06AbstractOps {
    def main(args: Array[String]): Unit = {
        val p = new Chinese
        p.eat()
    }
}

abstract class Human {
    var name:String
    var birthday:String = _
    def eat()
    def sleep(): Unit = {
        println("中午不睡，下午崩溃~")
    }
}

class Chinese extends Human {
    def eat(): Unit = {
        println(name + "使用筷子吃饭")
    }

    override  var name = "炎黄子孙"
}

有一个疑问？

大伙在java学习过，只能单继承，无法多继承，原因是什么？

如果一个类，继承两个类，而这两个类都有相同的方法，子类在使用过程中无法辨别该方法到底来源于哪一个父类。

java中为了解决这个只能单继承的问题，提出了两个方案，第一个就是多层继承，这是从纵向解决；第二个就是多实现。

scala也只能进行单继承和多层继承，无法多继承。

2.2.8. trait特质

trait特质是一个和class、object同一level的结构。

trait和java中的接口有点像，但不完全一样，java中的interface中的所有的方法都是抽象的，而trait既可以拥有抽象方法，也可以拥有非抽象方法，所以其实可以理解为抽象类。

已经有了一个抽象类，那干嘛有搞出一个trait特质呢？

那是因为，如果只有抽象类的话，在继承体系中只能单继承和多层继承，无法多extends，所以需要一个新的结构来弥补，这个结构就是trait特质。

需要大家注意的是，java中实现一个interface使用关键字implement，实现多个interface时候，interface之间使用“,”分割，scala中扩展trait的时候，同样也是用extends关键字，扩展多个trait的时候，trait之间使用with关键字连接。

如果trait中的所有的方法都是抽象的，那就是java中的interface。

示例：

object _07TraitOps {
    def main(args: Array[String]): Unit = {
        val mp = new MainOperation
        mp.debug("取法乎上仅得乎中，取法乎中仅得其下，取法乎下仅得其下下")
    }
}

//特质
trait Logger {
    def log(msg:String)
}

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

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

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


class MainOperation extends ConsoleLogger with Logger{
    def debug(msg:String): Unit = {
        print("debug: ")
        super.log(msg)
    }
}

混入：

把上述的MainOperation修改一下：

class MainOperation extends ConsoleLogger {
    def debug(msg:String): Unit = {
        print("debug: ")
        super.log(msg)
    }
}

如果这是张三开发的代码，李四在用的时候，觉得之extends ConsoleLogger不完善，还需要扩展其他的trait，但是联合开发的话，一般都不要随便修改别人的代码。

但是还是想要增加新的功能，怎么做呢，一种方式新写一个类集成张三写的类的同时又扩展新的的功能，可以，但是略微麻烦一点，所以这里在scala中使用混入这样一个概念去处理。

在运行时去扩展一个特质，如下，便让李四写的对象在原有的基础之上增加新的功能，对原先的类没有侵入。

val mmp = new MainOperation with MyTrait //scala特质的混入 mix in
mmp.debug("dafaff")
mmp.show()

trait MyTrait {
    def show(): Unit = {
        println("江上如此多娇~")
    }
}

baiyabai

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Scala总结之基础练习和面向对象

Scala总结二之基础练习和面向对象一. scala基础练习1.1. 字符串转换为数字1.2. 使用scala完成选择排序1.3. 使用scala完成二分查找二. scala面向对象2.1. 类的基本操作2.1.1. 类的创建与对象的构造2.1.2. 成员变量的封装getter和setter2.1.3. case class模拟javabean2.1.4. scala类的构造器2.1.5. 嵌套类...
复制链接

扫一扫