Scala深入学习之面向对象学习

梦里梦外; 2022-12-08 05:18 205阅读 0赞

### 目录 ###

*   *  一、封装
     *  二、类的构造
     *  三、内部类
     *  四、Object对象
     *  五、伴生对象
     *  六、类的继承
     *  七、类的类型检查和转换
     *  八、受保护的字段
     *  九、超类的构造
     *  十、匿名内部类
     *  十一、抽象类
     *  十二、抽象字段
     *  十三、特质Trait

## 一、封装 ##

定义一个类，实际上就是把一类事物的共有的属性和行为提取出来，形成一个物理模型（模板）。这种研究问题的方法称为抽象。

面向对象编程有三大特征:封装、继承和多态。

封装（encapsulation）就是把抽象出的数据和对数据的操作封装在一起， 数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。  
封装的理解和好处：

*  隐藏实现细节，可以对数据进行验证，保证安全合理

如何体现封装：

*  对类中的属性进行封装
 *  通过成员方法，包实现封装

封装的实现步骤将属性进行私有化提供一一个公 共的set方法，用于对属性判断并赋值  
提供一个公共的get方法，用于获取属性的值

**封装的示例代码：**

package encapsulationDemo
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/9/17 * @time : 10:57 下午 * scala的类的定义 * Scala和Java一样，都是用关键字class来进行声明 * 在Scala中刚刚创建的这个类，其实就模拟了Java中的javabean，当然在Scala中有一个专门的类结构来表示Java中的bean -- case class（样例类）， * 会自动的给其中的字段提供getter和setter方法 */
    
    object ClassOps { 
      def main(args: Array[String]): Unit = { 
        // 创建类的对象
        val person:Person = new Person()
        person.setName("张三")
        person.setAge(14)
        println(s"name:${person.getName},age:${person.getAge}")
      }
    }
    
    // 定义了一个Scala的类，类名为Person
    class Person{ 
      // 定义了一个String类型的成员name，并赋予默认值，默认值为null
      private var name:String = _
      // 定义了一个Int类型的成员age，并赋予默认值，默认值为0
      private var age:Int = _
    
      // 提供getter和setter来处理
      def setName(n:String):Unit = { 
        name = n
      }
      // 单行函数
      def getName = name
    
      def setAge(a:Int):Unit = { 
        if (a<1 || a>=150){ 
          throw new RuntimeException("年龄不能小于1，或者不能超过150岁")
        }
        age = a
      }
      def getAge = age
    }

运行结果：

name:张三,age:14

## 二、类的构造 ##

1、和Java或C++一样，Scala可以有任意多的构造器。不过Scala类有一个构造器比其他所有构造器都更为重要，它就是主构造器（primary constructor） 。除了主构造器之外，类还可以有任意多的辅助构造器（ auxiliary constructor）

2、辅助构造器的名称为this。在Java或C++中，构造器的名称和类名相同，当你修改类名时就不那么方便了。每一个辅助构造器都必须以一个对先前已定义的其他辅助构造器或主构造器的调用开始

3、scala中构造器的定义  
（1）Scala中和类名相同的方法并不是构造器  
（2）通过分析，Scala的其中一个构造器就在类名后面，因为是无参的，所以默认省略（），也是参数列表  
问题分析：

*  1、该构造器的方法体呢？  
    通过代码验证，说明Scala类的构造器的函数体和类的定义交织在了一起
 *  2、可不可以拥有其他的构造器？  
    Scala不能用类名做构造器，而是使用this关键字来代替这里的类名

（3）由2的内容，我们可以归纳如下

*  Scala的构造器有两种，一种在类名后面定义的，一种在类中使用关键字来定义的  
    第一种的构造器，被称为Scala类的主构造器  
    第二种的构造器，被称为Scala类的辅助构造器
 *  Scala中的辅助构造器的第一句话，必须要调用本类的主构造器或者其他辅助构造器

**类的构造示例代码：**

