Scribd
Upload
137 views

Introduction To Java Programming - Constructor

Constructors are special methods used to initialize objects. They have the same name as the class and are used with the new operator. Constructors can be overloaded by having different parameters. The document provides examples of declaring default constructors without parameters, constructors with parameters, and overloaded constructors. It explains the differences between constructors and methods in terms of modifiers, return types and names.

Uploaded by

Elle Xevierre G
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
137 views

Introduction To Java Programming - Constructor

Constructors are special methods used to initialize objects. They have the same name as the class and are used with the new operator. Constructors can be overloaded by having different parameters. The document provides examples of declaring default constructors without parameters, constructors with parameters, and overloaded constructors. It explains the differences between constructors and methods in terms of modifiers, return types and names.

Uploaded by

Elle Xevierre G
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 20

Constructor

Objectives
 Able to define constructor
 Able to declare constructor
 Able to create overloading
constructor
Purpose and Function of
Constructor
 Constructors have one purpose in life: to
create an instance of a class. This can
also be called creating an object, as in:

University unikl = new University();

 The purpose of methods, by contrast, is


much more general.
A method's basic function is to execute
Java codes.
Signature differences
 Constructors and methods differ in three aspects of the
signature: modifiers, return type, and name.

 Like methods, constructors can have any of the access


modifiers: public, protected, private, or none (often
called package or friendly). Unlike methods,
constructors can take only public access modifiers.
Therefore, constructors cannot be final or static.

 The return types are very different too. Methods can


have any valid return type, or no return type, in which
case the return type is given as void. Constructors have
NO return type, not even void.
Signature differences
 Finally, in terms of the signature, methods and
constructors have different names.

 Constructors have the same name as their


class; by convention, methods use names
other than the class name.

 If the Java program follows normal


conventions, methods will start with a
lowercase letter, constructors with an
uppercase letter. Also, constructor names are
usually nouns because class names are usually
nouns; method names usually indicate actions.
Example1: Declaring
Constructor
public class University
{ Constructor name
       private String institute;
Receiving parameter
       public University (String input)
{ Store value of input into name
               institute = input;
       }
}      
public class UniversityTest
{
       public static void main(String args[ ])
{
               University unikl = new University (“miit");
        }
}
Example2: Declaring
Constructor
public class Transportation
{
private String name; Constructor name
private int year;
private String model;
No parameter
public Transportation( )
{ Store default value into data member
name = “Pesona";
year = 2007;
model = “Sedan1.4";
}

public void DisplayInfo( )


{
System.out.println("The default car name is "+name);
System.out.println("The default car year is "+year);
System.out.println("The default car model is "+model);
}
}
Example2: Declaring
Constructor
public class TransportationTest
{

public static void main(String[ ] args)


{
Create an instance called car

Transportation car = new Transportation();


car.DisplayInfo( ); Call DisplayInfo method

}
}
Output
 The following will be display if
you compile and run the
program.
Example3: Declaring
Constructor
public class Transportation
{
String name;
int year;
String model;

public Transportation (String CarName, int CarYear, String CarModel)


{
name=CarName;
year=CarYear;
model=CarModel

public void DisplayInfo( )


{
System.out.println("The default car name is "+name);
System.out.println("The default car year is "+year);
System.out.println("The default car model is "+model);
}
}
Example3: Declaring
Constructor
public class TransportationTest
{

public static void main(String[ ] args)


{

Transportation car = new Transportation(“Perdana”,2002,”DANA1.6”);


car.DisplayInfo( );

}
}
Example3: Declaring
Constructor
 The following will be displayed if
you compile and run the
program.
Check Point
 Class Bicycle has 3 data members as String id,
String ownerName and int yearBuilt.
 Create a constructor without parameter (default
constructor) that will assigned a default value of
“001”,”Malek” and 2006 when an instance of Bike1 is
created.
 Create a constructor with parameter that will pass
default value of “001”,”Malek” and 2006 when an
instance of Bike1 is created through parameter.
Create the test class too !. Compile and execute in your
virtual compiler 
Write your answer…
Overloaded Constructor
 Constructor has exactly the same name
as the defining class.

 Therefore, if you provide two or more


constructors for the same class, they
are overloaded by definition.

 Those overloaded constructors used in


the same program MUST have different
argument lists so that compiler can
differentiate them.
Example4: Overloaded
Constructor
public class Number
{ private double a;
private String b;

public Number ( ) // default constructor


{ a = 0.0;
b = “Hello”;
}

public Number ( double m, String n ) // constructor


with 2 arguments
{ a = m;
b = n;
}

}
Example4: Overloaded
Constructor
public class TestNumber
{
public static void main (String[ ] args)
{

Number myObj1 = new Number (100.0,“Welcome” );


// call constructor with arguments

Number myObj2 = new Number( ); // call default


constructor
}

} // end class TestNumber


::Check point::
public class V
{ private double a;
private double b;

public V ( )
public class TestV
{ a = 0.0; {
b = 0.0; public static void main (String[ ]
}
args)
public V ( double m, double n ) {
{ a = m; V x = new V(100.0,
b=n
} 200.0 );
x.updateValues();
public void updateValues()
{ a = a + 5;
x.display();
b = b +10; V y = new V( );
}

public void display( )


y.updateValues();
{ y. display( );
System.out.println( a + b ); }
System.out.println( b - a );
} } // end class TestV
} // end class V
What is the output for the above program
Exercise
Create a class ShortCourse. ShortCourse class has 4 private data
members, courseTitle, courseId, courseFee and courseDuration.
A public method, updatedFee() will calculate the
new fees of specific courses based on the following discount rate
shown below:

courseId Discount rate


ICT1010 25%
ICT1056 10%
Others 8%

Another public method, displayCourseDetails() will display all


information about the course.
If the new fees is greater than RM100, acknowledge the user that
they will be given a free one-week workshop.

Create your test class called ShortCourseTest. In this class, write a


main() method and call updatedFee() to calculate new fees and
display course details by calling displayCourseDetails() .

You are to produce a program using :


default constructor(coded)
constructor with arguments
Extra Reading
 http://java.sun.com/docs/books/tutori
al/java/javaOO/constructors.html

You might also like