Scala中Object和Class区别(伴生类和伴生对象)

淡淡的烟草味﹌ 2022-11-14 14:52 415阅读 0赞

### 文章目录 ###

*  一,介绍
 *  二,类Class
 *   *  2.1 类定义
     *  2.2 构造器
     *   *  1.基本语法
         *  2.构造器参数
     *  2.3 私有成员和Getter/Setter语法
 *  三,单例对象Object
 *  四,伴生对象和伴生类介绍
 *  五,伴生类和伴生对象反编译后结果
 *  六,总结

# 一,介绍 #

Scala是一个完全面向对象的语言，故Scala去掉了Java中非面向对象的元素，如static关键字，void类型，为了能够调用静态语法(模拟静态语法)，采用伴生对象单例的方式

1.  Scala源码中包含了`main`方法,在编译后自动形成了`public static void main`
2.  scala在编译源码时,会生成两个字节码文件，静态`main`方法执行另一个字节码文件中的成员`main`方法
3.  Scala是完全面向对象的语言,那么没有静态的方法,只能通过模拟生成静态方法
4.  scala无static关键字，由object实现类似静态方法的功能（类名.方法名）
5.  class关键字和Java中的class关键字作用相同，用来定义一个类
6.  编译时将当前类生成一个特殊的类==>`Scala01_HelloWorld$`,然后创建对象来调用这个对象的main方法
7.  一般情况下,将加$的类的对象,称之为`伴生对象`
8.  伴生对象中的内容,都可以通过类名访问,来模拟java中的静态语法
9.  伴生对象的语法规则：使用object声明\[加上就一定能够使用类名来访问\]

# 二,类Class #

Scala中的类是用于创建对象的蓝图，其中包含了**方法、常量、变量、类型、对象、特质、类**，这些统称为成员。

object中定义的均为静态的，class中均是非静态的。

## 2.1 类定义 ##

一个最简的类的定义就是关键字class+标识符，类名首字母应大写。

class User
    val user1 = new User

关键字`new`被用于创建类的实例。`User`由于没有定义任何构造器，因而只有一个不带任何参数的默认构造器。然而，你通常需要一个构造器和类体。下面是类定义的一个例子：

class Point(var x: Int, var y: Int) { 
    
      def move(dx: Int, dy: Int): Unit = { 
        x = x + dx
        y = y + dy
      }
    
      override def toString: String =
        s"($x, $y)"
    }
    
    val point1 = new Point(2, 3)
    point1.x  // 2
    println(point1)  // prints (2, 3)

`Point类`有4个成员：变量`x`和`y`，方法`move`和`toString`。与许多其他语言不同，主构造方法在类的签名中`(var x: Int, var y: Int)`。`move`方法带有2个参数，返回无任何意义的`Unit`类型值()。这一点与Java这类语言中的`void`相当。另外，`toString`方法不带任何参数但是返回一个`String`值。因为`toString`覆盖了`AnyRef`中的`toString`方法，所以用了`override`关键字标记。

## 2.2 构造器 ##

和 Java 一样，Scala 构造对象也需要调用构造方法，并且可以有任意多个构造方法。

### 1.基本语法 ###

Scala 类的构造器包括：**主构造器和辅助构造器**

class  类名(形参列表) { 	// 主构造器
    	// 类 体
    	def	this(形参列表) { 	// 辅助构造器
    	}
    	
    	def	this(形参列表) { 	// 辅助构造器可以有多个...
    	}
    }

说明：

1.  辅助构造器，函数的名称 this，可以有多个，编译器通过参数的个数及类型来区分。
2.  辅助构造方法不能直接构建对象，必须直接或者间接调用主构造方法。
3.  构造器调用其他另外的构造器，要求被调用构造器必须提前声明。

如果主构造器无参数，小括号可省略，构建对象时调用的构造方法的小括号也可以省略。

