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

 

文章目录

• 一,介绍
• 二,类Class
• • 2.1 类定义
  • 2.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("[e-mail]")
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")
  }
}