package encapsulationDemo
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/9/18 * @time : 1:37 下午 * scala中构造器的定义 * 1、Scala中和类名相同的方法并不是构造器 * 2、通过分析，Scala的其中一个构造器就在类名后面，因为是无参的，所以默认省略（），也是参数列表 * 问题分析？ * 1、该构造器的方法体呢？ * 通过代码验证，说明Scala类的构造器的函数体和类的定义交织在了一起 * 2、可不可以拥有其他的构造器？ * Scala不能用类名做构造器，而是使用this关键字来代替这里的类名 * 3、由2的内容，我们可以归纳如下 * 1、Scala的构造器有两种，一种在类名后面定义的，一种在类中使用关键字来定义的 * 第一种的构造器，被称为Scala类的主构造器 * 第二种的构造器，被称为Scala类的辅助构造器 * 2、Scala中的辅助构造器的第一句话，必须要调用本类的主构造器或者其他辅助构造器 */
    object ConstructorOps { 
    
      def main(args: Array[String]): Unit = { 
        val teacher:Teacher = new Teacher()
        teacher.show()
        teacher.Teacher()
    
        println("==========这里使用Scala的有参数的构造器==========")
        val teacher1 = new Teacher("李四",20)
        teacher1.show()
    
        println("==========这里使用Scala的有参主构造器==========")
        val teacher2 = new Teacher1("张三",23)
        teacher2.show()
      }
    }
    
    // Scala中有参主构造器
    class Teacher1/*private主构造器的私有化*/ (name:String,age:Int){ 
      def show():Unit = { 
        println(s"name:${name},age:${age}")
      }
    }
    
    class Teacher(/*这是Scala的默认的类的无参构造器，而且这还是最特殊的一个构造器*/){ 
      private var name:String = _
      private var age:Int = _
    
      println("如果这是类的构造器的话，该语句将会被调用～")
    
      // Scala中Teacher()不是构造器，就是普通方法
      def Teacher():Unit = { 
        println("如果这是类的构造器的话，该方法将会被调用～")
      }
    
      def this(name:String,age:Int){ 
        this()
        this.name = name
        this.age = age
        println("如果这是类的有参构造器的话，该语句将会被调用")
      }
    
      def show():Unit = { 
        println(s"name:${name},age:${age}")
      }
    }

运行结果：

如果这是类的构造器的话，该语句将会被调用～
    name:null,age:0
    如果这是类的构造器的话，该方法将会被调用～
    ==========这里使用Scala的有参数的构造器==========
    如果这是类的构造器的话，该语句将会被调用～
    如果这是类的有参构造器的话，该语句将会被调用
    name:李四,age:20
    ==========这里使用Scala的有参主构造器==========
    name:张三,age:23

## 三、内部类 ##

**示例代码：**

package encapsulationDemo
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/9/18 * @time : 2:30 下午 * Scala内部类 */
    object InnerClassOps { 
      def main(args: Array[String]): Unit = { 
        val outer:Outer = new Outer()
        // 创建Scala的内部类对象
        val inner = new outer.Inner()
        inner.show()
    
      }
    }
    class Outer {  o => // 此时o就是本类对象的引用
      val x = 5
      class Inner{  i => // 此时就是本类对象的引用
        val x = 6
    
        def show(): Unit ={ 
          val x = 7
          println("x = "+x)
          println("x = "+this.x)
          println("x = "+i.x)
          println("x = "+Outer.this.x)
          println("x = "+o.x)
    
        }
      }
    }

运行结果：

x = 7
    x = 6
    x = 6
    x = 5
    x = 5

## 四、Object对象 ##

**scala中的Object结构：**  
在Java的一个类中，既可以拥有static静态，也可以拥有非static，同时Java中的主函数必须是static。但是Scala中的class只能提供非static的成员，所以要想Scala也能提供static的成员，就必须使用object结构。Scala的object中定义的成员都是类似于Java中的静态成员，也就是直接可以通过类名.调用，无需创建对象。

**object的主要作用：**

*  给Scala类提供程序运行入口，静态的main函数
 *  给Scala类也能够提供静态成员–Scala类的伴生对象来实现

