Sgg：Scala面向对象语法（类&构造器）

• Scala 是基于 Java 的语言，所以基本的语法非常的类似，但是， 为了能好的体现，高效，简单，灵活等特性， Scala 语言做了极大的努力。 对 Java 的很多语法进行了改进。

1 类

• 在 Scala 中，你几乎可以在任何语法结构中内嵌任何语法结构。 如在类中可以再定义一个类，这样的类是嵌套类， 其他语法结构也是一样。嵌套类类似于 Java 中的内部类。

public class Java01_Class {
    //成员内部类
    class InnerClass {
    }
    static class StaticInnerClass {
    }

    public static void main(String[] args) {
        //三种创建成员内部类的方法
        Java01_Class outer = new Java01_Class();
        Java01_Class.InnerClass inner = outer.new InnerClass(); // 很诡异的写法
        Java01_Class.StaticInnerClass staticInner = new Java01_Class.StaticInnerClass();
    }
}

• 任意语法结构可以嵌套任意语法结构
  Scala的内部类写法：

class Scala01_Class {
  //成员内部类
  class InnerClass {
  }

}

//下面是静态的成员内部类
//Scala 中没有静态的概念，所以静态内部类不是放在类中声明，而是放置在类的伴生对象中声明
object Scala01_Class{

  class StaticInnerClass{

  }

  def main(args: Array[String]): Unit = {
    val staticInner = new chaptor03.Scala01_Class.StaticInnerClass

    val out1 = new Scala01_Class
    val out2 = new Scala01_Class
    val inner1 = new out1.InnerClass

    val inner2 = new out2.InnerClass
  }
}

• 先看Java是如何声明并调用内部类方法的

public class Java01_Class {
    //成员内部类
    class InnerClass {
        //定义一个内部类的方法
        public void test(InnerClass inner){

        }
    }
    public static void main(String[] args) {
        /**
         * 创建两个内部类对象
         */
        Java01_Class outer1 = new Java01_Class();
        Java01_Class.InnerClass inner1 = outer1.new InnerClass(); // 很诡异的写法

        Java01_Class outer2 = new Java01_Class();
        Java01_Class.InnerClass inner2 = outer2.new InnerClass(); // 很诡异的写法
        
        //调用内部类分方法
        inner1.test(inner2);
        inner2.test(inner1);
    }
}

• 先看Scala是如何声明并调用内部类方法的
• 先遵循Java的方法

class Scala01_Class {
  //成员内部类
  class InnerClass {
    def test(ic:InnerClass): Unit ={

    }
  }
}

• 沿袭java的调用方式发现在Scala里面不可用：
  
  
  
• 其实Scala的类都不是类，都是函数，

• 内部类如果想要访问外部类的属性，可以通过外部类对象或外部类别名访问

class Scala01_Class {

  val name = "zhang3"

  //成员内部类
  class InnerClass {
    val name = "li4"
    //类型投影：可以忽略Scala对象的从属关系
    def test(ic:Scala01_Class#InnerClass): Unit ={
      //若想访问外部类的属性 类名.this.属性名
      println("name = " + Scala01_Class.this.name)
    }
  }

}

object Scala01_Class{
  def main(args: Array[String]): Unit = {
    val out1 = new Scala01_Class
    val out2 = new Scala01_Class

    val inner1 = new out1.InnerClass
    val inner2 = new out2.InnerClass

    inner1.test(inner2)
    inner2.test(inner2)
  }
}

运行结果：调用的外部类的属性name值 zhang3

name = zhang3
name = zhang3

Process finished with exit code 0

2 对象

构造器

• 和 Java 一样， Scala 构造对象也需要调用构造方法，并且可以有任意多个构造方法，不过， Scala 类有一个构造方法比其他所有的构造方法都更为重要，我们称之为主构造器，其他的构造器我们称之为辅助构造器.

主构造器

1. 主构造器的声明直接放置于类名之后

• 先看这个主构造函数的使用
  
  执行结果：

执行

Process finished with exit code 0

同样再调用这个对象的方法：

    val test = new Scala02_Object
    test.test()

运行结果：

执行
zhangfei

Process finished with exit code 0

2. 主构造器会执行类定义中的所有语句
3. 主构造器传递参数

// 如果主构造器无参数，小括号可省略
// 构造器也是方法（函数） ，传递参数和使用方法和前面的函数部分内容没有区别
class Scala02_Object (p:String){

  //类体
  //函数体
  //构造体

  val name = "zhangfei"

  println("执行")

  println("参数是" + p)

  def test():Unit = {
    println(name)
  }
}

object Scala02_Object{
  def main(args: Array[String]): Unit = {
    val test = new Scala02_Object("arg")
    test.test()
  }
}

执行
参数是arg
zhangfei

Process finished with exit code 0

辅助构造器

4. 辅助构造器名称为 this（这个和 Java 是不一样的），多个辅助构造器通过不同参数列表进行区分
   下面是Java的构造器
   
   来看Scala：

  //辅助构造器
  //每一句第一句代码都是要直接或者间接调用主构造器
  //辅助构造器无论是直接或间接，最终都一定要调用主构造器，执行主构造器逻辑
  def this(n:String){
    this()
  }

  def this(n:String,a:Int){
    this()
  }

辅助构造器没有主构造器没办法构造
5. 如果想让主构造器变成私有的，可以在()之前加上 private，这样用户只能通过辅助构造器来构造对象了

• 那么可以调用了