polymorphism by using interface and inheritance

[abalfazl hossein]

public class Pet {
private String name;
private int age;
public Pet(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(name + “ is eating”);
}
}

public interface Mammal {
public void breathe();
}
//The following Cat class both extends Pet and implements the Mammal interface:
public class Cat extends Pet implements Mammal {
public Cat(String name, int age) {
super(name, age);
}
public void breathe() {

System.out.println(“Cat is breathing”);
}
public void sleep() {
System.out.println(“Cat is sleeping”);
}
}


Cat c = new Cat(“Garfield”, 3);
Pet p = c;
Mammal m = c;


c.sleep();
c.breathe();
c.eat();
p.eat();
m.breathe();

Polymorphism is forms of one type.Is this polymorphism because of this?

c.eat();
p.eat();

How can you see polymorphism in this code:

16. Pet pet = new Cat(“Alley”, 7);
17. pet.eat(); //no cast needed
18. ((Cat) pet).sleep(); //cast is needed
19. ((Mammal) pet).breathe(); //cast is needed
20. ((Cat) pet).breathe(); //Same as previous line of code

From SCJP study guide by Richard F. Raposa

[Ryan Beckett]

c.eat();
p.eat();

I see inheritance, not polymorphism.

public class Pet {
private String name;
private int age;
public Pet(String name, int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println(“This pet is eating”);
}
}

public class Cat extends Pet {
public Cat(String name, int age) {
super(name, age);
}
public void eat() {
System.out.println(“This cat is eating”);
}
}

public class Dog extends Pet{
public Dog(String name, int age) {
super(name, age);
}
public void eat() {
System.out.println(“This dog is eating”);
}
}

Pet p = new Cat("", 0);
p.eat(); //displays “This cat is eating”
p = new Dog("", 0);
p.eat(); //displays "This dog is eating"

That is polymorphism. eat() has many different forms since it's overridden by whoever extends Pet. When referencing each instance with its super type, the correct override is chosen based on the instance type at run time.

[marc weber]

See "How my dog learned polymorphism."

[abalfazl hossein]

Pet pet = new Cat(“Alley”, 7);  
 pet.eat(); //no cast needed  
 ((Cat) pet).sleep(); //cast is needed  

pet is an instance of a Cat,Because of new Cat,Then Why does it need to cast?

[Hauke Ingmar Schmidt]

abalfazl hossein wrote:

Pet pet = new Cat(“Alley”, 7);  
 pet.eat(); //no cast needed  
 ((Cat) pet).sleep(); //cast is needed  

pet is an instance of a Cat,Because of new Cat,Then Why does it need to cast?