//（1）如果主构造器无参数，小括号可省略
    //class Person (){ 
    class Person { 
    	var name: String = _ 
    	var age: Int = _
    	def this(age: Int) { 
    		this() 
    		this.age = age
    		println("辅助构造器")
    	}
    
    	def this(age: Int, name: String) {  
    		this(age)
    		this.name = name
    	}
    
    	println("主构造器")
    }
    
    object Person { 
    	def main(args: Array[String]): Unit = {  
    		val person2 = new Person(18)
    	}
    }

说明实例

// TODO Scala中的构造方法分为两类: 主构造方法(一个) & 辅助构造方法(多个)
    // Scala构建对象可以通过辅助构造方法创建,但是 TODO 必须要调用主构造方法
    // Scala是完全面向函数的语言,所以类也是函数
    // 类是函数,可以使用小括号作为函数的参数列表
    // 类所代表的函数其实就是这个类的构造方法
    // 默认情况下,scala也是给类提供无参构造方法,所以小括号可以省略
    // 在类的后面声明的构造方法就是主构造方法
    // 在主构造方法中声明的构造方法就是辅助构造方法
    // 辅助构造器的声明不能和主构造器的声明一致,会发生错误(构造器名重复)
    
    // 如果想让主构造器变成私有的,可以在()之前加上private,这样用户不能直接通过主构造器来构造对象了(可以通过伴生对象访问)
    
    class User09 private(s: String) {  // 主构造方法,如果主构造方法无参数,小括号可以省略
    
      // 类体 & 构造方法体
      println("主构造方法")
      println(s)
    
      // 辅助构造方法无论是直接或者间接,最终都一定要调用主构造器,执行主构造器的逻辑
      // 而且需要放在辅助构造器的第一行
      def this(s: String, ss: String) {  // 辅助构造方法
        this(s) // 直接调用主构造器
        println("辅助构造方法2")
      }
    
      // 声明辅助构造方法,方法名为this
      // TODO 构造方法调用其他的构造方法时,应该保证被调用的构造方法已经声明过
      def this() {  // 辅助构造方法可以有多个
        this("辅助构造方法1", "xxxx") // 间接调用主构造器,因为def this(s: String, ss: String)中调用了主构造器
      }
    
    
    }

### 2.构造器参数 ###

Scala 类的主构造器函数的形参包括三种类型：未用任何修饰、var 修饰、val 修饰

1.  未用任何修饰符修饰，这个参数就是一个局部变量
2.  var 修饰参数，作为类的成员属性使用，可以修改
3.  val 修饰参数，作为类只读属性使用，不能修改

案例实操

class Person(name: String, var age: Int, val sex: String) { 
    }
    object Test { 
    	 def main(args: Array[String]): Unit = { 
    		 var person = new Person("bobo", 18, "男")
    		 // （1）未用任何修饰符修饰，这个参数就是一个局部变量
    		 // printf(person.name)
    		 // （2）var 修饰参数，作为类的成员属性使用，可以修改
    		 person.age = 19
    		 println(person.age)
    		// （3）val 修饰参数，作为类的只读属性使用，不能修改
    		 // person.sex = "女"
    		 println(person.sex)
    	 } 
    }

构造器可以通过提供一个默认值来拥有可选参数：

class Point(var x: Int = 0, var y: Int = 0)
    
    val origin = new Point  // x and y are both set to 0
    val point1 = new Point(1)
    println(point1.x)  // prints 1

在这个版本的`Point`类中，`x`和`y`拥有默认值`0`所以没有必传参数。然而，因为构造器是**从左往右**读取参数，所以如果仅仅要传个y的值，你需要**带名传参**。

class Point(var x: Int = 0, var y: Int = 0)
    val point2 = new Point(y=2)
    println(point2.y)  // prints 2

## 2.3 私有成员和Getter/Setter语法 ##

成员默认是公有（`public`）的。使用`private`访问修饰符可以在类外部隐藏它们。

class Point { 
      private var _x = 0
      private var _y = 0
      private val bound = 100
    
      def x = _x
      def x_= (newValue: Int): Unit = { 
        if (newValue < bound) _x = newValue else printWarning
      }
    
