JAVA for Beginners
System.out.println(" 4. while");
System.out.println(" 5. do-while");
System.out.println(" 6. break");
System.out.println(" 7. continue\n");
System.out.print("Choose one (q to quit): ");
Method isvalid( )
boolean isvalid(int ch) {
if(ch < '1' | ch > '7' & ch != 'q') return false;
else return true;
Class Help
class Help {
void helpon(int what) {
switch(what) {
case '1':
System.out.println("The if:\n");
System.out.println("if(condition) statement;");
System.out.println("else statement;");
break;
case '2':
System.out.println("The switch:\n");
System.out.println("switch(expression) {");
System.out.println(" case constant:");
System.out.println(" statement sequence");
Riccardo Flask 85 | P a g e
JAVA for Beginners
System.out.println(" break;");
System.out.println(" // ...");
System.out.println("}");
break;
case '3':
System.out.println("The for:\n");
System.out.print("for(init; condition;
iteration)");
System.out.println(" statement;");
break;
case '4':
System.out.println("The while:\n");
System.out.println("while(condition)
statement;");
break;
case '5':
System.out.println("The do-while:\n");
System.out.println("do {");
System.out.println(" statement;");
System.out.println("} while (condition);");
break;
case '6':
System.out.println("The break:\n");
System.out.println("break; or break label;");
break;
case '7':
System.out.println("The continue:\n");
Riccardo Flask 86 | P a g e
JAVA for Beginners
System.out.println("continue; or continue
label;");
break;
System.out.println();
void showmenu() {
System.out.println("Help on:");
System.out.println(" 1. if");
System.out.println(" 2. switch");
System.out.println(" 3. for");
System.out.println(" 4. while");
System.out.println(" 5. do-while");
System.out.println(" 6. break");
System.out.println(" 7. continue\n");
System.out.print("Choose one (q to quit): ");
boolean isvalid(int ch) {
if(ch < '1' | ch > '7' & ch != 'q') return false;
else return true;
Main Program:
class HelpClassDemo {
public static void main(String args[])
throws java.io.IOException {
char choice;
Riccardo Flask 87 | P a g e
JAVA for Beginners
Help hlpobj = new Help();
for(;;) {
do {
hlpobj.showmenu();
do {
choice = (char) System.in.read();
} while(choice == '\n' | choice == '\r');
} while( !hlpobj.isvalid(choice) );
if(choice == 'q') break;
System.out.println("\n");
hlpobj.helpon(choice);
Constructors
In previous examples when working with the vehicle class we did assign values to the class variables
by using statements like: minivan.passengers = 7;
To accomplish this task Java programmers use constructors. A constructor is created by default and
initializes all member variables to zero. However we can create our constructors and set the values
the way we want, e.g.
class MyClass {
int x;
MyClass() {
This is the constructor
x = 10;
Riccardo Flask 88 | P a g e
JAVA for Beginners
class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass();
MyClass t2 = new MyClass();
System.out.println(t1.x + " " + t2.x);
Predicted Output:
10 10
Constructor having parameters
We can edit our previous constructor to create a parameter:
MyClass(int i) {
x = i;
If we edit the main program, by changing the statements which initiate the two objects:
MyClass t1 = new MyClass(10);
MyClass t2 = new MyClass(88);
The output would now be:
10 88
The values and are first passed on to ‘i’ and then are assigned to ‘x’.
Now we can modify our vehicle class and add a constructor:
// Constructor for Vehicle class
Vehicle(int p, int f, int m) {
passengers = p;
fuelcap = f;
mpg = m;
Riccardo Flask 89 | P a g e
JAVA for Beginners
The main program would be as follows:
class VehConsDemo {
public static void main(String args[]) {
// construct complete vehicles
Vehicle minivan = new Vehicle(7, 16, 21);
Vehicle sportscar = new Vehicle(2, 14, 12);
double gallons;
int dist = 252;
gallons = minivan.fuelneeded(dist);
System.out.println("To go " + dist + " miles minivan
needs " + gallons + " gallons of fuel.");
gallons = sportscar.fuelneeded(dist);
System.out.println("To go " + dist + " miles sportscar
needs " + gallons + " gallons of fuel.");
Overloading Methods and Constructors
The term overloading refers to the act of using the same method/constructor name in a class but
different parameter declarations. Method overloading is an example of Polymorphism.
Method Overloading
// Demonstrate method overloading.
class Overload {
void ovlDemo() {
System.out.println("No parameters");
// Overload ovlDemo for one integer parameter.
void ovlDemo(int a) {
Riccardo Flask 90 | P a g e
JAVA for Beginners
System.out.println("One parameter: " + a);
// Overload ovlDemo for two integer parameters.
int ovlDemo(int a, int b) {
System.out.println("Two parameters: " + a + " " +
b);
return a + b;
// Overload ovlDemo for two double parameters.
double ovlDemo(double a, double b) {
System.out.println("Two double parameters: " +
a + " "+ b);
return a + b;
Main Program:
class OverloadDemo {
public static void main(String args[]) {
Overload ob = new Overload();
int resI;
double resD;
// call all versions of ovlDemo()
ob.ovlDemo();
System.out.println();
ob.ovlDemo(2);
System.out.println();
resI = ob.ovlDemo(4, 6);
System.out.println("Result of ob.ovlDemo(4, 6): " +
Riccardo Flask 91 | P a g e
JAVA for Beginners
resI);
System.out.println();
resD = ob.ovlDemo(1.1, 2.32);
System.out.println("Result of ob.ovlDemo(1.1, 2.32):
" + resD);
Predicted Output:
No parameters
One parameter: 2
Two parameters: 4 6
Result of ob.ovlDemo(4, 6): 10
Two double parameters: 1.1 2.32
Result of ob.ovlDemo(1.1, 2.32): 3.42
Automatic Type Conversion for Parameters of overloaded Methods
class Overload2 {
void f(int x) {
System.out.println("Inside f(int): " + x);
void f(double x) {
System.out.println("Inside f(double): " + x);
Riccardo Flask 92 | P a g e
JAVA for Beginners
Main Program:
class TypeConv {
public static void main(String args[]) {
Overload2 ob = new Overload2();
int i = 10;
double d = 10.1;
byte b = 99;
short s = 10;
float f = 11.5F;
ob.f(i); // calls ob.f(int)
ob.f(d); // calls ob.f(double)
ob.f(b); // calls ob.f(int) type conversion
ob.f(s); // calls ob.f(int) type conversion
ob.f(f); // calls ob.f(double) type conversion
Predicted Output:
Inside f(int): 10
Inside f(double): 10.1
Inside f(int): 99
Inside f(int): 10
Inside f(double): 11.5
Even though “f” had been defined with two parameters, ‘int’ and ‘double’, it is possible to pass a
different data type and automatic conversion occurs. ‘byte’ and ‘short’ are converted to ‘int’ while
‘float’ is converted to ‘double’ and the respective methods are called.
Riccardo Flask 93 | P a g e
JAVA for Beginners
Overloading Constructors
// Overloading constructors.
class MyClass {
int x;
MyClass() {
System.out.println("Inside MyClass().");
x = 0;
MyClass(int i) {
System.out.println("Inside MyClass(int).");
x = i;
MyClass(double d) {
System.out.println("Inside MyClass(double).");
x = (int) d;
MyClass(int i, int j) {
System.out.println("Inside MyClass(int, int).");
x = i * j;
Main Program:
class OverloadConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass();
MyClass t2 = new MyClass(88);
MyClass t3 = new MyClass(17.23);
Riccardo Flask 94 | P a g e
JAVA for Beginners
MyClass t4 = new MyClass(2, 4);
System.out.println("t1.x: " + t1.x);
System.out.println("t2.x: " + t2.x);
System.out.println("t3.x: " + t3.x);
System.out.println("t4.x: " + t4.x);
Predicted Output:
Inside MyClass().
Inside MyClass(int).
Inside MyClass(double).
Inside MyClass(int, int).
t1.x: 0
t2.x: 88
t3.x: 17
t4.x: 8
In Java programming, overloading constructors is a technique used to allow an object to initialize
another. This makes coding more efficient.
class Summation {
int sum;
// Construct from an integer
Summation(int num) {
sum = 0;
for(int i=1; i <= num; i++)
sum += i;
// Construct from another object (ob)
Riccardo Flask 95 | P a g e
JAVA for Beginners
Summation(Summation ob) {
sum = ob.sum;
Main Program:
class SumDemo {
public static void main(String args[]) {
Summation s1 = new Summation(5);
Summation s2 = new Summation(s1);
System.out.println("s1.sum: " + s1.sum);
System.out.println("s2.sum: " + s2.sum);
Predicted Output:
s1.sum: 15
s2.sum: 15
In the above example, when s2 is constructed, it takes the value of the summation of s1. Hence
there is no need to recompute the value.
Access Specifiers: public and private
Whenever we started a class, we always wrote ‘public’. If one writes ‘class’ only, by default it is
taken to be public.
// Public and private access.
class MyClass {
private int alpha; // private access
public int beta; // public access
int gamma; // default access (essentially public)
Riccardo Flask 96 | P a g e
