Answer of this question says "You are not creating an instance of the interface.." I wonder if it is true.
can anyone let me know whose instance is created in below lines of code? and why?
BaseClass b= new Child();
and
BaseInterface bi= new Child();
Edit : I am asking with respect to C#.net language. If instance is created of child(). why intellisense of visual studio shows Base members while pressing ?
The actual object created is an instance of the Child class.
The "up-cast" is merely a different view of the same Child object instance.
A statically-typed language limits the operations based on the type of the expression, not the type of the actual object the expressions evaluate to. Because of this, the IntelliSense will only show methods applicable to BaseClass for b and BaseInterface for bi.
This is also why something like Object o = new Child() is valid, even though only the methods defined on Object can be invoked upon o, which is is an expression typed as Object.
The fact that the actual object is a Child can be demonstrated as so:
Child c = new Child();
BaseClass b = c;
BaseInterface bi = c;
c.GetType() == typeof(Child) // => true
object.ReferenceEquals(c, b) // => true
object.ReferenceEquals(c, bi) // => true
This is a very basic question, yet a very, very important one. But I'm not sure this site is the best medium for getting your answer (and more importantly, for understanding it). Try to take a lesson in OOP somewhere, or look for an online presentation detailing it.
Short answer
Runtime type and Static type are two very different things.
Longer answer:
In a statically typed language as C# (or java, or F#, or a bunch of others), a variable always has a static type. The static type is the type that the compiler proved the variable is of, because you told it it is, or because it inferred it (in case of var or lambda arguments for instance).
Some exemples:
int i; //i is of type int
BaseClass b; //b is of class BaseClass
IEnumerable<int> list; //list implements interface IEnumerable<int>
var s = "foo"; //s is inferred to be of type string
This is static typing. It means the variable is of the given type. It does not mean that the object in the variable is this type (which would not even make sense for an interface!), it just means that the compiler has proof that the object inside is assignable to this type (which exactly means it can be put into a variable/field of that type).
Contrast the runtime type. The runtime type is the actual type of the instance. It's only a runtime thing, the compiler cannot access it. It is what is effectively there.
When you statically make method and property calls, you can only call properties and methods from the static type. Simply because it's the only type the compiler can know about. When you're writing
BaseInterface bi= new Child();
You're effectively telling the compiler "I ask you to forget this object is a Child, treat it as a BaseInterface". And that's exactly what the compiler does: you cannot access bi's member that are specific to the Child class.
In fact, this assignation is just a short way to make two very different operations. It's the same as
BaseInterface bi; // I create a "bi" variable. Its static type is BaseInterface
bi = new Child() // Instanciate an object of runtime type Child and assign it to the bi variable
Assigning a value to the variable does not the change its static type.
BaseClass b= new Child(); - the new Child() calls the constructor of class Child which initializes the object(creates a new instance), the reference type will be Base class.
So if BaseClass a has baseClassMet() and class Child() has an aditional method childMet(), you can call the methods defined only in the BaseClass.
and
BaseInterface bi= new Child(); With the interface first of all you cannot instantiate an interface directly. You can assign to an interface a class that implements that interface.
So in this case lets say that Base interface has a method definition void interfMet();
As you know in the class that implements this interface you are obligated to implement this method.
The object reference bi being type of BaseInterface will have access only to methods that the interface declares. You cannot accces with bi(interface reference type) methods of Child class.
If you really want to access methods of Child you have to do a cast.
I hope this helps you.
interface BaseInterface{
void interMet();
}
class BaseClass{
void baseClassMet(){
System.out.println("baseClassMet method in superclass");
}
}
public class Child extends BaseClass implements BaseInterface{
//overrided method
void baseClassMet(){
System.out.println("baseClass method in extended class");
}
//method of child
void childMet(){
System.out.println("Child met");
}
public void interMet() {
System.out.println("Implemented method");
}
public static void main(String[] args) {
Child c = new Child();
c.baseClassMet();// prints "baseClass method in extended class"
BaseClass b = new Child();
b.baseClassMet();// prints "baseClass method in extended class"
b.childMet//can't access object method childMet() like this // Does not compile
((Child)b).childMet();//you can do it like this telling the compiler that
//you are sure that b point to a Child object
BaseClass b1 = new BaseClass();
b1.baseClassMet();//prints "baseClassMet method in superclass"
BaseInterface bi = new Child();//assigning bi of type BaseInterface(interface) the object Child
bi.interMet(); // this prints "Child met"
}}
the declared type of the reference is the perspective you choose to interract with the Child instance , the perspective oopingly speaking is a super class or Interface of the Child.
