When defining a field, the Scala compiler creates up to four accessors
for it: a getter, a setter, and if the field is annotated with
@BeanProperty, a bean getter and a bean setter.

When defining a field, the Scala compiler creates up to four accessors
for it: a getter, a setter, and if the field is annotated with
@BeanProperty, a bean getter and a bean setter.

For instance in the following class definition

class C(@myAnnot @BeanPropertyvar c: Int)

there are six entities which can carry the annotation @myAnnot: the
constructor parameter, the generated field and the four accessors.

By default, annotations on (val-, var- or plain) constructor parameters
end up on the parameter, not on any other entity. Annotations on fields
by default only end up on the field.

The meta-annotations in package scala.annotation.meta are used
to control where annotations on fields and class parameters are copied.
This is done by annotating either the annotation type or the annotation
class with one or several of the meta-annotations in this package.

Annotating the annotation type

The target meta-annotations can be put on the annotation type when
instantiating the annotation. In the following example, the annotation
@Id will be added only to the bean getter getX.

A marker for annotations that, when applied to a type, should be treated
as a constraint on the annotated type.

A proper constraint should restrict the type based only on information
mentioned within the type. A Scala compiler can use this assumption to
rewrite the contents of the constraint as necessary. To contrast, a type
annotation whose meaning depends on the context where it is written
down is not a proper constrained type, and this marker should not be
applied. A Scala compiler will drop such annotations in cases where it
would rewrite a type constraint.

Equivalent to x.hashCode except for boxed numeric types and null.
For numerics, it returns a hash value which is consistent
with value equality: if two value type instances compare
as true, then ## will produce the same hash value for each
of them.
For null returns a hashcode where null.hashCode throws a
NullPointerException.

Note that the success of a cast at runtime is modulo Scala's erasure semantics.
Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at
runtime, while the expression List(1).asInstanceOf[List[String]] will not.
In the latter example, because the type argument is erased as part of compilation it is
not possible to check whether the contents of the list are of the requested type.

Tests whether the argument (that) is a reference to the receiver object (this).

Tests whether the argument (that) is a reference to the receiver object (this).

The eq method implements an equivalence relation on
non-null instances of AnyRef, and has three additional properties:

It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of
x.eq(y) consistently returns true or consistently returns false.

For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.

null.eq(null) returns true.

When overriding the equals or hashCode methods, it is important to ensure that their behavior is
consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they
should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).

returns

true if the argument is a reference to the receiver object; false otherwise.

Note that the result of the test is modulo Scala's erasure semantics.
Therefore the expression 1.isInstanceOf[String] will return false, while the
expression List(1).isInstanceOf[List[String]] will return true.
In the latter example, because the type argument is erased as part of compilation it is
not possible to check whether the contents of the list are of the specified type.

returns

true if the receiver object is an instance of erasure of type T0; false otherwise.

Creates a String representation of this object. The default
representation is platform dependent. On the java platform it
is the concatenation of the class name, "@", and the object's
hashcode in hexadecimal.