object ObjectOps { 
      def main(args: Array[String]): Unit = { 
        println("hello world")
      }
    }

## 五、伴生对象 ##

scala中的伴生对象：scala中把同一个源文件中相同名称的object结构称为class结构的伴生对象，反过来把这个class结构称之为object结构的伴生类。

*  class CompanionClass 是object CompanionClass的伴生类
 *  object CompanionClass 是 class CompanionClass的伴生对象

构建伴生类/伴生对象成立的几个前提：  
1、二者必须在同一个.class源文件  
2、二者名称必须相同

伴生类/伴生对象的特点：  
1、伴生对象可以访问伴生类中非私有和私有的成员  
2、通常我们需要在伴生对象中覆盖一个方法–apply，用于构造伴生类的实例  
比如,Array,ArrayBuffer,Map 等等都是通过伴生对象来创建对象，该构造的时候其实就是调用了伴生对象apply方法。该apply方法的特点：

*  返回值类型是本类引用
 *  参数列表对应伴生类的构造器的参数列表

3、有了伴生对象，同时覆盖了apply方法，便给伴生类提供了一个简化的对象构造器方式，即省略了new关键字

**代码示例：**

package encapsulationDemo
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/9/21 * @time : 9:48 上午 * * scala中的伴生对象 * scala中把同一个源文件中相同名称的object结构称为class结构的伴生对象，反过来把这个class结构称之为 * object结构的伴生类。 * * class CompanionClass 是object CompanionClass的伴生类 * object CompanionClass 是 class CompanionClass的伴生对象 * 构建伴生类/伴生对象成立的几个前提 * 1、二者必须在同一个.class源文件 * 2、二者名称必须相同 * 伴生类/伴生对象的特点 * 1、伴生对象可以访问伴生类中非私有和私有的成员 * 2、通常我们需要在伴生对象中覆盖一个方法--apply，用于构造伴生类的实例 * 比如,Array,ArrayBuffer,Map 等等都是通过伴生对象来创建对象，该构造的时候其实就是调用了伴生对象apply方法 * 该apply方法的特点： * 1、返回值类型是本类引用 * 2、参数列表对应伴生类的构造器的参数列表 * 3、有了伴生对象，同时覆盖了apply方法，便给伴生类提供了一个简化的对象构造器方式，即省略了new关键字 * */
    object CompanionObjectOps { 
        def main(args: Array[String]): Unit = { 
            val cc = new CompanionClass()
            println("-------------------")
            val cc1 = CompanionClass
            println("-------------------")
            val cc2 = CompanionClass("张三",13)
        }
    }
    class CompanionClass{ 
        private val x = 6
    
        def this(name:String,age:Int){ 
            this()
            println("name:"+name)
            println("age:"+age)
        }
    }
    object CompanionClass{ 
        val cc = new CompanionClass
        println(cc.x)
    
        def apply(): CompanionClass = { 
            new CompanionClass()
        }
    
        def apply(name:String,age:Int): CompanionClass = { 
            new CompanionClass(name,age)
        }
    }

运行结果：

-------------------
    6
    -------------------
    name:张三
    age:13

## 六、类的继承 ##

Scala扩展类的方式和Java一样，使用extends关键字:

继承就代表，子类可以从父类继承父类的field和method，然后子类可以在自己内部放入父类所没有，子类特有的field和method，使用继承可以有效复用代码。

不可扩展关键字：  
子类可以覆盖父类的field和method，但是如果父类用final修饰，field和method用finaI修饰， 则该类是无法被扩展的，field和method是无法被覆盖的。

scala 中的继承/扩展

*  使用关键字extends来产生这种继承或者扩展关系
 *  子类可以继承父类中所有非私有的成员
 *  子类不能覆盖父类中被final所修饰的成员
 *  Scala中子类覆盖父类的方法时，必须要添加关键字override进行修饰，以标识要对父类方法进行覆盖，否则认为子类重新定义一个同名方法，这就会造成方法同名，会报错
 *  子类要想访问父类的成员时候，就需要使用super关键字来完成