      // 类似于java中的get方法
      def y = _y
      // 类似于java中的set方法
      def y_= (newValue: Int): Unit = { 
        if (newValue < bound) _y = newValue else printWarning
      }
    
      private def printWarning = println("WARNING: Out of bounds")
    }
    
    val point1 = new Point
    point1.x = 99
    point1.y = 101 // prints the warning

在这个版本的`Point`类中，数据存在私有变量`_x`和`_y`中。`def x`和`def y`方法用于访问私有数据。`def x_=`和`def y_=`是为了验证和给`_x`和`_y`赋值。

注意下对于setter方法的特殊语法：这个方法在`getter`方法的后面加上`_=`，后面跟着参数。

**主构造方法**中带有`val`和`var`的参数是公有的。然而由于`val`是不可变的，所以不能像下面这样去使用。

class Point(val x: Int, val y: Int)
    val point = new Point(1, 2)
    point.x = 3  // <-- does not compile

不带`val`或`var`的参数是私有的，仅在类中可见。

class Point(x: Int, y: Int)
    val point = new Point(1, 2)
    point.x  // <-- does not compile

# 三,单例对象Object #

object是类的单例对象，开发人员无需用new关键字实例化。如果对象的名称和类名相同，这个对象就是伴生对象

Scala object相当于java中的单例

object中定义的均为静态的，class中均是非静态的。

静态的可以直接用`Object名.属性/方法`来调用

Object就相当于一个静态的工具类，**main方法要写在object中。**

object中不可以传参，当创建一个object时，如果传入参数，那么会自动寻找object中的相应参数个数的apply方法。

apply可以写多个 保证参数不同即可

object ClassAndObj { 
      // object中定义的属性都是静态的
      val name = "wangwu"
    
      // 当给对象传入参数时,默认会调用apply方法
      def apply(i: Int) = { 
        println("Score is " + i)
      }
      // apply可以重写
      def apply(i: Int, s: String) = { 
        println("name is " + s + ",Score is " + i)
      }
    
      def main(args: Array[String]): Unit = { 
        // 对象不可以传参,当看到代码中出现为对象传参的情况,就说明代码中肯定会有一个apply方法
        ClassAndObj(30)
        ClassAndObj(30,"zhangsan")
      }
    }

一个单例对象是就是一个值。单例对象的定义方式很像类，但是使用的关键字是`object`

object Box

下面例子中的单例对象包含一个方法：

package logging
    object Logger { 
      def info(message: String): Unit = println(s"INFO: $message")
    }

方法`info`可以在程序中的任何地方被引用。像这样创建功能性方法是单例对象的一种常见用法。

下面让我们来看看如何在另外一个包中使用`info`方法：

import logging.Logger.info
    
    class Project(name: String, daysToComplete: Int)
    
    class Test { 
      val project1 = new Project("TPS Reports", 1)
      val project2 = new Project("Website redesign", 5)
      info("Created projects")  // Prints "INFO: Created projects"
    }

因为`import`语句`import logging.Logger.info`，方法`info`在此处是可见的。

`import`语句要求被导入的标识具有一个“稳定路径”，一个单例对象由于全局唯一，所以具有稳定路径。

注意：如果一个`object`没定义在顶层而是定义在另一个类或者单例对象中，那么这个单例对象和其他类普通成员一样是“路径相关的(path-dependent)”。这意味着有两种行为，`class Milk` 和 `class OrangeJuice`，一个类成员`object NutritionInfo`“依赖”于包装它的实例，要么是牛奶要么是橙汁。`milk.NutritionInfo`则完全不同于`oj.NutritionInfo`。

# 四,伴生对象和伴生类介绍 #

在同一个文件中当一个单例对象和某个类**同名**时，这个单例对象称为`伴生对象`。 同理，这个类被称为是这个单例对象的伴生类。类和它的伴生对象可以**互相访问其私有成员**。使用伴生对象来定义那些在伴生类中不依赖于实例化对象而存在的成员变量或者方法。

scala反编译之后其实就是把Object中的静态的内容全都揉进class中

