Regarding reference variable

hello i am new to this forum.can anyone please explain the elucidated stuff given below with an example

A reference variable can be of only one type, and once declared, that type
can never be changed (although the object it references can change).

A reference is a variable, so it can be reassigned to other objects, (unless the
reference is declared final).

A reference variable's type determines the methods that can be invoked on
the object the variable is referencing.

A reference variable can refer to any object of the same type as the declared
reference, or—this is the big one—it can refer to any subtype of the
declared type!

thanks in advance

Please go through the tutorial - http://docs.oracle.com/javase/tutorial/java/index.html

After reading the tutorial check if this program helps you...

public class SomeClass { public static void main(String...args){ Object obj = new Object(); Fruit fruit = new Fruit(); Apple apple = new Apple(); Vegetable vegetable = new Vegetable(); Tomato tomato = new Tomato(); obj = fruit; obj = new Apple(); final Object objFinal = new Object(); objFinal = fruit; objFinal = new Tomato(); apple.getFruitName(); apple.getVegetableName(); fruit = new Apple(); System.out.println(fruit.getFruitName()); } } class Fruit { String getFruitName(){ return "Fruit"; } } class Apple extends Fruit{ String getFruitName() { return "Apple"; } } class Vegetable { } class Tomato extends Vegetable { String getVegetableName() { return "Tomato"; } }

And read - HowToAskQuestionsOnJavaRanch

kiruthigha rajan wrote:hello i am new to this forum.can anyone please explain the elucidated stuff given below with an example

A reference variable can be of only one type, and once declared, that type
can never be changed (although the object it references can change).

int variable1 = 5; variable1 = "Invalid statement"; //This would be an invalid statement
As its statically and strongly typed language- the type of the variable is determined at compile time and cannot be changed during runtime. And Strongly typed because each variable should have a type associated.

kiruthigha rajan wrote:
A reference is a variable, so it can be reassigned to other objects, (unless the
reference is declared final).

Lets consider a sample class-
class Animal { String name; public Animal(String n) { name = n; } public String getName() { return name; } }

So you create an instance of Animal-
Animal animal1 = new Animal("Animal1");

And then you can assign animal1 to some other instance of Animal
animal1 = new Animal("Animal2");

But if its declared as final-
final Animal animal1 = new Animal("Animal1"); animal1 = new Animal("Animal2"); //This will result in an error

kiruthigha rajan wrote:
A reference variable's type determines the methods that can be invoked on
the object the variable is referencing.

Consider the Animal class, the methods you can invoke on an instance of animal class are those present in the Animal class and those present in the super class which Animal extends (provided the Super class has them declared as either public or protected)
By default in Java all classes extend the Object class. Check out the Javadoc for the methods present in Object class.
Animal animal1 = new Animal("Animal1"); //So the methods which you can invoke on animal1 are: System.out.println(animal1.getName()); //Lets try to invoke some method not defined in Animal class. animal1.someNonExistingMethod(); //You get a compiler error //You can try to invoke some method present in the Object class animal1.toString(); animal1.hashCode();

kiruthigha rajan wrote:
A reference variable can refer to any object of the same type as the declared
reference, or—this is the big one—it can refer to any subtype of the
declared type!

Consider another class-
class Tiger extends Animal { } //So you can this declaration Animal animal1 = new Animal(); //Or you can have this Tiger tiger1 = new Tiger(); //Or you can have this // The super class reference referring to a sub class instance. Animal animal2 = new Tiger();

}

and Welcome to JavaRanch!
You need to go through some tutorials, work out some code to understand the concepts. Just trying to understand what they mean from the language point of view, you can get confused.
The best way to learn a programming language is to WRITE CODE.

Mohamed Sanaulla wrote:and Welcome to JavaRanch!
You need to go through some tutorials, work out some code to understand the concepts. Just trying to understand what they mean from the language point of view, you can get confused.
The best way to learn a programming language is to WRITE CODE.

awesome explanation..thanks alot

hello,i am unable to understand the question itself can anyone help me with an example

Which methods can be invoked when the PlayerPiece object is being referred
to using a reference declared as type Animatable? Only the animate() method.

the code is:
public interface Animatable { public void animate(); } class PlayerPiece extends GameShape implements Animatable { public void movePiece() { System.out.println("moving game piece"); } public void animate() { System.out.println("animating..."); } // more code }

Question is if you have a reference type of the Animatable interface which methods can you call with that variable.

John Jai wrote:Question is if you have a reference type of the Animatable interface which methods can you call with that variable.

In code (just for some added clarity), that would be:

Animatable player = new PlayerPiece(); // What methods can be called on 'player' now?

Hai everyone.. i am unable to understand the concept given below?how can a reference variable access a static method.as they have told before that static members=class and non static=instance.
then how cum is this possible.if possible please explain with an example.thanks in advance

"But just to make it really confusing, the Java language also allows you to use an
object reference variable to access a static member:
Frog f = new Frog();
int frogs = f.frogCount; // Access static variable
// FrogCount using f"

the whole program is given below:

class Frog {
static int frogCount = 0; // Declare and initialize
// static variable
public Frog() {
frogCount += 1; // Modify the value in the constructor
}
}
class TestFrog {
public static void main (String [] args) {
new Frog();
new Frog();
new Frog();
System.out.print("frogCount:"+Frog.frogCount); //Access
// static variable
}
}

Declaring a field as static means it exists only once, in the class. The alternative is instance variables, which exist in each and every instance of the class that gets created. So, if you have an instance variable (let's call it 'i') defined in your class (let's call it 'C'), then every object of type C can have its own value for i. If you have a static variable (let's call it 's') defined in your class, then every object of type C shares the value of s (i.e. they would all see the same value, and if you changed it in one place, every existing instance would see the new value).

Generally, you want to access static members through the class itself (for example, C.s), but, because those static members are accessible by every instance, you can access them through the instance as well. There may be a slightly more technical reason as to why this is the case, and I don't know it. One thing to remember though: just because you can access static members through the instance, doesn't mean you should; prefer to use the class (Frog.frogCount in your example).