Java With Us
Home   |   Tutorial   |   Programs  

Java Tutorial

Introduction to Java
Hello World Program
Variables and Data types
More about data types
Displaying text using print and println
Displaying text using printf
Java Comments
Naming conventions for Identifiers
Mathematical operations in Java
Taking input from the user

Classes and Objects
Introduction to object oriented programming
The constituents of a Class
Creating objects and calling methods
Get and Set Methods
Default constructor provided by the compiler
Access Specfiers
Scope and lifetime of Variables
Call by value and Call by Reference

A few more topics
Casting
Class as a reference data type
Constants or literals
Final variables
Increment and decrement operators
Manipulating Strings
Operators
Overloading constructors and methods
Static methods and variables
The Java API
The Math class
this keyword
Wrapper classes

Control Structures
Control Statements
Repetition statements
Nested loops
Formulating algorithms
Branching Statements

Arrays
Arrays introduction
Processing arrays using 1oops
Searching and sorting arrays
Array of objects
Multi dimensional arrays
Taking input as command line arguments
Using ellipsis to accept variable number of arguments

Inheritance
Inheritance introduction
Relation between a super class and sub class
Final classes and methods
The protected access specifier
Class Object

Polymorphism
Introduction
Interfaces
Packages
Abstract classes and methods

Exception handling
Exception handling introduction
Exception hierarchy
Nested try catch blocks
Throwing exceptions


Class as a Reference Data Type

It has already been said that a class is also a data type- a non primitive reference data type. This was very much implicit in the way we had declared a class variable in the following way.

Student s;

This declaration was identical to the way we declared the int variable firstNumber was declared in our Addition program

int firstNumber;

Now, considering this similarity, it should be possible to use a class everywhere we had used a primitive data type such as int. We can have instance variable of a class type, we can accept parameters of class type and we can also return objects from methods. All that needs to be done is to specify the particular reference type (the class name) wherever we had earlier specified the data type as int or double.

We shall now look into each of these possibilities and their applications.

The first in queue is to declare an instance variable of a class type. Assume that we have a Tutor class which would represent a person who would be taking classes for Students and each Tutor will be taking classes for exactly two Students. So, we need to have two Student instance variables in a Tutor class in the following way:

public class Tutor {
   Student s1,s2;
}

All the things that we have learnt with declaring and initialising variables of simple data types are applicable here also. And now, we need a constructor for this Tutor class which will initialise the variables s1 and s2 with two objects that would be passed as arguments. The constructor would be having the following form.

public Tutor ( Student stu1, Student stu2 ) {
   s1 = stu1;
   s2 = stu2;
}

We can also have methods that would return Student objects. For example, consider the following method getS1 which returns the s1 object. note that this method is however not necessary here as s1 hasn't been declared to be private.

public Student getS1() {
   return s1;
}

Note that we have specified the return type to be Student just like int, double and void. And lastly, we have to deal with referencing the constituents of an object. Suppose that we have a Tutor object named t. How would we call the print Details() method of s1? It is very much the same thing that we have been doing now with a little addition.

t.s1.printDetails();

t.s1 gives us access to the first Student's object and then we invoke the print Details() method on that object. Here is a small class for Tutor and a test program which follows it which illustrate all that has been told till now.

public class Tutor {

   Student s1, s2;

   public Tutor ( Student st1, st2 ) {
      s1 = st1;
      s2 =st2;
   }
}

public class TutorTest {

   public static void main ( String args[] ) {
      Student student1 = new Student ( "Gautham", 3 );
      Student student2 = new Student ( "Sai", 4, 98, 100, 96);
      Tutor t = new Tutor (s1,s2);
      t.s1.printDetails();
      t.s2.printDetails();
   }
}

Run the above program and try to understand the output.

There are many more possibilities that we can try here. One such possibility is to check which of the two Students of a particular Tutor is performing better by considering his average. For this we can provide a compareStudents() method within the Tutor class itself in the following way. We have used the decision making statement if- else that has been introduced earlier.

public void compareStudents() {
   if ( s1.getAverage() >= s2.getAverage() ) {
      System.out.println("s1 is better");
   } else {
      System.out.println("s2 is better");
   }

Note that this method doesn't give the correct output if both of them have the same average. We will see later on how we can do it. And apart from this we can also provide an another method comapreToTutor() which would compare a Tutor to another Tutor that would be passed as an argument based on the sum of average marks of both the students.

public void compareToTutor ( tutor t ) {
   double average1 = s1.getAverage() + s2.getAverage() ;
   double average2 = t.s1.getAverage() + t.s2.getAverage() ;
   if ( average1 >= average2) {
      System.out.println("Tutor is performing well");
   } else {
      System.out.println("Tutor is not performing well");
   }
}

Observe the computation of average1 and avergae2. Avearge1 is the average of the Tutor on which this method would be called. And average2 is the average of the Tutor that would be passed as parameter.

In the main method of a test class, we write the following code:

Tutor t1 = new Tutor ( new Student ( "Sai", 3,98,97,100), new Student ("Gautham",4,94,97,98) );
Tutor t2=new Tutor ( new Student ( "Ravi", 7, 99, 98, 100), new Student ("Ranjith", 34, 95, 97,97) );
t1.comapreToTutor(t2);

Note how the Tutor objects were created. Instead of first creating the Student objects and then passing them to the constructor of Tutor, we have written the object creation statements within the parentheses itself. As always, the arguments in the parentheses would be evaluated first and then the constructor would be called. In this case, first the two Student objects would be created and then the Tutor constructor would be called. And then t1 is compared to t2. Run the program and see down the result.

Privacy Policy