import scala.math._
    
    case class Circle(radius: Double) { 
      import Circle._
      def area: Double = calculateArea(radius)
    }
    
    object Circle { 
      private def calculateArea(radius: Double): Double = Pi * pow(radius, 2.0)
    }
    
    val circle1 = Circle(5.0)
    
    circle1.area

这里的`class Circle`有一个成员`area`是和具体的实例化对象相关的，单例对象`object Circle`包含一个方法`calculateArea`，它在每一个实例化对象中都是可见的。

伴生对象也可以包含工厂方法：

class Email(val username: String, val domainName: String)
    
    object Email { 
      def fromString(emailString: String): Option[Email] = { 
        emailString.split('@') match { 
          case Array(a, b) => Some(new Email(a, b))
          case _ => None
        }
      }
    }
    
    val scalaCenterEmail = Email.fromString("scala.center@epfl.ch")
    scalaCenterEmail match { 
      case Some(email) => println(
        s"""Registered an email |Username: ${email.username} |Domain name: ${email.domainName} """)
      case None => println("Error: could not parse email")
    }

伴生对象`object Email`包含有一个工厂方法`fromString`用来根据一个`String`创建`Email`实例。在这里我们返回的是`Option[Email]`以防有语法分析错误。

> 注意：伴生类和它的伴生对象**必须定义在同一个源文件**里。如果需要在 REPL 里定义类和其伴生对象，需要将它们定义在同一行或者进入 :paste 模式。

# 五,伴生类和伴生对象反编译后结果 #

scala反编译之后其实就是把**Object中的静态的内容全都揉进class**中。这个class就是这个Object的伴生类，这个Object就是这个class的伴生对象。这样就可以互相调用他们之间的私有的属性和私有的方法。

scala代码

package com.cw
    
    /** * @author 陈小哥cw * @date 2021/3/30 13:52 */
    class Person(name: String, var age: Int, val sex: String) { 
    
      var phone: Long = _
    
      // 类体 & 构造方法体
      println(Person.objAge)
      println(Person.objName)
      println(Person.getName())
    
      def this(name: String, age: Int, sex: String, phone: Long) { 
        this(name, age, sex)
        this.phone = phone
      }
    
    
    }
    
    object Person { 
    
      var objName: String = "Obj"
      var objAge = 20
    
      def main(args: Array[String]): Unit = { 
        var person = new Person("Mike", 18, "男")
        // 未用任何修饰符修饰，这个参数就是一个局部变量
        // println(person.name)// 无法访问
    
        // var 修饰参数，作为类的成员属性使用，可以修改
        println(person.age)
        person.age = 20
        println(person.age)
    
        // val 修饰参数，作为类的只读属性使用，不能修改
        // person.sex = "女" //无法修改
        println(person.sex)
    
    
      }
    
      def getName(): String = { 
        objName
      }
    }

反编译为java代码后