At compile time all the compiler knows is it is a Pet. A Pet does not know how to sleep, the method is specific to Cats. (Please don't quote this without context ;-)).

[Matthew Brown]

abalfazl hossein wrote:pet is an instance of a Cat,Because of new Cat,Then Why does it need to cast?

It's the other way around, really: if pet wasn't an instance of Cat, you wouldn't be able to cast.

[abalfazl hossein]

if (pet instanceof pet)
            System.out.println("true");
        if (pet instanceof Cat)
            System.out.println("true");

These returns true, Then again: Why does it need to cast?

[abalfazl hossein]

Is it possible one object has two kinds?! Because in that code pet has two kinds! Again: Why does it need cast?

[Matthew Brown]

abalfazl hossein wrote:These returns true, Then again: Why does it need to cast?

Casting is relevant when you have a variable with one reference type, which is referring to an object which is actually an instance of a subclass. For example:

Animal animal = new Cat();

All the compiler knows about animal is that is referencing an Animal. So as long as we only need to use features of an Animal, this is fine.

animal.run();

But what if we want to use a feature specific to Cat? The compiler doesn't know that it's a Cat. So it can't allow us to do this:

animal.playWithBallOfString(); // compiler error

In this case, we need to tell the compiler "trust me - I know the reference type says Animal, but it's definitely containing a Cat". Normally the compiler protects us from accidentally treating a Dog like a Cat, so we need to override it. That's what casting does:

((Cat)animal).playWithBallOfString();

Then, if we're wrong, the run-time will throw a ClassCastException.

So, casting is needed when we need to tell the compiler at compile time that something will be true that it can't check until run time.

[Matthew Brown]

abalfazl hossein wrote:Is it possible one object has two kinds?! Because in that code pet has two kinds!

Yes, because that's what inheritance means. A Cat is an Animal. If something is a Cat, it must also be an Animal. But the other way around is not necessarily true, and that's why casting is sometimes necessary.

[Campbell Ritchie]

abalfazl hossein wrote:Is it possible one object has two kinds?! Because in that code pet has two kinds! Again: Why does it need cast?. . . .

By "two", I presume you mean three.

Matthew Brown wrote:A Cat is an Animal. If something is a Cat, it must also be an Animal.

That makes two.


But we are writing in Java™, so a Cat is an Animal and an Animal is an Object. That makes three


And some objects have more types; for example an instance of this class has 7 types.

[abalfazl hossein]

abalfazl hossein wrote:
view plaincopy to clipboardprint?
Pet pet = new Cat(“Alley”, 7);
pet.eat(); //no cast needed
((Cat) pet).sleep(); //cast is needed


pet is an instance of a Cat,Because of new Cat,Then Why does it need to cast?


At compile time all the compiler knows is it is a Pet. A Pet does not know how to sleep, the method is specific to Cats. (Please don't quote this without context ;-)).

َand in Runtime, Pet is a Cat?

[Campbell Ritchie]

There is type extension and there is functional extension and I can never remember which is which. But one means adding new methods/behaviour in subclasses, and the other means not adding new methods.
Whichever way it is you are adding new methods, it means that only certain subclasses have certain behaviour. For example, java.util.ArrayList has three methods which are not in the List interface: trimToSize, ensureCapacity and removeRange. If you need those, you would have to cast

/**
 * Populates the List with numbers from the random generator
 *@param numbers A List<Double> to populate
 *@param count How many numbers are required
 *@throws IllegalArgumentException if count < 0
 */
public static final void populateListWithRandoms(List<Double> numbers, int count)
{
   if (count < 0)
   {
       throw new IllegalArgumentException("Negative numbers not acceptable in this method: you passed " + count);
   }
   if (numbers instanceof java.util.ArrayList)
   {
        ((java.util.ArrayList) numbers).ensureCapacity(count);
   }
   for (int i = 0; i < count; i++)
   {
        double random = randomGenerator.nextDouble();
        numbers.add(random);
   }
}

So when you want 10000000 numbers, you get a List large enough to hold them. Those methods (trimToSize and ensureCapacity) are not in LinkedList, because they are not necessary there.

The instanceof operator tests whether you have an ArrayList or one of its subclasses, so the cast can go ahead safely. I think that is an awkward programming construct, however, and it should be used only rarely. And it will be awkward if you find another type of List which also has an ensureCapacity() method or a trimToSize() method.
Another awkward construct there is the use of an output parameter; the List is passed in order to have its state changed. If you didn't cast the Pet object to (Cat)tiddles or similar before invoking the sleep() method, the compiler would only know it is a Pet and would not know there is an accessible sleep() method, so it would never compile. And I am surprised only Cat has a sleep() method; have you never seen a dog asleep?

[abalfazl hossein]

public class a {
        
    public void eat() {
        System.out.println("a is eating");
    }
}

public class b extends a {
    
    
    public void eat() {
        System.out.println("b is eating");
    }
 }

public class Main {
       public static void main(String[] args) {
           a test=new b();
           test.eat();
           ((a)test).eat();
       }
}

b is eating
b is eating

Why are these same?

[Campbell Ritchie]

abalfazl hossein wrote:

public class a {
        
    public void eat() {
        System.out.println("a is eating");
    }
}

public class b extends a {
    
    
    public void eat() {
        System.out.println("b is eating");
    }
 }

public class Main {
       public static void main(String[] args) {
           a test=new b();
           test.eat();
           ((a)test).eat();
       }
}

b is eating
b is eating

Why are these same?

Polymorphism. It's still a "b".

[abalfazl hossein]

((a)test).eat();

When we use inheritance, Super class and Subclass has same type.Then cast must working here.It must print:

a is eating


Because Of type cast, Why it doesn't?

[Henry Wong]

abalfazl hossein wrote:

((a)test).eat();

It must print:

a is eating


Because Of type cast, Why it doesn't?

Because that's not how it works. It's a "b" object, the overridden method is always called.

Henry

[abalfazl hossein]

Welcome back Sir!
When we use inheritance, Super class and Subclass has same type

((a)test).eat();

By this order, test became a.

a.eat must print a is eating

[Henry Wong]

abalfazl hossein wrote:
By this order, test became a.

a.eat must print a is eating

Casting doesn't change the object. It only (may) changes how the compiler generates code to call it. It's a "b" object, the overridden method is always called.

Henry

[abalfazl hossein]

a test4= new a();
           b test5=(b)test4;

Exception in thread "main" java.lang.ClassCastException: inheritancetest.a cannot be cast to inheritancetest.b

Subclass and superclass has same type.But it is not possible to cast subclass to super class, Because an a object may be a "b" object, But not necessarily.Right?

[Campbell Ritchie]

abalfazl hossein wrote: . . . But it is not possible to cast subclass to super class, . . ..Right?

No.

It is always possible to cast from subclass to superclass; it is often not possible to cast from superclass to subclass.
And the casts vanish at runtime. Try this code

public abstract class Animal {}

public class Cat extends Animal {}

public class Dog extends Animal {}

public class AnimalDemo
{
    public static void main(String[] args)
    {
        Animal c = new Cat();
        System.out.println((Animal)c);
    }
}

Compile that code and print the bytecode with javap -c AnimalDemo and you will see no sign of the cast. So the Cat object is still a Cat object.

[abalfazl hossein]

public class Pet {  
private String name;  
private int age;  

public void eat() {  
System.out.println(“This pet is eating”);  
}  
}  
  
public class Cat extends Pet {  

public void eat() {  
System.out.println(“This cat is eating”);  
}  
}  
  
public class Dog extends Pet{  

public void eat() {  
System.out.println(“This dog is eating”);  
}  
}  
  
Pet p = new Cat();  
p.eat(); //displays “This cat is eating”  
((Dog)p).eat(); //displays "This dog is eating"  

It shows polymorphism too. Right?

If you compare this code to another:https://coderanch.com/forums/posts/list/531088#2408422
Which one is better?Cast or create new instance?

[Campbell Ritchie]

abalfazl hossein wrote:

 . . .
((Dog)p).eat(); //displays "This dog is eating" 

Does it really? I don't think it does. Have you tried it?

It shows polymorphism too. Right?

Yes, but . . .

If you compare this code to another:https://coderanch.com/forums/posts/list/531088#2408422
Which one is better?Cast or create new instancne?

What you have shown is very different from Ryan Beckett's code you quoted earlier. You should create as many objects as you need, and you should avoid casting as much as possible.

And please post code which compiles; your "smart" quotes won't compile. Use a text editor, not a word processor.