**示例代码：**

package extendsDemo
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/9/22 * @time : 2:53 下午 * * scala 中的继承/扩展 * 1、使用关键字extends来产生这种继承或者扩展关系 * 2、子类可以继承父类中所有非私有的成员 * 3、子类不能覆盖父类中被final所修饰的成员 * 4、Scala中子类覆盖父类的方法时，必须要添加关键字override进行修饰，以标识要对父类方法进行覆盖， * 否则认为子类重新定义一个同名方法，这就会造成方法同名，会报错 * 5、子类要想访问父类的成员时候，就需要使用super关键字来完成 */
    object ExtendsOps1 { 
        def main(args: Array[String]): Unit = { 
            val stu = new Student("张三")
            stu.show()
    
        }
    }
    // 父类
    class Person{ 
        var name:String = _
        var age:Int = 15
    
        def this(name:String,age:Int){ 
            this()
            this.name = name
            this.age = age
        }
        def show(): Unit ={ 
            println(s"name:${name},age:${age}")
        }
        def setName(name:String) = this.name = name
    }
    // 子类
    class Student extends Person{ 
        def this(name:String){ 
            this()
            // 完成name的赋值
            // this.name = name
            super.setName(name)
        }
    
        override def show(): Unit = { 
            // 调用父类的show方法
            super.show()
            println("------student-----show------")
        }
    }

运行结果：

name:张三,age:15
    ------student-----show------

## 七、类的类型检查和转换 ##

scala中的类型检查和类型转换

*  类型检查：obj.isInstanceOf\[类型\]
 *  类型转换：obj.asInstanceOf\[类型\]

**示例代码：**

package extendsDemo
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/9/22 * @time : 4:09 下午 * * scala中的类型检查和类型转换 * 类型检查：obj.isInstanceOf[类型] * 类型转换：obj.asInstanceOf[类型] */
    object ObjectEqualsOps { 
        def main(args: Array[String]): Unit = { 
            val w1 = new Worker("张三",15)
            val w2 = new Worker("张三",15)
            println(w1.equals(w2))
    
        }
    }
    class Worker{ 
        var name:String = _
        var age:Int = _
    
        def this(name:String,age:Int){ 
            this()
            this.name = name
            this.age = age
        }
    // 传统写法
    // override def equals(obj: Any): Boolean = { 
    // if (obj == null){ 
    // false
    // }
    // else if (!obj.isInstanceOf[Worker]){ 
    // false
    // } else { 
    // // 将obj转化为Worker
    // val that:Worker = obj.asInstanceOf[Worker]
    // this.name.eq(that.name) && this.age == that.age
    // }
    // }
        /** 使用Scala中的模式匹配来完成类型检查和类型转换 注意：在写模式匹配的时候，一定要把默认的选项加上，避免所有的可能性都没有匹配成功，此时就会报错：scala.MatchError */
    
        override def equals(obj: Any): Boolean = { 
            obj match { 
                case that:Worker =>{ 
                    this.name.eq(that.name) && this.age == that.age
                }
                case _ =>{  // 匹配不上前面的可能性，就使用这种默认的
                    println("类型不匹配，不能进行比较")
                    false
                }
            }
        }
    }

运行结果：

true

## 八、受保护的字段 ##

1、跟java一样，scala中同样 可以使用protected关键字来修饰field和method，这样在于类中就不需要super关键字，直接就可以访问field和method  
2、scala 中还提供了一个protected\[this\]，则只能在当前子类对象中访问父类的field和method，无法通过其他子类对象访问父类的fieId和method  
**示例代码：**

