About Class & Objects
Class
A class is a blueprint for creating different objects which defines its properties and behaviors. An object exhibits the properties and behaviors defined by its class.
Objects
An object is an instance of a class created using a new operator.
The new operator returns a reference to a new instance of a class. This reference can be assigned to a reference variable of the class. The process of creating objects from a class is called instantiation.
Declaring a Variable to Refer to an Object
class Point
{
…………
…………
}
Point originOne;
If you declare originOne like this, its value will be undetermined until an object is actually created and assigned to it. Simply declaring a reference variable does not create an object. For that, you need to use the new operator, as described in the next section. You must assign an object to originOne before you use it in your code. Otherwise, you will get a compiler error.
A variable in this state, which currently references no object, can be illustrated as follows (the variable name, originOne, plus a reference pointing to nothing):
Instantiating a Class The new keyword is a Java operator that creates the object. The new operator instantiates a class by allocating memory for a new object and returning a reference to that memory. The new operator also invokes the object constructor.
Note: The phrase "instantiating a class" means the same thing as "creating an object." When you create an object, you are creating an "instance" of a class, therefore "instantiating" a class.
The new operator requires a single, postfix argument: a call to a constructor. The name of the constructor provides the name of the class to instantiate.
The new operator returns a reference to the object it created. This reference is usually assigned to a variable of the appropriate type, like: Point originOne = new Point(23, 94);
The reference returned by the new operator does not have to be assigned to a variable. It can also be used directly in an expression. For example:
int height = new Rectangle().height;
int areaOfRectangle = new Rectangle(100, 50).getArea();
Instance Variables (Non-Static Fields)
Non-static fields are also known as instance variables because their values are unique to each instance of a class
Class Variables (Static Fields)
A class variable is any field declared with the static modifier; this tells the compiler that there is exactly one copy of this variable in existence; regardless of how many times the class has been instantiated.
Java Output Stmt
The printing facility is part of the Java standard library: The System class defines a public static field called out. The out object is an instance of the PrintStream class and provides the method println(String) for displaying data to the screen while creating a new line (standard out).
Simple Class program :
//sample.java
//import java.lang.*;
//import java.io.*;
class Sample
{
public static void main(String args[])
{
System.out.println("Hello World.");
System.out.println(123);
System.out.println(3.14);
System.out.println(true);
System.out.println('A');
System.out.println("Have a pleasant day.");
//PrintStream ps = new PrintStream(System.out);
//ps.println("This is to test.");
}
}
Simple Class program :
//sample.java
//import java.lang.*;
//import java.io.*;
class Sample
{
public static void main(String args[])
{
System.out.println("Hello World.");
System.out.println(123);
System.out.println(3.14);
System.out.println(true);
System.out.println('A');
System.out.println("Have a pleasant day.");
//PrintStream ps = new PrintStream(System.out);
//ps.println("This is to test.");
}
}
Output :
Hello World.123
3.14
true
A
Have a pleasant day.
Example2 for class:
/* A program that uses the Vehicle class.
Call this file VehicleDemo.java
*/
class Vehicle {
int passengers; // number of passengers
int fuelcap; // fuel capacity in gallons
int mpg; // fuel consumption in miles per gallon
}
// This class declares an object of type Vehicle.
class VehicleDemo {
public static void main(String args[]) {
Vehicle minivan = new Vehicle();
int range;
// assign values to fields in minivan
minivan.passengers = 7; //Notice the use of the dot
minivan.fuelcap = 16; //Notice the use of the dot
minivan.mpg = 21; //Notice the use of the dot operator to access a member.
// compute the range assuming a full tank of gas
range = minivan.fuelcap * minivan.mpg;
System.out.println("Minivan can carry " + minivan.passengers +" with a range of " + range);
*/
class Vehicle {
int passengers; // number of passengers
int fuelcap; // fuel capacity in gallons
int mpg; // fuel consumption in miles per gallon
}
// This class declares an object of type Vehicle.
class VehicleDemo {
public static void main(String args[]) {
Vehicle minivan = new Vehicle();
int range;
// assign values to fields in minivan
minivan.passengers = 7; //Notice the use of the dot
minivan.fuelcap = 16; //Notice the use of the dot
minivan.mpg = 21; //Notice the use of the dot operator to access a member.
// compute the range assuming a full tank of gas
range = minivan.fuelcap * minivan.mpg;
System.out.println("Minivan can carry " + minivan.passengers +" with a range of " + range);
}
}
You should call the file that contains this program VehicleDemo.java because the main( ) method is in the class called VehicleDemo, not the class called Vehicle. When you compile this program, you will find that two .class files have been created, one for Vehicle and one for VehicleDemo. The Java compiler automatically puts each class into its own .class file. It is not necessary for both the Vehicle and the VehicleDemo class to be in the same source file.You could put each class in its own file, called Vehicle.java and VehicleDemo.java, respectively.
To run this program, you must execute VehicleDemo.class. The following output is displayed:
Minivan can carry 7 with a range of 336
Before moving on, let’s review a fundamental principle: each object has its own copies of the instance variables defined by its class. Thus, the contents of the variables in one object can differ from the contents of the variables in another. There is no connection between the two objects except for the fact that they are both objects of the same type. For example, if you have two Vehicle objects, each has its own copy of passengers, fuelcap, and mpg, and the contents of these can differ between the two objects. The following program demonstrates this fact. (Notice that the class with main( ) is now called TwoVehicles.)
}
You should call the file that contains this program VehicleDemo.java because the main( ) method is in the class called VehicleDemo, not the class called Vehicle. When you compile this program, you will find that two .class files have been created, one for Vehicle and one for VehicleDemo. The Java compiler automatically puts each class into its own .class file. It is not necessary for both the Vehicle and the VehicleDemo class to be in the same source file.You could put each class in its own file, called Vehicle.java and VehicleDemo.java, respectively.
To run this program, you must execute VehicleDemo.class. The following output is displayed:
Minivan can carry 7 with a range of 336
Before moving on, let’s review a fundamental principle: each object has its own copies of the instance variables defined by its class. Thus, the contents of the variables in one object can differ from the contents of the variables in another. There is no connection between the two objects except for the fact that they are both objects of the same type. For example, if you have two Vehicle objects, each has its own copy of passengers, fuelcap, and mpg, and the contents of these can differ between the two objects. The following program demonstrates this fact. (Notice that the class with main( ) is now called TwoVehicles.)
// This program creates two Vehicle objects.
class Vehicle {
int passengers; // number of passengers
int fuelcap; // fuel capacity in gallons
int mpg; // fuel consumption in miles per gallon
}
// This class declares an object of type Vehicle.
class TwoVehicles {
public static void main(String args[]) {
Vehicle minivan = new Vehicle();
Vehicle sportscar = new Vehicle();
int range1, range2;
// assign values to fields in minivan
minivan.passengers = 7;
minivan.fuelcap = 16;
minivan.mpg = 21;
// assign values to fields in sportscar
sportscar.passengers = 2;
sportscar.fuelcap = 14;
sportscar.mpg = 12;
// compute the ranges assuming a full tank of gas
range1 = minivan.fuelcap * minivan.mpg;
range2 = sportscar.fuelcap * sportscar.mpg;
System.out.println("Minivan can carry " + minivan.passengers +
" with a range of " + range1);
System.out.println("Sportscar can carry " + sportscar.passengers +
" with a range of " + range2);
}
}
The output produced by this program is shown here:
Minivan can carry 7 with a range of 336
Sportscar can carry 2 with a range of 168
class Vehicle {
int passengers; // number of passengers
int fuelcap; // fuel capacity in gallons
int mpg; // fuel consumption in miles per gallon
}
// This class declares an object of type Vehicle.
class TwoVehicles {
public static void main(String args[]) {
Vehicle minivan = new Vehicle();
Vehicle sportscar = new Vehicle();
int range1, range2;
// assign values to fields in minivan
minivan.passengers = 7;
minivan.fuelcap = 16;
minivan.mpg = 21;
// assign values to fields in sportscar
sportscar.passengers = 2;
sportscar.fuelcap = 14;
sportscar.mpg = 12;
// compute the ranges assuming a full tank of gas
range1 = minivan.fuelcap * minivan.mpg;
range2 = sportscar.fuelcap * sportscar.mpg;
System.out.println("Minivan can carry " + minivan.passengers +
" with a range of " + range1);
System.out.println("Sportscar can carry " + sportscar.passengers +
" with a range of " + range2);
}
}
The output produced by this program is shown here:
Minivan can carry 7 with a range of 336
Sportscar can carry 2 with a range of 168
As you can see, minivan’s data is completely separate from the data contained in sportscar. The following illustration depicts this situation.
In the preceding programs, the following line was used to declare an object of type Vehicle:
Vehicle minivan = new Vehicle();
This declaration performs two functions. First, it declares a variable called minivan of the class type Vehicle. This variable does not define an object. Instead, it is simply a variable that can refer to an object. Second, the declaration creates a physical copy of the object and assigns to minivan a reference to that object. This is done by using the new operator.
The new operator dynamically allocates (that is, allocates at run time) memory for an object and returns a reference to it. This reference is, more or less, the address in memory of the object allocated by new. This reference is then stored in a variable. Thus, in Java, all class objects must be dynamically allocated. The two steps combined in the preceding statement can be rewritten like this to show each step individually:
Vehicle minivan; // declare reference to object
minivan = new Vehicle(); // allocate a Vehicle object
The first line declares minivan as a reference to an object of type Vehicle. Thus, minivan is a variable that can refer to an object, but it is not an object, itself. At this point, minivan contains the value null, which means that it does not refer to an object. The next line creates a new Vehicle object and assigns a reference to it to minivan. Now, minivan is linked with an object.
Reference Variables and Assignment
Vehicle minivan = new Vehicle();
This declaration performs two functions. First, it declares a variable called minivan of the class type Vehicle. This variable does not define an object. Instead, it is simply a variable that can refer to an object. Second, the declaration creates a physical copy of the object and assigns to minivan a reference to that object. This is done by using the new operator.
The new operator dynamically allocates (that is, allocates at run time) memory for an object and returns a reference to it. This reference is, more or less, the address in memory of the object allocated by new. This reference is then stored in a variable. Thus, in Java, all class objects must be dynamically allocated. The two steps combined in the preceding statement can be rewritten like this to show each step individually:
Vehicle minivan; // declare reference to object
minivan = new Vehicle(); // allocate a Vehicle object
The first line declares minivan as a reference to an object of type Vehicle. Thus, minivan is a variable that can refer to an object, but it is not an object, itself. At this point, minivan contains the value null, which means that it does not refer to an object. The next line creates a new Vehicle object and assigns a reference to it to minivan. Now, minivan is linked with an object.
Reference Variables and Assignment
In an assignment operation, object reference variables act differently than do variables of a primitive type, such as int. When you assign one primitive-type variable to another, the situation is straightforward. The variable on the left receives a copy of the value of the variable on the right. When you assign an object reference variable to another, the situation is a bit more complicated because you are changing the object that the reference variable refers to. The effect of this difference can cause some counterintuitive results. For example, consider the following fragment:
Vehicle car1 = new Vehicle();
Vehicle car2 = car1;
At first glance, it is easy to think that car1 and car2 refer to different objects, but this is not the case. Instead, car1 and car2 will both refer to the same object. The assignment of car1 to car2 simply makes car2 refer to the same object as does car1. Thus, the object can be acted upon by either car1 or car2. For example, after the assignment car1.mpg = 26; executes, both of these println( ) statements
System.out.println(car1.mpg);
System.out.println(car2.mpg);
Vehicle car1 = new Vehicle();
Vehicle car2 = car1;
At first glance, it is easy to think that car1 and car2 refer to different objects, but this is not the case. Instead, car1 and car2 will both refer to the same object. The assignment of car1 to car2 simply makes car2 refer to the same object as does car1. Thus, the object can be acted upon by either car1 or car2. For example, after the assignment car1.mpg = 26; executes, both of these println( ) statements
System.out.println(car1.mpg);
System.out.println(car2.mpg);
display the same value: 26. Although car1 and car2 both refer to the same object, they are not linked in any other way. For example, a subsequent assignment to car2 simply changes the object to which car2
refers. For example:
Vehicle car1 = new Vehicle();
Vehicle car2 = car1;
Vehicle car3 = new Vehicle();
car2 = car3; // now car2 and car3 refer to the same object.
After this sequence executes, car2 refers to the same object as car3. The object referred to by car1 is unchanged.
Methods
As explained, instance variables and methods are the constituents of classes. So far, the Vehicle class contains data, but no methods. Although data-only classes are perfectly valid, most classes will have methods. Methods are subroutines that manipulate the data defined by the class and, in many cases, provide access to that data. In most cases, other parts of your program will interact with a class through its methods.
refers. For example:
Vehicle car1 = new Vehicle();
Vehicle car2 = car1;
Vehicle car3 = new Vehicle();
car2 = car3; // now car2 and car3 refer to the same object.
After this sequence executes, car2 refers to the same object as car3. The object referred to by car1 is unchanged.
Methods
As explained, instance variables and methods are the constituents of classes. So far, the Vehicle class contains data, but no methods. Although data-only classes are perfectly valid, most classes will have methods. Methods are subroutines that manipulate the data defined by the class and, in many cases, provide access to that data. In most cases, other parts of your program will interact with a class through its methods.
A method contains one or more statements. In well-written Java code, each method performs only one task. Each method has a name, and it is this name that is used to call the method. In general, you can give a method whatever name you please. However, remember that main( ) is reserved for the method that begins execution of your program. Also, don’t use Java’s keywords for method names. When denoting methods in text, this book has used and will continue to use a convention that has become common when writing about Java. A method will have parentheses after its name. For example, if a method’s name is getval, it will be written getval( ) when its name is used in a sentence. This notation will help you distinguish variable names from method names.
The general form of a method is shown here:
ret-type name( parameter-list ) {
// body of method
}
Here, ret-type specifies the type of data returned by the method. This can be any valid type, including class types that you create. If the method does not return a value, its return type must be void. The name of the method is specified by name. This can be any legal identifier other than those already used by other items within the current scope. The parameter-list is a sequence of type and identifier pairs separated by commas. Parameters are essentially variables that receive the value of the arguments passed to the method when it is called. If the method has no parameters, the parameter list will be empty.
ret-type name( parameter-list ) {
// body of method
}
Here, ret-type specifies the type of data returned by the method. This can be any valid type, including class types that you create. If the method does not return a value, its return type must be void. The name of the method is specified by name. This can be any legal identifier other than those already used by other items within the current scope. The parameter-list is a sequence of type and identifier pairs separated by commas. Parameters are essentially variables that receive the value of the arguments passed to the method when it is called. If the method has no parameters, the parameter list will be empty.
Adding a Method to the Vehicle Class
As just explained, the methods of a class typically manipulate and provide access to the data of the class. With this in mind, recall that main( ) in the preceding examples computed the range of a vehicle by multiplying its fuel consumption rate by its fuel capacity. While technically correct, this is not the best way to handle this computation. The calculation of a vehicle’s range is something that is best handled by the Vehicle class itself. The reason for this conclusion is easy to understand: the range of a vehicle is dependent upon the capacity of the fuel tank and the rate of fuel consumption, and both of these quantities are encapsulated by Vehicle. By adding a method to Vehicle that computes the range, you are enhancing its object-oriented structure.To add a method to Vehicle, specify it within Vehicle’s declaration. For example, the following version of Vehicle contains a method called range( ) that displays the range of the vehicle.
// Add range to Vehicle.
class Vehicle {
int passengers; // number of passengers
int fuelcap; // fuel capacity in gallons
int mpg; // fuel consumption in miles per gallonclass Vehicle {
int passengers; // number of passengers
int fuelcap; // fuel capacity in gallons
// Display the range.
void range() {
System.out.println("Range is " + fuelcap * mpg);
}
}
class AddMeth {
public static void main(String args[]) {
Vehicle minivan = new Vehicle();
Vehicle sportscar = new Vehicle();
int range1, range2;
// assign values to fields in minivan
minivan.passengers = 7;
minivan.fuelcap = 16;
minivan.mpg = 21;
// assign values to fields in sportscar
sportscar.passengers = 2;
sportscar.fuelcap = 14;
sportscar.mpg = 12;
System.out.print("Minivan can carry " + minivan.passengers +". ");
minivan.range(); // display range of minivan
System.out.print("Sportscar can carry " + sportscar.passengers +". ");
sportscar.range(); // display range of sportscar.
}
}
This program generates the following output:
Minivan can carry 7. Range is 336
Sportscar can carry 2. Range is 168
Let’s look at the key elements of this program, beginning with the range( ) method itself.
The first line of range( ) is
void range() {
The range( ) method is contained within the Vehicle class. Notice that fuelcap and mpg are used directly, without the dot operator. This line declares a method called range that has no parameters. Its return type is void. Thus, range( ) does not return a value to the caller. The line ends with the opening curly brace of the
method body. The body of range( ) consists solely of this line:
System.out.println("Range is " + fuelcap * mpg);
This statement displays the range of the vehicle by multiplying fuelcap by mpg. Since each object of type Vehicle has its own copy of fuelcap and mpg, when range( ) is called, the range computation uses the calling object’s copies of those variables. The range( ) method ends when its closing curly brace is encountered. This causes program control to transfer back to the caller. Next, look closely at this line of code from inside main():
minivan.range();
This statement invokes the range( ) method on minivan. That is, it calls range( ) relative to the minivan object, using the object’s name followed by the dot operator. When a method iscalled, program control is transferred to the method. When the method terminates, control is transferred back to the caller, and execution resumes with the line of code following the call.In this case, the call to minivan.range( ) displays the range of the vehicle defined by minivan.
In similar fashion, the call to sportscar.range( ) displays the range of the vehicle defined bysportscar. Each time range( ) is invoked, it displays the range for the specified object.There is something very important to notice inside the range( ) method: the instance variablesfuelcap and mpg are referred to directly, without preceding them with an object name or the dot operator. When a method uses an instance variable that is defined by its class, it does sodirectly, without explicit reference to an object and without use of the dotoperator. This iseasy to understand if you think about it. A method is always invoked relative to some object of its class. Once this invocation has occurred, the object is known. Thus, within a method, there is no need to specify the object a second time. This means that fuelcap and mpg inside range( ) implicitly refer to the copies of those variables found in the object that invokes range( ).
Returning from a Method
In general, there are two conditions that cause a method to return—first, as the range( ) method in the preceding example shows, when the method’s closing curly brace is encountered. The second is when a return statement is executed. There are two forms of return—one for use in void methods (those that do not return a value) and one for returning values. The first form is examined here.
In a void method, you can cause the immediate termination of a method by using this form
of return: return ;
When this statement executes, program control returns to the caller, skipping any remaining code in the method. For example, consider this method:
void myMeth() {
int i;
for(i=0; i<10; i++) {
if(i == 5) return; // stop at 5
System.out.println();
}
}
Here, the for loop will only run from 0 to 5, because once i equals 5, the method returns. It is permissible to have multiple return statements in a method, especially when there are two or more routes out of it. For example:
void myMeth() {
// ...
if(done) return;
// ...
if(error) return;
}
Here, the method returns if it is done or if an error occurs. Be careful, however, because having too many exit points in a method can destructure your code; so avoid using them casually. A well-designed method has well-defined exit points. To review: a void method can return in one of two ways—its closing curly brace is
reached, or a return statement is executed.
Returning a Value
Although methods with a return type of void are not rare, most methods will return a value. In fact, the ability to return a value is one of the most useful features of a method. You have already seen one example of a return value: when we used the sqrt( ) function to obtain a square root.
Return values are used for a variety of purposes in programming. In some cases, such as with sqrt( ), the return value contains the outcome of some calculation. In other cases, the return value may simply indicate success or failure. In still others, it may contain a status code. Whatever the purpose, using method return values is an integral part of Java programming. Methods return a value to the calling routine using this form of return: return value; Here, value is the value returned.
You can use a return value to improve the implementation of range( ). Instead of displaying the range, a better approach is to have range( ) compute the range and return this value. Among the advantages to this approach is that you can use the value for other calculations. The following example modifies range( ) to return the range rather than displaying it.
// Use a return value.
class Vehicle {
int passengers; // number of passengers
int fuelcap; // fuel capacity in gallons
int mpg; // fuel consumption in miles per gallon
// Return the range.
int range() {
return mpg * fuelcap;
}
}
class RetMeth {
public static void main(String args[]) {
Vehicle minivan = new Vehicle();
Vehicle sportscar = new Vehicle();
int range1, range2;
// assign values to fields in minivan
minivan.passengers = 7;
minivan.fuelcap = 16;
minivan.mpg = 21;
// assign values to fields in sportscar
sportscar.passengers = 2;
sportscar.fuelcap = 14;
sportscar.mpg = 12;
// get the ranges
range1 = minivan.range();
range2 = sportscar.range();
System.out.println("Minivan can carry " + minivan.passengers +
" with range of " + range1 + " Miles");
System.out.println("Sportscar can carry " + sportscar.passengers +
" with range of " + range2 + " miles");
}
}
The output is shown here:
Minivan can carry 7 with range of 336 Miles
Sportscar can carry 2 with range of 168 miles
In the program, notice that when range( ) is called, it is put on the right side of an assignment statement. On the left is a variable that will receive the value returned by range( ). Thus, after
range1 = minivan.range();
executes, the range of the minivan object is stored in range1. Notice that range( ) now has a return type of int. This means that it will return an integer value to the caller. The return type of a method is important because the type of data returned by a method must be compatible with the return type specified by the method. Thus, if you want a method to return data of type double, its return type must be type double. Although the preceding program is correct, it is not written as efficiently as it could be. Specifically, there is no need for the range1 or range2 variables. A call to range( ) can be used in the println( ) statement directly, as shown here:
System.out.println("Minivan can carry " + minivan.passengers +" with range of " + minivan.range() + " Miles");
In this case, when println( ) is executed, minivan.range( ) is called automatically and its value will be passed to println( ). Furthermore, you can use a call to range( ) whenever the range of a Vehicle object is needed. For example, this statement compares the ranges of two vehicles:
if(v1.range() > v2.range()) System.out.println("v1 has greater range");
//passing a reference to a function and returning a reference
import java.lang.*;
class Sample
{
int num1;
int num2;
void set(int num1,int num2)
{
this.num1 = num1;
this.num2 = num2;
}
void show()
{
System.out.println("num1 : " + num1 + " num2 : " + num2);
}
Sample sum(Sample ob2)
{
Sample ob3 = new Sample();
ob3.num1 = num1 + ob2.num1;
ob3.num2 = num2 + ob2.num2;
//ob3.num1 = this.num1 + ob2.num1;
//ob3.num2 = this.num2 + ob2.num2;
return ob3;
}
}
class MainClass
{
public static void main(String args[])
{
Sample s1 = new Sample();
s1.set(10,20);
s1.show();
System.out.println("----------------------");
Sample s2 = new Sample();
s2.set(100,200);
s2.show();
System.out.println("----------------------");
Sample s3 = s1.sum(s2);
s3.show();
}
}
Output is:
num1 : 10 num2 : 20
----------------------
num1 : 100 num2 : 200
----------------------
num1 : 110 num2 : 220
Method Overloading :
In Java it is possible to define two or more methods within the same class that share the same name, as long as their parameter declarations are different. When this is the case, the methods are said to be overloaded, and the process is referred to as method overloading. Method overloading is one of the ways that Java implements polymorphism.
If you have never used a language that allows the overloading of methods, then the concept may seem strange at first. But as you will see, method overloading is one of Java's most exciting and useful features. When an overloaded method is invoked, Java uses the type and/or number of arguments as its guide to determine which version of the overloaded method to actually call. Thus,
overloaded methods must differ in the type and/or number of their parameters. While overloaded methods may have different return types, the return type alone is insufficient to distinguish two versions of a method. When Java encounters a call to an overloaded method, it simply executes the version of the method whose parameters match the arguments used in the call. Here is a simple example that illustrates method overloading:
//method overloading
import java.lang.*;
class Sample
{
void fun(int x,int y)
{
System.out.println("2 int args");
}
void fun(float x)
{
System.out.println("1 float args");
}
void fun(char x)
{
System.out.println("1 char args");
}
void fun(double x,double y,double z)
{
System.out.println("3 double args");
}
}
class MainClass
{
public static void main(String args[])
{
Sample s = new Sample();
s.fun(10,20); //identity conversion
s.fun(10.20f); //identity conversion
s.fun((float)10.20); //type casting or down casting or narrowing primitive conversion
s.fun('A'); //identity conversion
s.fun('A','B'); //widening primitive conversion
s.fun(1.2,3.4,5.6); //identity conversion
s.fun(1,2,3); //widening primitive conversion
s.fun(70); //widening primitive conversion
s.fun((char)70); //type casting
s.fun('a','b','c');
s.fun('a',1,2.3);
// s.fun(1.2); //error
}
}
Output is:
2 int args
1 float args
1 float args
1 char args
2 int args
3 double args
3 double args
1 float args
1 char args
3 double args
3 double args
Example 2:
import java.lang.*;
class Student
{
int sno;
String sname;
void setDetails()
{
sno = -1111;
sname = "Not Assigned";
}
void setDetails(int sno)
{
this.sno = sno;
sname = "Not Assigned";
}
void setDetails(int sno,String sname)
{
this.sno = sno;
this.sname = sname;
}
void showDetails()
{
System.out.println("sno : " + sno + " sname : " + sname);
}
}
class MainClass
{
public static void main(String args[])
{
Student st1 = new Student();
st1.setDetails();
st1.showDetails();
System.out.println("------------------------------");
Student st2 = new Student();
st2.setDetails(1231);
st2.showDetails();
System.out.println("------------------------------");
Student st3 = new Student();
st3.setDetails(1232,"Abcd");
st3.showDetails();
}
}
Output is:
sno : -1111 sname : Not Assigned
------------------------------
sno : 1231 sname : Not Assigned
------------------------------
sno : 1232 sname : Abcd
------------------------------
sno : 1231 sname : Not Assigned
------------------------------
sno : 1232 sname : Abcd
Constructor
All classes have at least one constructor. If a class does not explicitly declare any, the Java compiler automatically provides a no-argument constructor, called the default constructor. This default constructor calls the class parent's no-argument constructor or the Object constructor if the class has no other parent. If the parent has no constructor (Object does have one), the compiler will reject the program.
A class contains constructors that are invoked to create objects from the class blueprint. Constructor declarations look like method declarations—except that they use the name of the class and have no return type.
You don't have to provide any constructors for your class, but you must be careful when doing this. The compiler automatically provides a no-argument, default constructor for any class without constructors. This default constructor will call the no-argument constructor of the super class. In this situation, the compiler will complain if the super class doesn't have a no-argument constructor so you must verify that it does. If your class has no explicit super class, then it has an implicit super class of Object, which does have a no-argument constructor
You don't have to provide any constructors for your class, but you must be careful when doing this. The compiler automatically provides a no-argument, default constructor for any class without constructors. This default constructor will call the no-argument constructor of the super class. In this situation, the compiler will complain if the super class doesn't have a no-argument constructor so you must verify that it does. If your class has no explicit super class, then it has an implicit super class of Object, which does have a no-argument constructor
All classes have at least one constructor. If a class does not explicitly declare any, the Java compiler automatically provides a no-argument constructor, called the default constructor. This default constructor calls the class parent's no-argument constructor or the Object constructor if the class has no other parent. If the parent has no constructor (Object does have one), the compiler will reject the program.
When you define a class derived from another class, the first line of a constructor must be a call to the constructor of the base class, unless the base class has an accessible constructor that takes no parameters.
Note
Parameters refer to the list of variables in a method declaration.
Arguments are the actual values that are passed in when the method is invoked. When you invoke a method, the arguments used must match the declaration's parameters in type and order.
//constructor Ex 1:
import java.lang.*;
class Student
{
int sno;
String sname;
Student() //non parameterized cons or no arg cons
{
sno = 1231;
sname = "Abcd";
}
void showDetails()
{
System.out.println("sno : " + sno + " sname : " + sname);
}
}
class MainClass
{
public static void main(String args[])
{
Student st1 = new Student();
st1.showDetails();
System.out.println("-------------------------");
Student st2 = new Student();
st2.showDetails();
}
Output is:
sno : 1231 sname : Abcd
-------------------------
sno : 1231 sname : Abcd
sno : 1231 sname : Abcd
-------------------------
sno : 1231 sname : Abcd
this keyword:
/*this
----
"this" is a keyword that always refers the address
of the current object.
in every non static method by default "this" will be
available.
*/
import java.lang.*;
class Student
{
int sno;
String sname;
void setDetails(int sno,String sname)
{
System.out.println("this : " + this);
this.sno = sno;
this.sname = sname;
}
void showDetails()
{
System.out.println("this : " + this);
System.out.println("sno : " + sno);
System.out.println("sname : " + sname);
}
}
class MainClass
{
public static void main(String args[])
{
Student st1 = new Student();
System.out.println("st1 : " + st1);
st1.setDetails(1231,"Abcd");
st1.showDetails();
System.out.println("--------------------");
Student st2 = new Student();
System.out.println("st2 : " + st2);
st2.setDetails(1232,"Efgh");
st2.showDetails();
}
}
Output is:
st1 : Student@19821f
this : Student@19821f
this : Student@19821f
sno : 1231
sname : Abcd
--------------------
st2 : Student@addbf1
this : Student@addbf1
this : Student@addbf1
sno : 1232
sname : Efgh
//constructor Ex2
//sample.java
import java.lang.*;
class Sample
{
void fun() //normal function
{
System.out.println("this : " + this); //hashcode=class_name+@+address
System.out.println("i'm a normal function.");
}
Sample() //constructor
{
System.out.println("this : " + this); //hashcode=class_name+@+address
System.out.println("i'm a constructor.");
}
}
class MainClass
{
public static void main(String args[])
{
new Sample();
System.out.println("-----------------------");
Sample s;
s = new Sample(); //cons called
System.out.println("s : " + s); //hashcode=class_name+@+address
s.fun(); //fun called
System.out.println("-----------------------");
new Sample();
System.out.println("-----------------------");
new Sample().fun();
}
}
Output is:
this : Sample@19821f
i'm a constructor.
-----------------------
this : Sample@addbf1
i'm a constructor.
s : Sample@addbf1
this : Sample@addbf1
i'm a normal function.
-----------------------
this : Sample@42e816
i'm a constructor.
-----------------------
this : Sample@9304b1
i'm a constructor.
this : Sample@9304b1
i'm a normal function.
When Are Constructors Called?
In the foregoing discussion of inheritance and class hierarchies, an important question may have occurred to you: When a subclass object is created, whose constructor is executed first, the one in the subclass or the one defined by the superclass? For example, given a subclass called B and a superclass called A, is A’s constructor called before B’s, or vice versa? The answer is that in a class hierarchy, constructors are called in order of derivation, from superclass to subclass. Further, since super( ) must be the first statement executed in a subclass’ constructor, this order is the same whether or not super( ) is used. If super( ) is not used, then the default (parameterless) constructor of each superclass will be executed. The following program
illustrates when constructors are executed:
// Demonstrate when constructors are called.
// Create a super class.
class A {
A() {
System.out.println("Constructing A.");
}
}
//sample.java
import java.lang.*;
class Sample
{
void fun() //normal function
{
System.out.println("this : " + this); //hashcode=class_name+@+address
System.out.println("i'm a normal function.");
}
Sample() //constructor
{
System.out.println("this : " + this); //hashcode=class_name+@+address
System.out.println("i'm a constructor.");
}
}
class MainClass
{
public static void main(String args[])
{
new Sample();
System.out.println("-----------------------");
Sample s;
s = new Sample(); //cons called
System.out.println("s : " + s); //hashcode=class_name+@+address
s.fun(); //fun called
System.out.println("-----------------------");
new Sample();
System.out.println("-----------------------");
new Sample().fun();
}
}
Output is:
this : Sample@19821f
i'm a constructor.
-----------------------
this : Sample@addbf1
i'm a constructor.
s : Sample@addbf1
this : Sample@addbf1
i'm a normal function.
-----------------------
this : Sample@42e816
i'm a constructor.
-----------------------
this : Sample@9304b1
i'm a constructor.
this : Sample@9304b1
i'm a normal function.
When Are Constructors Called?
In the foregoing discussion of inheritance and class hierarchies, an important question may have occurred to you: When a subclass object is created, whose constructor is executed first, the one in the subclass or the one defined by the superclass? For example, given a subclass called B and a superclass called A, is A’s constructor called before B’s, or vice versa? The answer is that in a class hierarchy, constructors are called in order of derivation, from superclass to subclass. Further, since super( ) must be the first statement executed in a subclass’ constructor, this order is the same whether or not super( ) is used. If super( ) is not used, then the default (parameterless) constructor of each superclass will be executed. The following program
illustrates when constructors are executed:
// Demonstrate when constructors are called.
// Create a super class.
class A {
A() {
System.out.println("Constructing A.");
}
}
// Create a subclass by extending class A.
class B extends A {
B() {
System.out.println("Constructing B.");
}
}
// Create another subclass by extending B.
class C extends B {
C( ) {
System.out.println("Constructing C.");
}
}
class OrderOfConstruction {
public static void main(String args[]) {
C c = new C();
}
}
The output from this program is shown here:
Constructing A.
Constructing B.
Constructing C.
As you can see, the constructors are called in order of derivation. If you think about it, it makes sense that constructors are executed in order of derivation. Because a superclass has no knowledge of any subclass, any initialization it needs to perform is separate from and possibly prerequisite to any initialization performed by the subclass. Therefore, it must be executed first.
class B extends A {
B() {
System.out.println("Constructing B.");
}
}
// Create another subclass by extending B.
class C extends B {
C( ) {
System.out.println("Constructing C.");
}
}
class OrderOfConstruction {
public static void main(String args[]) {
C c = new C();
}
}
The output from this program is shown here:
Constructing A.
Constructing B.
Constructing C.
As you can see, the constructors are called in order of derivation. If you think about it, it makes sense that constructors are executed in order of derivation. Because a superclass has no knowledge of any subclass, any initialization it needs to perform is separate from and possibly prerequisite to any initialization performed by the subclass. Therefore, it must be executed first.
No comments:
Post a Comment