//decompiled from Person$.class
    package com.cw;
    
    import scala.Predef.;
    import scala.runtime.BoxesRunTime;
    
    public final class Person$ { 
       public static Person$ MODULE$;
       private String objName;
       private int objAge;
    
       static { 
          new Person$();
       }
    
       public String objName() { 
          return this.objName;
       }
    
       public void objName_$eq(final String x$1) { 
          this.objName = x$1;
       }
    
       public int objAge() { 
          return this.objAge;
       }
    
       public void objAge_$eq(final int x$1) { 
          this.objAge = x$1;
       }
    
       public void main(final String[] args) { 
          Person person = new Person("Mike", 18, "男");
          .MODULE$.println(BoxesRunTime.boxToInteger(person.age()));
          person.age_$eq(20);
          .MODULE$.println(BoxesRunTime.boxToInteger(person.age()));
          .MODULE$.println(person.sex());
       }
    
       public String getName() { 
          return this.objName();
       }
    
       private Person$() { 
          MODULE$ = this;
          this.objName = "Obj";
          this.objAge = 20;
       }
    }
    
            //decompiled from Person.class
    package com.cw;
    
    import scala.Predef.;
    import scala.reflect.ScalaSignature;
    import scala.runtime.BoxesRunTime;
    
    @ScalaSignature(
       bytes = "\u0006\u000114Aa\u0006\r\u0001;!AA\u0005\u0001B\u0001B\u0003%Q\u0005\u0003\u00051\u0001\t\u0005\r\u0011\"\u00012\u0011!)\u0004A!a\u0001\n\u00031\u0004\u0002\u0003\u001f\u0001\u0005\u0003\u0005\u000b\u0015\u0002\u001a\t\u0011u\u0002!Q1A\u0005\u0002yB\u0001b\u0010\u0001\u0003\u0002\u0003\u0006I!\n\u0005\u0006\u0001\u0002!\t!\u0011\u0005\n\u000f\u0002\u0001\r\u00111A\u0005\u0002!C\u0011\u0002\u0014\u0001A\u0002\u0003\u0007I\u0011A'\t\u0013=\u0003\u0001\u0019!A!B\u0013I\u0005\"\u0002!\u0001\t\u0003\u0001v!B+\u0019\u0011\u00031f!B\f\u0019\u0011\u00039\u0006\"\u0002!\u000e\t\u0003A\u0006bB-\u000e\u0001\u0004%\tA\u0010\u0005\b56\u0001\r\u0011\"\u0001\\\u0011\u0019iV\u0002)Q\u0005K!9a,\u0004a\u0001\n\u0003\t\u0004bB0\u000e\u0001\u0004%\t\u0001\u0019\u0005\u0007E6\u0001\u000b\u0015\u0002\u001a\t\u000b\rlA\u0011\u00013\t\u000b)lA\u0011A6\u0003\rA+'o]8o\u0015\tI\"$\u0001\u0002do*\t1$A\u0002d_6\u001c\u0001a\u0005\u0002\u0001=A\u0011qDI\u0007\u0002A)\t\u0011%A\u0003tG\u0006d\u0017-\u0003\u0002$A\t1\u0011I\\=SK\u001a\fAA\\1nKB\u0011a%\f\b\u0003O-\u0002\"\u0001\u000b\u0011\u000e\u0003%R!A\u000b\u000f\u0002\rq\u0012xn\u001c;?\u0013\ta\u0003%\u0001\u0004Qe\u0016$WMZ\u0005\u0003]=\u0012aa\u0015;sS:<'B\u0001\u0017!\u0003\r\tw-Z\u000b\u0002eA\u0011qdM\u0005\u0003i\u0001\u00121!\u00138u\u0003\u001d\tw-Z0%KF$\"a\u000e\u001e\u0011\u0005}A\u0014BA\u001d!\u0005\u0011)f.\u001b;\t\u000fm\u001a\u0011\u0011!a\u0001e\u0005\u0019\u0001\u0010J\u0019\u0002\t\u0005<W\rI\u0001\u0004g\u0016DX#A\u0013\u0002\tM,\u0007\u0010I\u0001\u0007y%t\u0017\u000e\u001e \u0015\t\t#UI\u0012\t\u0003\u0007\u0002i\u0011\u0001\u0007\u0005\u0006I\u001d\u0001\r!\n\u0005\u0006a\u001d\u0001\rA\r\u0005\u0006{\u001d\u0001\r!J\u0001\u0006a\"|g.Z\u000b\u0002\u0013B\u0011qDS\u0005\u0003\u0017\u0002\u0012A\u0001T8oO\u0006I\u0001\u000f[8oK~#S-\u001d\u000b\u0003o9CqaO\u0005\u0002\u0002\u0003\u0007\u0011*\u0001\u0004qQ>tW\r\t\u000b\u0006\u0005F\u00136\u000b\u0016\u0005\u0006I-\u0001\r!\n\u0005\u0006a-\u0001\rA\r\u0005\u0006{-\u0001\r!\n\u0005\u0006\u000f.\u0001\r!S\u0001\u0007!\u0016\u00148o\u001c8\u0011\u0005\rk1CA\u0007\u001f)\u00051\u0016aB8cU:\u000bW.Z\u0001\f_\nTg*Y7f?\u0012*\u0017\u000f\u0006\u000289\"91\bEA\u0001\u0002\u0004)\u0013\u0001C8cU:\u000bW.\u001a\u0011\u0002\r=\u0014'.Q4f\u0003)y'M[!hK~#S-\u001d\u000b\u0003o\u0005DqaO\n\u0002\u0002\u0003\u0007!'A\u0004pE*\fu-\u001a\u0011\u0002\t5\f\u0017N\u001c\u000b\u0003o\u0015DQAZ\u000bA\u0002\u001d\fA!\u0019:hgB\u0019q\u0004[\u0013\n\u0005%\u0004#!B!se\u0006L\u0018aB4fi:\u000bW.\u001a\u000b\u0002K\u0001"
    )
    public class Person { 
       private int age;
       private final String sex;
       private long phone;
    
       public static String getName() { 
          return Person$.MODULE$.getName();
       }
    
       public static void main(final String[] args) { 
          Person$.MODULE$.main(var0);
       }
    
       public static void objAge_$eq(final int x$1) { 
          Person$.MODULE$.objAge_$eq(var0);
       }
    
       public static int objAge() { 
          return Person$.MODULE$.objAge();
       }
    
       public static void objName_$eq(final String x$1) { 
          Person$.MODULE$.objName_$eq(var0);
       }
    
       public static String objName() { 
          return Person$.MODULE$.objName();
       }
    
       public int age() { 
          return this.age;
       }
    
       public void age_$eq(final int x$1) { 
          this.age = x$1;
       }
    
       public String sex() { 
          return this.sex;
       }
    
       public long phone() { 
          return this.phone;
       }
    
       public void phone_$eq(final long x$1) { 
          this.phone = x$1;
       }
    
       public Person(final String name, final int age, final String sex) { 
          this.age = age;
          this.sex = sex;
          super();
          .MODULE$.println(BoxesRunTime.boxToInteger(Person$.MODULE$.objAge()));
          .MODULE$.println(Person$.MODULE$.objName());
          .MODULE$.println(Person$.MODULE$.getName());
       }
    
       public Person(final String name, final int age, final String sex, final long phone) { 
          this(name, age, sex);
          this.phone_$eq(phone);
       }
    }