package extendsDemo
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/10/7 * @time : 11:20 上午 * scala 中被protected修饰的成员特点 * scala在使用protected和private做访问权限修饰的时候，除了传统的意义意外，还可以做到非常精准的控制某一个成员在某一个package下面被访问。 * 就在protected/private[具体包名]，该成员只能在该包，及其子包下面被访问 * 其中有一个特例，就是protected[this]，只能子在本类及其子类中被使用，不能被子类实例中来进行访问 */
    object ProtectedOps { 
        def main(args: Array[String]): Unit = { 
            var dog1 = new Dog("dog1")
            var dog2 = new Dog("dog2")
            dog1.makeFriends(dog2)
        }
    }
    class Animal{ 
        var name:String=_
    
    // protected var age = 3
        protected[extendsDemo] var age = 3
    
        def this(name:String,age:Int){ 
            this()
            this.name = name
            this.age = age
        }
        def show(): Unit ={ 
            println(s"Animal:${name},${age}")
        }
    }
    class Dog extends Animal{ 
        age = 5
        def this(name:String){ 
            this()
            this.name = name
        }
        def makeFriends(dog: Dog): Unit ={ 
            println(s"${this.name} age is ${this.age} 要和 ${dog.name} age is ${dog.age} 交朋友")
        }
    }

运行结果：

dog1 age is 5 要和 dog2 age is 5 交朋友

## 九、超类的构造 ##

1、一个类有一个主构造器和任意数量的辅助构造器，而每个辅助构造器都必须以对先前定义的辅助构造器或主构造器的调用开始。这样做帶来的后果是，辅助构造器永远都不可能直接调用超类的构造器。  
2、子类的辅助构造器最终都会调用主构造器，只有主构造 器可以调用超类的构道器。主构造器是和类定义交织在一起的，调用超类构造器的方式也同样交织在一起。

**示例代码：**

package extendsDemo
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/10/7 * @time : 2:47 下午 * scala中超类的构造过程 * 1、Scala中在继承体系中，构造子类的时候，先有构造父类 * 2、子类在构造器中要想传递参数到父类的构造器中，只能通过主构造器 * 因为辅助构造器的第一句话，只能调用本类的主构造器，或者其他辅助构造器 */
    object ExtendsOps2 { 
        def main(args: Array[String]): Unit = { 
            val zi:Fu = new Zi(13)
        }
    }
    class Fu(name:String,age:Int){ 
        println("----------Fu-primary-constructor----------")
        def this(name:String){ 
            this(name,13)
            println("----------Fu-this(name:String)-constructor----------")
        }
    }
    class Zi(name:String,age:Int) extends Fu(name) { 
        println("----------Zi-primary-constructor----------")
    
        def this(age:Int){ 
            this("zhangsan",age)
            println("----------Zi-this(name:String)-constructor----------")
        }
    }

运行结果：

----------Fu-primary-constructor----------
    ----------Fu-this(name:String)-constructor----------
    ----------Zi-primary-constructor----------
    ----------Zi-this(name:String)-constructor----------

## 十、匿名内部类 ##

1、在Scala中， 匿名子类是非常常见，而且非常强大，因为Spark源码中也大量使用了这种匿名子类。  
2、匿名子类，也就是说，可以定义一个类的没有名称的子类，并直接创建其对象，然后将对象的引用赋予一个变量。之后甚至可以将该匿名子类的对象传递给其他函数  
**示例代码：**

package extendsDemo
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/10/7 * @time : 3:24 下午 * * scala中的匿名子类---匿名内部类 * 匿名的意思就是说该类名名称 * 通常出现在继承体系中，对于接口，抽象类只被调用一次的情况，同时父类中的（抽象）方法相对较少 * * class Xxx{}---这不是匿名的 * * new Xxx{} --- 匿名子类、 * * 常见的作用：作为方法的参数出现 */
    object AnnominyInnerClassOps { 
        def main(args: Array[String]): Unit = { 
            // 调用非匿名子类来实现
            showName(new NameAnnominy)
            println("通过匿名子类来实现")
            val annominy = new Annominy(){ 
                // 这是Annominy的一个匿名子类
                override def show(): Unit = { 
                    super.show()
                    println("hello scala")
                }
                def myPrint(): Unit ={ 
                    println("hello java!")
                }
            }
            annominy.show()
            annominy.myPrint()
            showName(annominy)
    
            println("通过局部匿名内部类来实现")
            showName(new Annominy(){ 
                override def show(): Unit = { 
                    super.show()
                    println("hello scala")
                }
            })
        }
    
        def showName(annominy: Annominy): Unit ={ 
            annominy.show()
        }
    }
    class Annominy{ 
        val name:String = "Hello World!"
        def show(): Unit ={ 
            println(name)
        }
    }
    // 非匿名子类
    class NameAnnominy extends Annominy{ 
    
    }

