scala伴生对象|对象创建|判断所属类|scala对象的相等性判断|覆写override

object Student{
  private val secrect1 = "i am secrect1 ******"
  def accessCompanionClass(s:Student) = {
    println(s"access Companion Class private field =${s.secrect2}")
  }
}

class Student {
  private val secrect2 = "i am secrect2 ******"

  def accessCompanionObject() = {
    println(s"access Companion Object private field = ${Student.secrect1}")
  }
}

object Run1{
  def main(args: Array[String]): Unit = {
    new Student().accessCompanionObject()
  }
}

Scala中的伴生类和伴生对象是一种特殊的关系，它们互为伴生。伴生类和伴生对象必须在同一个源文件中定义，且它们的名称必须相同。

伴生类是一个普通的类，可以定义属性和方法，它的实例可以被创建和使用。伴生对象是一个单例对象，它与伴生类共享同一个名称，但没有实例化的过程。伴生对象中的方法和属性可以被直接调用，就像Java中的静态方法和属性一样。

伴生类和伴生对象之间可以互相访问彼此的私有成员，这使得它们可以作为一个整体来使用，提供了更高效的程序运行方式。

下面是一个示例代码，演示了Scala中伴生类和伴生对象的用法：

```scala
// 伴生类
class Student(val name: String) {
  def sayHello(): Unit = {
    println(s"Hello, my name is $name")
  }
}

// 伴生对象
object Student {
  def createStudent(name: String): Student = {
    new Student(name)
  }
}

// 使用伴生对象创建伴生类的实例
val student = Student.createStudent("Alice")
student.sayHello() // 输出：Hello, my name is Alice
```

在上面的示例中，`Student`是伴生类，它有一个构造函数和一个`sayHello`方法。`Student`的伴生对象也叫做`Student`，它有一个`createStudent`方法用于创建`Student`类的实例。

通过调用伴生对象的方法`createStudent`，我们可以创建一个`Student`类的实例，并调用该实例的`sayHello`方法。

伴生对象是Scala中的一个特殊概念，它与类共享同一个名称，并且可以访问类的私有成员。伴生对象的作用有以下几个方面：

1. 提供类级别的静态成员：伴生对象中的成员可以像Java中的静态成员一样被访问，不需要创建类的实例。这样可以方便地在伴生对象中定义一些与类相关的全局变量或方法。

2. 实现工厂模式：伴生对象可以定义一个apply方法，用于创建类的实例。这样可以通过伴生对象的apply方法来创建类的对象，而不需要使用new关键字。

3. 提供类级别的访问权限控制：伴生对象可以访问类的私有成员，这样可以在伴生对象中定义一些只能在类内部访问的方法或变量。

4. 提供类级别的隐式转换：伴生对象可以定义隐式转换方法，用于将类的实例转换为其他类型。这样可以方便地扩展类的功能，使其可以与其他类型进行交互。

下面是一个示例代码，演示了伴生对象的作用：

```scala
class MyClass {
  private val privateVariable = "Private Variable"

  def printPrivateVariable(): Unit = {
    println(MyClass.staticMethod()) // 调用伴生对象中的静态方法
    println(MyClass.privateStaticVariable) // 访问伴生对象中的私有静态变量
    println(privateVariable) // 访问类的私有成员
  }
}

object MyClass {
  private val privateStaticVariable = "Private Static Variable"

  def staticMethod(): String = {
    "Static Method"
  }

  def apply(): MyClass = {
    new MyClass()
  }
}

val obj = MyClass() // 使用伴生对象的apply方法创建类的实例
obj.printPrivateVariable() // 调用类的方法
```
 

对象创建、

class Person {
  var name = "person"
  println("enter into person construction")}
 object Person {
  println("enter into person object construction")

   def apply(): Person = new Person()

   def apply(name:String): Person = {
     var p=new Person()
     p.name=name
     p
   }
 }
 object RunPerson{
   def main(args: Array[String]): Unit = {
     //1
     //2
     //3
     val p1= Person("apply person")
     println(s"create object by apply p1=$p1")
     println(s"create object by apply p1=${p1.name}")
     val p2= Person("apply person")
     println(s"create object by apply p2=$p2")
     println(s"create object by apply p1=${p2.name}")
   }

}

判断所属类

object RunJudgeObject {
  def main(args: Array[String]): Unit = {
    val p1=new Person2()
    val p2=new Person2()
    val s= new Student2()
    val t=new Teacher2()

    //1
    println(s"p1==p2 ? ${p1.getClass==p2.getClass} ")
    println(s"p1==p1 ? ${p1.getClass==p1.getClass} ")
    println(s"p1==s ? ${p1.getClass==s.getClass} ")
    println(s"s==t ? ${p1.getClass==t.getClass} ")
    println(s"p1=${getClass},p2=${p2.getClass},s=${s.getClass},t=${t.getClass}")
    //
    println(s"p1 isInstanceOF person2 ? ${p1.isInstanceOf[Person2]}")
    println(s"p2 isInstanceOF person2 ? ${p2.isInstanceOf[Person2]}")
    println(s"s isInstanceOF person2 ? ${s.isInstanceOf[Person2]}")
    println(s"t isInstanceOF person2 ? ${s.isInstanceOf[Person2]}")
    println(s"s isInstanceOF person2 ? ${s.isInstanceOf[Student2]}")
  }

}
class Person2{
  var name="person1"
}
class Student2 extends Person2{

}
class Teacher2() extends Person2{

}

scala对象的相等性判断

import java.net.Socket

object RunEqual {
  def main(args: Array[String]): Unit = {
    val s1=new String("scala")
    val s2=new String("scala")
    val s3=new String("java")
    println(s"s1==s2? ${s1 equals s2}")
    println(s"s1==s3? ${s1 equals s3}")
    println(s"s1 equals s2? ${s1 eq s2}")
    println(s"s1 eq s3? ${s1 eq s3}")
  }
  val l1=List(1,2)
  val l2=List(1,2)
  println(s"l1==l2 ? ${l1==l2}")
  println(s"l1  equals l2 ? ${l1 equals l2}")
  println(s"s1 eq s2 ? ${l1 eq l2}")
  //
    val sk1=new Socket("127.0.0.1",22)
    val sk2=new Socket("127.0.0.1",22)
    val sk3=new Socket("127.0.0.1",23)
    val sk4=new Socket("127.0.2.1",28)
  println(s"sk1 == sk2 ? ${sk1==sk2}")
  println(s"sk1 == sk3 ? ${sk1==sk3}")
  println(s"sk1 == sk4 ? ${sk1==sk4}")
  println(s"sk1 equals sk2 ?${sk1 equals sk2}")
  println(s"sk1 equals sk3 ?${sk1 equals sk3}")
  println(s"sk1 eq sk2 ? ${sk1 eq sk2}")
    println(s"sk1 eq sk3 ? ${sk1 eq sk3}")
}
class Socket(ip:String,port:Int){
  override def equals(obj: Any): Boolean = {true}
}

覆写override