单例模式饿汉式:在类初始化时初始化一个对象,并让`MODULE$`引用

`MODULE$`即静态对象,所谓的静态方法与静态变量只不过是`MODULE$`的成员方法与属性

从底层原理看，伴生对象实现静态特性是依赖于`public static final MODULE$`实现的。

可以看到

1.  val 和 private val 修饰的成员变量被编译成 private final, 并提供getter
2.  var 和 private var 修饰的成员变量被编译成 private, 并提供getter和setter
3.  没有修饰词修饰的和private\[this\]不会被编译成成员变量，但构造函数会带上

# 六,总结 #

1.  在 Java 中`static`成员对应于`Scala`中的伴生对象的普通成员。
2.  在`Java`代码中调用伴生对象时，伴生对象的成员会被定义成伴生类中的`static`成员。这称为`静态转发`。这种行为发生在当你自己没有定义一个伴生类时。
3.  scala 中的object是`单例对象`，相当于java中的工具类，可以看成是定义静态的方法的类。
4.  object不可以传参,当看到代码中出现为对象传参的情况,就说明代码中肯定会有一个`apply`方法。
5.  当创建一个object时，如果传入参数，那么会自动寻找object中的相应参数个数的`apply`方法。
6.  class可以传参，object不可以传参。 对象(object)要传参,使用apply方法。
7.  scala中的class类默认可以传参数，传参一定要指定类型, 有了参数就有了默认的构造
8.  class重写构造函数的时候，必须要调用默认的构造函数。
9.  类中重写构造时,构造中**第一行必须先调用默认的构造**def this()\{\}
10. class 类属性自带getter ，setter方法。但是要set的话，属性必须是变量。Var声明。
11. Scala中当new class时,类中除了方法不执行\[这里的方法不包括构造方法\],其它都执行
12. 使用object时，不用new,使用class时要new ,并且new的时候，class中除了方法(不包括构造方法)不执行，其他都执行。这些执行的内容就相当于是java 中的构造方法。
13. 如果在同一个文件中，object对象和class类的名称相同，则这个对象就是这个类的伴生对象，这个类就是这个对象的伴生类。可以互相访问私有变量。
14. 伴生类和伴生对象：因为scala中剥离了静态和非静态的属性和方法，需要解决私有属性和方法的调用问题
15. Scala中，将非静态的全部定义在class中，静态的全部定义在Object中。
16. scala反编译之后其实就是把**Object中的静态的内容全都揉进class**中。这个class就是这个Object的伴生类，这个Object就是这个class的伴生对象。这样就可以互相调用他们之间的私有的属性和私有的方法。
17. class和Object中的属性默认是`public`的,可以使用`private`来修饰私有
18. 伴生类和它的伴生对象必须定义在同一个源文件里