运行结果：

Hello World!
    通过匿名子类来实现
    Hello World!
    hello scala
    hello java!
    Hello World!
    hello scala
    通过局部匿名内部类来实现
    Hello World!
    hello scala

## 十一、抽象类 ##

Scala中的抽象类  
1、Scala中一个类的方法或者字段只做了一个声明没有进行实现或者初始化，我们把这类称之为抽象类，需要使用关键字abstract来进行声明  
2、Scala中的抽象类和Java一样，既可以有抽象成员，也可以有非抽象成员  
3、Scala类中子类复写父类的抽象成员的时候，我们可以省略掉override关键字  
4、Scala中的抽象成员，可以省略abstract关键字

**示例代码：**

package abstracts
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/10/8 * @time : 1:01 下午 * * Scala中的抽象类 * 1、Scala中一个类的方法或者字段只做了一个声明没有进行实现或者初始化，我们把这类称之为抽象类，需要使用关键字abstract来进行声明 * 2、Scala中的抽象类和Java一样，既可以有抽象成员，也可以有非抽象成员 * 3、Scala类中子类复写父类的抽象成员的时候，我们可以省略掉override关键字 * 4、Scala中的抽象成员，可以省略abstract关键字 */
    object AbstractOps1 { 
        def main(args: Array[String]): Unit = { 
            // 父类引用指向子类对象，实现多态
            val bat:Animal = new Bat
            bat.sleep()
            bat.dead()
            val dog:Animal = new Dog
            dog.sleep()
            dog.dead()
    
        }
    }
    abstract class Animal{ 
        var color:String = _
        // 只有方法的定义，没有方法的实现，这就是一个抽象方法
        def sleep()
        // 非抽象成员
        def dead(): Unit ={ 
            println("动物皆有一死")
        }
    }
    
    class Bat extends Animal{ 
        color = "黑色"
        override def sleep(): Unit = { 
            println("倒挂金钟")
        }
    
        override def dead(): Unit = { 
            println("禁止吃野生动物")
        }
    }
    class Dog extends Animal{ 
        color = "黄色"
        override def sleep(): Unit = { 
            println("趴着睡觉")
        }
    
        override def dead(): Unit = { 
            println("狗是人类忠诚的朋友")
        }
    }

运行结果：

倒挂金钟
    禁止吃野生动物
    趴着睡觉
    狗是人类忠诚的朋友

## 十二、抽象字段 ##

Scala中的抽象字段：所谓抽象字段，就是只有字段的声明，没有初始化的字段  
**示例代码：**

package abstracts
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/10/8 * @time : 1:26 下午 * * Scala中的抽象字段 * 所谓抽象字段，就是只有字段的声明，没有初始化的字段 */
    object AbstractOps2 { 
        def main(args: Array[String]): Unit = { 
            val abstractZi:AbstractZi = new AbstractZi
            println("name:"+abstractZi.name)
            println("age:"+abstractZi.age)
    
        }
    }
    abstract class AbstractFu{ 
        // 定义了一个抽象的val和var的字段
        val name:String
        var age:Int
    }
    class AbstractZi extends AbstractFu{ 
        override val name: String = "张三"
        override var age: Int = 23
    }

运行结果：

name:张三
    age:23

## 十三、特质Trait ##

特质（Traits） 用于在类（Class）之间共享程序接口（Interface）和字段 （Fields）。 它们类似于 Java8的接口。类和对象 （Objects） 可以扩展特质，但是特质不能被实例化，因此特质没有参数。

