কেস ক্লাস কী তা সম্পর্কে চূড়ান্ত বোঝার জন্য:
আসুন নিম্নলিখিত কেস শ্রেণীর সংজ্ঞাটি ধরে নেওয়া যাক:
case class Foo(foo:String, bar: Int)
এবং তারপরে টার্মিনালে নিম্নলিখিতটি করুন:
$ scalac -print src/main/scala/Foo.scala
স্কেল 2.12.8 আউটপুট দেবে:
...
case class Foo extends Object with Product with Serializable {
<caseaccessor> <paramaccessor> private[this] val foo: String = _;
<stable> <caseaccessor> <accessor> <paramaccessor> def foo(): String = Foo.this.foo;
<caseaccessor> <paramaccessor> private[this] val bar: Int = _;
<stable> <caseaccessor> <accessor> <paramaccessor> def bar(): Int = Foo.this.bar;
<synthetic> def copy(foo: String, bar: Int): Foo = new Foo(foo, bar);
<synthetic> def copy$default$1(): String = Foo.this.foo();
<synthetic> def copy$default$2(): Int = Foo.this.bar();
override <synthetic> def productPrefix(): String = "Foo";
<synthetic> def productArity(): Int = 2;
<synthetic> def productElement(x$1: Int): Object = {
case <synthetic> val x1: Int = x$1;
(x1: Int) match {
case 0 => Foo.this.foo()
case 1 => scala.Int.box(Foo.this.bar())
case _ => throw new IndexOutOfBoundsException(scala.Int.box(x$1).toString())
}
};
override <synthetic> def productIterator(): Iterator = scala.runtime.ScalaRunTime.typedProductIterator(Foo.this);
<synthetic> def canEqual(x$1: Object): Boolean = x$1.$isInstanceOf[Foo]();
override <synthetic> def hashCode(): Int = {
<synthetic> var acc: Int = -889275714;
acc = scala.runtime.Statics.mix(acc, scala.runtime.Statics.anyHash(Foo.this.foo()));
acc = scala.runtime.Statics.mix(acc, Foo.this.bar());
scala.runtime.Statics.finalizeHash(acc, 2)
};
override <synthetic> def toString(): String = scala.runtime.ScalaRunTime._toString(Foo.this);
override <synthetic> def equals(x$1: Object): Boolean = Foo.this.eq(x$1).||({
case <synthetic> val x1: Object = x$1;
case5(){
if (x1.$isInstanceOf[Foo]())
matchEnd4(true)
else
case6()
};
case6(){
matchEnd4(false)
};
matchEnd4(x: Boolean){
x
}
}.&&({
<synthetic> val Foo$1: Foo = x$1.$asInstanceOf[Foo]();
Foo.this.foo().==(Foo$1.foo()).&&(Foo.this.bar().==(Foo$1.bar())).&&(Foo$1.canEqual(Foo.this))
}));
def <init>(foo: String, bar: Int): Foo = {
Foo.this.foo = foo;
Foo.this.bar = bar;
Foo.super.<init>();
Foo.super./*Product*/$init$();
()
}
};
<synthetic> object Foo extends scala.runtime.AbstractFunction2 with Serializable {
final override <synthetic> def toString(): String = "Foo";
case <synthetic> def apply(foo: String, bar: Int): Foo = new Foo(foo, bar);
case <synthetic> def unapply(x$0: Foo): Option =
if (x$0.==(null))
scala.None
else
new Some(new Tuple2(x$0.foo(), scala.Int.box(x$0.bar())));
<synthetic> private def readResolve(): Object = Foo;
case <synthetic> <bridge> <artifact> def apply(v1: Object, v2: Object): Object = Foo.this.apply(v1.$asInstanceOf[String](), scala.Int.unbox(v2));
def <init>(): Foo.type = {
Foo.super.<init>();
()
}
}
...
যেমনটি আমরা দেখতে পাচ্ছি স্কালা সংকলক একটি নিয়মিত শ্রেণি Fooএবং সহচর-বস্তু উত্পাদন করে Foo।
আসুন সংকলিত ক্লাসের মধ্যে যাব এবং আমরা কী পেয়েছি সে সম্পর্কে মন্তব্য করুন:
Fooশ্রেণীর অভ্যন্তরীণ অবস্থা , স্থাবর:
val foo: String
val bar: Int
def foo(): String
def bar(): Int
def copy(foo: String, bar: Int): Foo
def copy$default$1(): String
def copy$default$2(): Int
scala.Productবৈশিষ্ট্য প্রয়োগ :
override def productPrefix(): String
def productArity(): Int
def productElement(x$1: Int): Object
override def productIterator(): Iterator
scala.Equalsসাম্যর জন্য কেস ক্লাসের উদাহরণগুলির তুলনাযোগ্য করে তুলতে বৈশিষ্ট্য প্রয়োগ করে ==:
def canEqual(x$1: Object): Boolean
override def equals(x$1: Object): Boolean
java.lang.Object.hashCodeসমান-হ্যাশকোড চুক্তি মানার জন্য ওভাররাইডিং :
override <synthetic> def hashCode(): Int
- ওভাররাইডিং
java.lang.Object.toString:
override def toString(): String
newকীওয়ার্ড দ্বারা ইনস্ট্যান্টেশন জন্য কনস্ট্রাক্টর :
def <init>(foo: String, bar: Int): Foo
অবজেক্ট ফু: - কীওয়ার্ড applyছাড়াই ইনস্ট্যান্টেশন করার পদ্ধতি new:
case <synthetic> def apply(foo: String, bar: Int): Foo = new Foo(foo, bar);
unupplyপ্যাটার্ন ম্যাচিংয়ে কেস ক্লাস ফু ব্যবহার করার জন্য এক্সট্রাক্টর পদ্ধতি :
case <synthetic> def unapply(x$0: Foo): Option
- আরও একটি উদাহরণ তৈরি করতে না দেওয়ার জন্য ডিসিজারাইজেশন থেকে অবজেক্টটিকে সিঙ্গলটন হিসাবে রক্ষা করার পদ্ধতি:
<synthetic> private def readResolve(): Object = Foo;
- অবজেক্ট ফু এ
scala.runtime.AbstractFunction2জাতীয় কৌশল করার জন্য প্রসারিত :
scala> case class Foo(foo:String, bar: Int)
defined class Foo
scala> Foo.tupled
res1: ((String, Int)) => Foo = scala.Function2$$Lambda$224/1935637221@9ab310b
tupled বস্তু থেকে 2 টি উপাদানের একটি টিপল প্রয়োগ করে একটি নতুন ফু তৈরি করার জন্য একটি মজাদার ফিরিয়ে দেয়।
সুতরাং কেস ক্লাসটি কেবল সিনট্যাকটিক চিনি।