package com.cw.scala
    
    /** * Scala: * 1.Scala object相当于java中的单例,object中定义的全是静态的.相当于java中的工具类 * 2.Scala中定义变量使用var,定义常量使用val,变量可变,常量不可变 * 3.Scala中每行后面都会有分号自动推断机制,不用显式写出";" * 4.Scala 变量和常量的类型可以省略不写,会自动推断 * 5.建议在Scala中命名使用驼峰命名法 * 6.Scala类中可以传参,传参一定要指定类型,有了参数就有了默认的构造 * 7.类中的属性默认有getter和setter方法,但是要set的话，属性必须是变量。Var声明。 * 8.类中重写构造时,构造中第一行必须先调用默认的构造,def this(){} * 9,Scala中当new class时,类中除了方法不执行[这里的方法不包括构造方法],其它都执行 * 10.在同一个scala文件中,class名称和Object名称一样时,这个类叫做这个对象的伴生类,这个对象叫做这个类的伴生对象,他们之间可以互相访问私有变量 * 11.class和Object中的属性默认是public的,可以使用private来修饰私有 * 12.Object不可以传参 class可以传参 对象(object)要传参,使用apply方法. */
    
    //在xname前不使用val和var修饰,相当于xname是私有的
    // 使用val和var修饰后可以被其它类调用p.xname 如 class Person(var xname: String, xage: Int)
    class Person(xname: String, xage: Int) { 
      //class中定义的属性都是非静态的
      val name = xname
      var age = xage
      var gender = 'M'
    
      // println("****** Person Class ***********")
    
      //重写构造: 构造方法{}前不能加=,因为它没有返回值
      def this(yname: String, yage: Int, ygender: Char) { 
        this(yname, yage)
        this.gender = ygender
      }
    
      def sayName() = { 
        println("hello world..." + ClassAndObj.name)
        //object中的属性和方法都是静态的
        ClassAndObj.show()
      }
    
      // println("======== Person Class ======")
    }
    
    object ClassAndObj { 
      // println("######## ClassAndObj Object #######")
      //object中定义的属性都是静态的
      val name = "wangwu"
    
      //当给对象传入参数时,默认会调用apply方法
      def apply(i: Int) = { 
        println("Score is " + i)
      }
      //apply可以重写
      def apply(i: Int, s: String) = { 
        println("name is " + s + ",Score is " + i)
      }
    
      def main(args: Array[String]): Unit = { 
        //对象不可以传参,当看到代码中出现为对象传参的情况,就说明代码中肯定会有一个apply方法
        ClassAndObj(30)
        ClassAndObj(30,"zhangsan")
        // val p = new Person("zhangsan", 20);
        // print(p.name)
        // println(p.gender)
        // //有了参数就有了默认的构造
        // val p1 = new Person("diaochan", 18, 'F')
        // println(p1.gender)
    
    
        // p.age = 200 //使用默认setter方法来修改
        // println(p.name)
        // println(p.age)
        // p.sayName()
        // val a: Int = 100
        // var b = 200
        // b = 300
        // println(b)
      }
    
      def show() = { 
        println("hello")
      }
    }