特质的定义除了使用关键字trait之外，与类定义无异。

在triat中可以定义抽象方法，就与抽象类中的抽象方法一样， 只要不给出方法的具体实现即可。

类可以使用extends关键字继承trait，注意，这里不是implement，而是extends， 在scala中没有implement的概念，无论继承类还是trait，统一都是extends.

**示例代码：**

package abstracts
    
    /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/10/8 * @time : 2:28 下午 * * Scala的特质Trait * 什么是trait特质？ * 特质trait，就是在Scala中一种和class、object同一级别的语法结构，需要被trait关键字进行声明 * 为什么要有trait特质？ * Java和Scala的继承特点？ * 不仅仅指的是：封装、继承、多态、抽象。 * 只能进行单继承，不可以进行多继承。 * 这种单继承，是有局限的，只能单一的继承某一个类的成员，在Scala和Java中是无法做到再去继承其他类的特性。 * 为了弥补这个缺陷，在Java和Scala中，首先就有多层继承 * A extend B, B extend C <=> A继承了B，同时也继承了C的特性 * 其次在Java中还有一个多实现的概念，被实现的结构称之为接口（interface），接口中的所有的方法都是抽象的 * * 要进行实现的所有的方法都是抽象，那如果一个接口的方法很多，在实现起来很麻烦，所以在Java中又有一种设计模式——适配器 * * 于是，在Scala中就弥补这个设计上的缺憾——Java中多实现的方法都需要自己来实现，那么也就是说，在Scala中是可以多实现的，同时 * 多实现的方法不一定都是抽象。 * * Scala中把类似Java中的这种多实现接口（interface），不叫多实现，而称之为trait特质的多扩展 * Scala中的trait在一定程度上，是可以看作Java中的接口interface，如果一个trait特质中的所有的方法都是抽象的，那么就可以将其视为Java中的一个接口 * * 在Java中，实现多个接口的时候，使用的是关键字interface，多个使用","来进行分割 * 在Scala中，扩展特质trait和扩展父类使用的是相同的关键字extends，扩展多个trait的时候使用with关键字进行分割 * 而且，如果即继承一个类，又扩展一个特质，书写的顺序是继承类优先，其次在with特质 */
    object TraitOps { 
        def main(args: Array[String]): Unit = { 
            val consoleLog = new ConsoleLog with TraitMix
            consoleLog.log("行车不规范，亲人两行泪")
            consoleLog.show()
            consoleLog.method()
    
            // 混入
            consoleLog.mix()
        }
    }
    class TraitFu{ 
        def method(): Unit ={ 
            println("---TraitFu-method---")
        }
    }
    /* 在运行时，让一个类具备另外一个类的特征，把这种操作，称之为Scala中的混入，此时的影响只是在局部 只需要在创建类对象的时候，使用关键字with连接需要具备的类即可 */
    trait TraitMix{ 
        def mix(): Unit ={ 
            println("这是为了证明Scala中的特质还有更NB的地方-混入")
        }
    }
    
    trait Log{ 
        // 抽象方法
        def log(msg:String)
        def show(): Unit ={ 
            println("这就是为了证明，Scala中的trait要比Java中的interface接口更NB")
        }
    }
    // 继承类优先，其次with特质
    class ConsoleLog extends TraitFu with Log with Serializable  { 
        override def log(msg: String): Unit = { 
            println("控制台："+msg)
        }
    }
    
    // 扩展特质trait用关键字extends
    class FileLog extends Log{ 
        override def log(msg: String): Unit = { 
            println("文件："+msg)
        }
    }

运行结果：

控制台：行车不规范，亲人两行泪
    这就是为了证明，Scala中的trait要比Java中的interface接口更NB
    ---TraitFu-method---
    这是为了证明Scala中的特质还有更NB的地方-混入

--------------------

以上内容仅供参考学习，如有侵权请联系我删除！  
如果这篇文章对您有帮助，左下角的大拇指就是对博主最大的鼓励。  
您的鼓励就是博主最大的动力！