Declaring a Java object where class name differs from constructor name [duplicate]

It can be possible if Dog is a subclass of Puppy or if Puppy is an Interface and Dog is an implementation for it. This is a classic example of polymorphism in Java.

We're talking about two different things here:

1) Create a file that contains a class definition:

MyClass.java

public class MyClass { private int someValue; public MyClass(int someValue) { this.someValue = someValue; } } 

2) Create a class that is extending some other class or implements an interface:

MyInterface.java

public interface MyInterface { void doSomeAction(); } 

MyClass.java

public class MyClass implements MyInterface { private int someValue; public MyClass(int someValue) { this.someValue = someValue; } public void doSomeAction() { // some logic here } } 

In this case you can use your code like you mentioned:

MyInterface someObjectThatImplementsMyInterface = new MyClass(42); 

So, one thing is creating a class definition, and other thing is initializing an object that either extends some class or implements some interface. Two different things to consider. :)

the constructor part of the syntax differs from the class name

It's never the case. Constructors have a strict declaration and their names are always the name of the class they are defined in.

What you've seen is the initialisation of a completely different class called Dog, which inherits from Puppy.

For you, Puppy is a cute Dog. For me, Puppy is a little Rat. For someone else, Puppy could be a young Seal. But they all are puppies, and they all share some common characteristics. Given that, you can work with a Puppy regardless of its actual type.

It's a stupid idea to have Puppy as a subclass of Dog, though. The same goes for MiddleAgedDog, or OldDog. You could simply ask dog.getAge() and if it returns 20 we can agree that this buddy is old.

It's due to a concept called 'inheritance' in object oriented programming. In your example, you are not creating a Puppy object but a Dog object. Puppy is just an interface or a class of which Dog is inherited.

this is because they use inheritance in their Example

you got

public class Puppy{...} 

and

public class Dog extends Puppy { public Dog(String string) {...} } 

you can now implement the interface of Dog in Puppy:

public class Dog extends Puppy{...} 

and then call

Puppy myPuppy = new Dog( "tommy" ); 

your Puppy is a Dog and inherits the methods of the parent

What type of class is myPuppy?

The type of the variable myPuppy is Puppy but (assuming this code compiles) the object/instance that myPuppy is referencing is of the type (or class) Dog.

What is it doing?

This is called inheritance, i.e. if Dog extends Puppy then each dog is a puppy. Thus any field or variable of type Puppy can refer to (or "hold") an instance of anything that extends or implements Puppy. All that's known is that myPuppy is a puppy but not what kind of puppy (let's say there'd be a Wolf extends Puppy as well - myPuppy could then refer to a dog or a wolf).

This is called Dynamic Binding in Java

Dynamic Binding: In Dynamic binding compiler doesn’t decide the method to be called. Overriding is a perfect example of dynamic binding. In overriding both parent and child classes have same method .

It simply means when you can have child class object in parent class reference like:

Dog myDog = new Puppy( "tommy" ); 

To do this your Puppy class should be child class of Dog

JLS 4.10.2. Subtyping among Class and Interface Types

Given a non-generic type declaration C, the direct supertypes of the type C are all of the following:

The direct superclass of C (§8.1.4).

The direct superinterfaces of C (§8.1.5).

And 4.12.2. Variables of Reference Type

A variable of a class type T can hold a null reference or a reference to an instance of class T or of any class that is a subclass of T.

So let say if you have bark method in you Dog class and you have override that in your puppy class too then:

During compilation, the compiler has no idea as to which bark has to be called since compiler goes only by referencing variable not by type of object and therefore the binding would be delayed to runtime and therefore the corresponding version of bark will be called based on type on object.