Java Objects and the instanceof Operator

When does the instanceof operator return true?

Answer:
The `instanceof` operator in Java is used to check whether an object is an instance of a specific class or implements an interface. It returns `true` if the object is an instance of the specified class or interface, and `false` otherwise. This operator is particularly useful for safe typecasting and ensuring that an object can be safely cast to a particular type before performing operations on it.
Syntax:
```
object instanceof ClassName
```
Example:
```
class Animal { }

class Dog extends Animal { }

public class Main {
   public static void main(String[] args) {
       Animal animal = new Dog();

       // Checking if 'animal' is an instance of Dog
       if (animal instanceof Dog) {
           System.out.println("animal is an instance of Dog");
       } else {
           System.out.println("animal is NOT an instance of Dog");
       }

       // Checking if 'animal' is an instance of Animal
       if (animal instanceof Animal) {
           System.out.println("animal is an instance of Animal");
       } else {
           System.out.println("animal is NOT an instance of Animal");
       }
   }
}
```
Output:
```
animal is an instance of Dog
animal is an instance of Animal
```
Explanation:
- In the example above, the `instanceof` operator checks if the `animal` object is an instance of the `Dog` class and the `Animal` class.
- Since `Dog` is a subclass of `Animal`, the `animal` object is both an instance of `Dog` and `Animal`. Therefore, both checks return `true`.
The `instanceof` operator is often used in scenarios where objects might belong to different subclasses, and you want to perform operations specific to a subclass safely.
The instanceof operator returns true if the reference variable being tested is of the type being compared to.

What is true of every class in Java?

Answer:
In Java, every class is implicitly a subclass of the `Object` class, even if you don't explicitly extend it. This is because `Object` is the root of the class hierarchy. If a class doesn't explicitly extend another class, it automatically extends `Object`.
Key Points:
1. Root of All Classes:
  - The `Object` class is the top-most class in the Java class hierarchy. Every class in Java directly or indirectly inherits from `Object`.
  - For example, if you create a class `MyClass` without specifying a superclass, it is automatically considered a subclass of `Object`:
```
class MyClass {
 // Implicitly extends Object
}
```
2. Methods Inherited from `Object`:
  - Since all classes extend `Object`, they inherit its methods. Some of the commonly used methods from `Object` include:
  1. `toString()`: Returns a string representation of the object.
  2. `equals(Object obj)`: Compares this object to another for equality.
  3. `hashCode()`: Returns a hash code value for the object.
  4. `getClass()`: Returns the runtime class of the object.
  5. `clone()`: Creates and returns a copy of this object.
  6. `finalize()`: Called by the garbage collector before the object is destroyed.
3. Polymorphism and `Object`:
  - Since every class is a subclass of `Object`, you can assign any object to a reference variable of type `Object`. This allows for a high degree of polymorphism. For example:
```
Object obj = new MyClass();
```
  - However, to access subclass-specific methods, you must cast the object back to its original type.
4. Example:
```
class MyClass {
  private String name;

  public MyClass(String name) {
   this.name = name;
  }

  // Overriding toString() from Object
  @Override
  public String toString() {
   return "MyClass: " + name;
  }
}

public class Main {
  public static void main(String[] args) {
   MyClass myObject = new MyClass("Example");

   // Using Object methods
   System.out.println(myObject.toString()); // Outputs: MyClass: Example
   System.out.println(myObject.hashCode()); // Outputs: Hash code of the object
   System.out.println(myObject.getClass()); // Outputs: class MyClass
  }
}
```
Importance of `Object`:
- Standardization: The `Object` class provides a set of default behaviors that every Java object can rely on, making it easier to work with collections and frameworks that expect objects of any type.
- Polymorphism: By treating all objects as instances of `Object`, you can write more generic and flexible code.
In essence, the `Object` class serves as the foundation for all classes in Java, providing essential methods and enabling the powerful features of polymorphism and type hierarchy.

What is true about every class that you create?

Answer:
Whenever you create a class, you automatically inherit all of the methods in the class Object.
What are the two most common reasons to use inheritance?

Answer:
The 2 most common reasons to use inheritance are
1. To promote code resuse
2. To use polymorphism.

The IS-A relationships is based on which two object oriented concepts?

Answer:
The concept of IS-A is based on
1. class inheritance or
2. interface implementation
Give two examples of a "IS-A Relationship"?

Answer:
A mustang "is a" type of horse.
A grizzly "is a" type of bear.
How does the "IS-A" relationship relate to the extends keyword?

Answer:
Car extends Vehicle means Car "IS-A" vehicle.

Write a class Mammal that inherits from Animal.

public class Animal{}

Answer:

public class Mammal extends Animal{
	private Lungs mammalLungs;
}

What test must a Java object pass in order to be considered polymorphic?

Answer:
In Java, for an object to be considered polymorphic, it must meet the following criteria:
1. Multiple Forms (Is-a Relationship):
  - The object must be able to take on multiple forms, meaning it should be able to be referenced by its own type as well as by a parent type (superclass or interface). This "is-a" relationship is fundamental to polymorphism.
  - For example, if `Dog` is a subclass of `Animal`, then a `Dog` object can be referred to as both a `Dog` and an `Animal`.
2. Inheritance or Interface Implementation:
  - The object must be derived from a superclass or implement an interface. This means the object can be referred to by a variable of the superclass or the implemented interface type.
  - For example:
```
class Animal { }
class Dog extends Animal { }

Animal myDog = new Dog();  // Polymorphism: myDog is of type Animal, but refers to a Dog
```
3. Ability to Override Methods:
  - The subclass should override one or more methods from the superclass or interface, providing specific behavior. This allows the method to behave differently depending on the actual object type, even when accessed via a reference to the superclass or interface.
  - For example:
```
class Animal {
 void sound() {
	 System.out.println("Some generic animal sound");
 }
}

class Dog extends Animal {
 @Override
 void sound() {
	 System.out.println("Bark");
 }
}

public class Main {
 public static void main(String[] args) {
	 Animal myAnimal = new Dog();
	 myAnimal.sound();  // Outputs: Bark 
 }
}
 
```
4. Dynamic Method Dispatch (Runtime Polymorphism):
  - Java supports method overriding, where the method call is resolved at runtime rather than compile-time. This is known as dynamic method dispatch. The decision of which method to invoke is based on the actual object type, not the reference type.
  - In the example above, `myAnimal.sound()` calls the `sound()` method of `Dog`, not `Animal`, because the actual object type at runtime is `Dog`.
Summary: A "Java object" is considered polymorphic if it can be accessed through a reference of its superclass or interface type and can override methods to provide specific behavior. This is the essence of polymorphism: the ability to define a single interface or superclass and have multiple implementations that are selected at runtime based on the actual object type.
Any Java object that can pass more than one IS-A test can be considered polymorphic.