Module 6 — Methods (Part 1)

1. Modules Approach

Suppose you want to build a program as follows:

int sum = 0;
for (int i = 1; i <= 10; i++)
    sum += i;
System.out.println("Sum from 1 to 10 is " + sum);

sum = 0;
for (int i = 20; i <= 30; i++)
    sum += i;
System.out.println("Sum from 20 to 30 is " + sum);

sum = 0;
for (int i = 35; i <= 45; i++)
    sum += i;
System.out.println("Sum from 35 to 45 is " + sum);

Defining a method will make you code more simpler:

public class SumExample {
    public static int sum(int i1, int i2) {
        int sum = 0;
        for (int i = i1; i <= i2; i++)
            sum += i;
        return sum;
    }

    public static void main(String[] args) {
        System.out.println("Sum from 1 to 10 is " + sum(1, 10));
        System.out.println("Sum from 20 to 30 is " + sum(20, 30));
        System.out.println("Sum from 35 to 45 is " + sum(35, 45));
    }
}

You build Java programs by combining new methods and classes with predefined ones available in the Java Application Programming Interface (API).

Methods help you modularize a program by separating its tasks into self-contained units.

Divide and Conquer

• It makes program development more manageable by constructing programs from small, simple pieces.
• Software reusability — using existing methods as building blocks to create new programs.

Hierarchical Relationship Between Method Calls

A method is invoked by a method call

• when the called method completes its task
• it returns control — and possibly a result — to the caller.

A boss method calls worker methods (e.g. worker1, worker2, worker3) in a hierarchical boss-method/worker-method relationship.

greet("Sara");

static void greet(String name) {
    System.out.println("Hello, " + name);
}

2. Declaring Methods

public static int methodName(int a, int b) {
    // body
}

• public static — modifier
• int — return type
• methodName — name of the method
• a, b — formal parameters

• int a, int b — list of parameters

• The method name should be a verb and start with a lowercase letter.

• If the method name has more than two words, the first name must be a verb followed by adjective or noun.
• In the multi-word method name, the first letter of each word must be in uppercase except the first word.

For example:

• Single-word method name: sum(), area()
• Multi-word method name: areaOfCircle(), stringComparision()

Types of Method

• Predefined Method
• User-defined Method

Predefined Method are the method that is already defined in the Java class libraries.

• known as the standard library method or built-in method.

public class Demo {
    public static void main(String[] args) {
        // using the max() method of Math class
        System.out.print("The maximum number is: " + Math.max(9, 7));
    }
}

User-defined Method

• The method written by the user or programmer

import java.util.Scanner;

public class EvenOdd {
    // user defined method
    public static void findEvenOdd(int num) {
        // method body
        if (num % 2 == 0)
            System.out.println(num + " is even");
        else
            System.out.println(num + " is odd");
    }

    public static void main(String[] args) {
        // creating Scanner class object
        Scanner scan = new Scanner(System.in);
        System.out.print("Enter the number: ");
        // reading value from the user
        int num = scan.nextInt();
        // method calling
        findEvenOdd(num);
    }
}

Example

public class Addition {
    public static void main(String[] args) {
        int a = 19;
        int b = 5;
        // method calling
        int c = add(a, b); // a and b are actual parameters
        System.out.println("The sum of a and b is=" + c);
    }

    // user defined method
    public static int add(int n1, int n2) { // n1 and n2 are formal parameters
        int s;
        s = n1 + n2;
        return s; // returning the sum
    }
}

Return Values

• The void keyword, used in the examples above, indicates that the method should not return a value.
• If you want the method to return a value, you can use a primitive data type (such as int, char, etc.) instead of void, and use the return keyword inside the method:

public class Main {
    static int myMethod(int x) {
        return 5 + x;
    }

    public static void main(String[] args) {
        System.out.println(myMethod(3));
    }
}
// Outputs 8 (5+3)

public String print(int x, String y) {
    return y;
}

public static ______ getSum(double a, double b)
{
return a + b;
}

double x = 2;
double y = 3;
double z = Math.pow(x, 3) + Math.pow(y, 2) + x * (2 + y);
System.out.println(z);

double x = 2;
double y = 3;
double z = Math.pow(x, 3) + Math.pow(y, 2);
System.out.println(z);

public static boolean isMultipleOf(int a, int b) {
    return b % a == 0;
}

public static void calculateArea(float height, float width) {
    System.out.println("Area of the rectangle is :" + (height * width));
    System.out.println("Area of the triangle is: "  + (height * width / 2));
}

3. Arguments and Casting

Information can be passed to methods as parameter. Parameters are specified after the method name, inside the parentheses.

You can add as many parameters as you want, just separate them with a comma.

public class Main {
    static void myMethod(String fname) {
        System.out.println(fname + " Refsnes");
    }

    public static void main(String[] args) {
        myMethod("Liam");
        myMethod("Jenny");
        myMethod("Anja");
    }
}
// Liam Refsnes
// Jenny Refsnes
// Anja Refsnes

Multiple Parameters

public class Main {
    static void myMethod(String fname, int age) {
        System.out.println(fname + " is " + age);
    }

    public static void main(String[] args) {
        myMethod("Liam", 5);
        myMethod("Jenny", 8);
        myMethod("Anja", 31);
    }
}
// Liam is 5
// Jenny is 8
// Anja is 31

pass-by-value

When Java passes a variable to a method via a parameter, the method itself receives a copy of the variable's value, not the variable itself.

public class ChangeParameters {
    public static void main(String[] args) {
        int number = 1;
        tryToChangeNumber(number);
        System.out.println(number);
    }

    public static void tryToChangeNumber(int i) {
        i = 2;
    }
}

Argument Promotion

• Coercion of arguments
• Forcing arguments to appropriate type to pass to method e.g., System.out.println( Math.sqrt( 4 ) );
• Evaluates Math.sqrt(4) Then evaluates System.out.println()
• Promotion rules
• Specify how to convert types without data loss

The following table:

Promotions allowed for primitive types.

• Suppose method square calculates the square of an integer
• Thus requires an int argument.
• To call square with a double argument named doubleValue, we would be required to write the method call as square((int) doubleValue)
• This method call explicitly casts (converts) doubleValue's value to a temporary integer for use in method square.
• Thus, if doubleValue's value is 4.5, the method receives the value 4 and returns 16, not 20.25.

public static int myMethod(int x, int y)
{
x++;
y++;
return x * y;
}

public class Test {
    public static void mult2 (int b, int a, int c)
    {
        a = a + 1;
        b = b + 2;
    }
    public static void main(String[] args)
    {
        int x = 9, y = 8;
        mult2(x, y, 2);
        System.out.print(x + "-" + y);
    }
}

public static int sumTwoNumbers(int numberOne, int numberTwo) {
    int sumNumbers = 0;
    for (int number = numberOne; number <= numberTwo; number ++)
        sumNumbers += number;
    return sumNumbers;
}

Module 7 — Methods (Part 2)

1. Java API Packages

A package is a group of related classes grouped together to promote software reuse. Use import statements to bring classes from a package into your program (e.g. import javax.swing.JApplet;).

The Java API ships with many packages. Some of the most commonly used ones:

import myLibrary.*;
public class ShowSomeClass
{
    // code for the class...
}

import java.util.ArrayList;   // a single class
import java.util.*;           // every public class in java.util

2. Scope of Declaration

The scope of a declaration is the portion of the program that can refer to the declared entity by its name. Outside that portion, the name does not exist.

Basic scope rules cover:

• Scope of a parameter declaration
• Scope of a local-variable declaration
• Scope of a label in a labeled break or continue statement
• Scope of a local-variable declaration that appears in the initialization section of a for statement's header
• Scope of a method or field of a class

Example

// Fig. 5.9: Scope.java
// Scope class demonstrates field and local variable scopes.

public class Scope
{
    // field that is accessible to all methods of this class
    private static int x = 1;

    // method main creates and initializes local variable x
    // and calls methods useLocalVariable and useField
    public static void main(String[] args)
    {
        int x = 5; // method's local variable x shadows field x
        System.out.printf("local x in main is %d%n", x);

        useLocalVariable(); // useLocalVariable has local x
        useField(); // useField uses class Scope's field x
        useLocalVariable(); // useLocalVariable reinitializes local x
        useField(); // class Scope's field x retains its value

        System.out.printf("%nlocal x in main is %d%n", x);
    }

    // create and initialize local variable x during each call
    public static void useLocalVariable()
    {
        int x = 25; // initialized each time useLocalVariable is called
        System.out.printf(
            "%nlocal x on entering method useLocalVariable is %d%n", x);
        ++x; // modifies this method's local variable x
        System.out.printf(
            "local x before exiting method useLocalVariable is %d%n", x);
    }

    // modify class Scope's field x during each call
    public static void useField()
    {
        System.out.printf(
            "%nfield x on entering method useField is %d%n", x);
        x *= 10; // modifies class Scope's field x
        System.out.printf(
            "field x before exiting method useField is %d%n", x);
    }
} // end class Scope

Output

local x in main is 5
local x on entering method useLocalVariable is 25
local x before exiting method useLocalVariable is 26
field x on entering method useField is 1
field x before exiting method useField is 10
local x on entering method useLocalVariable is 25
local x before exiting method useLocalVariable is 26
field x on entering method useField is 10
field x before exiting method useField is 100
local x in main is 5

3. Method Overloading

Method overloading lets you give several methods the same name as long as each takes a different parameter list. Java picks which version to run by matching the call's argument count and types to a signature.

What counts as "different parameters":

• Different number of parameters
• Different parameter types
• Different order of types

Example: square(int) vs square(double):

// Fig. 5.10: MethodOverload.java
// Overloaded method declarations.

public class MethodOverload
{
    // test overloaded square methods
    public static void main(String[] args)
    {
        System.out.printf("Square of integer 7 is %d%n",
            square(7));

        System.out.printf("Square of double 7.5 is %f%n", square(7.5));
    }

    // square method with int argument
    public static int square(int intValue)
    {
        System.out.printf("%nCalled square with int argument: %d%n",
            intValue);
        return intValue * intValue;
    }

    // square method with double argument
    public static double square(double doubleValue)
    {
        System.out.printf("%nCalled square with double argument: %f%n",
            doubleValue);
        return doubleValue * doubleValue;
    }
} // end class MethodOverload

Output

Called square with int argument: 7
Square of integer 7 is 49
Called square with double argument: 7.500000
Square of double 7.5 is 56.250000

Example: same name, different parameter types (int vs double):

class Adder {
    static int add(int a, int b) {
        return a + b;
    }
    static double add(double a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        System.out.println(add(11, 11));
        System.out.println(add(12.3, 12.6));
    }
}

Example: same name, different number of parameters:

class Adder {
    static int add(int a, int b) {
        return a + b;
    }
    static int add(int a, int b, int c) {
        return a + b + c;
    }
    public static void main(String[] args) {
        System.out.println(add(11, 11));
        System.out.println(add(11, 11, 11));
    }
}

Example: overloading with type promotion (int argument promotes to long):

class OverloadingCalculation1 {
    static void sum(int a, long b) {
        System.out.println(a + b);
    }
    static void sum(int a, int b, int c) {
        System.out.println(a + b + c);
    }
    public static void main(String[] args) {
        sum(20, 20); // now second int literal will be promoted to long
        sum(20, 20, 20);
    }
}

public class Test{
    public static int sum(int a){
        return a +5;}
    public static int sum(int a, int b){
        return a+10;
    }

    public static void main(String []args){
        System.out.print(" " +sum(1));
        System.out.print(" " +sum(5));
    } }

Module 8 — Arrays

1. Primitive vs. Reference type

• A primitive-type variable can hold exactly one value of its declared type at a time. For example, an int variable can store one integer at a time.
• When another value is assigned to that variable, the new value replaces the previous one.
• Programs use variables of reference types to store the addresses of objects in the computer's memory.

Scanner input = new Scanner(System.in); creates a Scanner object, then assigns to the variable input a reference to that Scanner object.

2. Creating, Initializing, and modifying arrays

Arrays

• Data structures
• Related data items of same type
• Remain same size once created
• Fixed-length entries

• Index
  • Also called subscript
  • Position number in square brackets
  • Must be positive integer or integer expression

a = 5;
b = 6;
c[a + b] += 2;

• Adds 2 to c[11]

• The name of the array is c

• c.length returns array c's length
• This array's 12 elements are referred to as c[0], c[1], c[2],...,c[11]
• The value of c[0] is -45
• The value of c[1] is 6
• The value of c[2] is 0
• sum = c[0] + c[1] + c[2];

Declaring and Creating Arrays

• Array objects occupy space in memory.
• Arrays are created with keyword new.

int[] c = new int[12];

Equivalent to:

int[] c;            // declare the array variable
c = new int[12];    // create the array; assign to array variable

Create several arrays in a single declaration:

String[] b = new String[100], x = new String[27];

Creating and Initializing an Array Example

// Fig. 6.2: InitArray.java
// Initializing the elements of an array to default values of zero.

public class InitArray {
    public static void main(String[] args) {
        // declare variable array and initialize it with an array object
        int[] array = new int[10]; // create the array object

        System.out.printf("%s%s%n", "Index", "Value"); // column headings

        // output each array element's value
        for (int counter = 0; counter < array.length; counter++)
            System.out.printf("%5d%8d%n", counter, array[counter]);
    }
} // end class InitArray

Output

Index Value
    0     0
    1     0
    2     0
    3     0
    4     0
    5     0
    6     0
    7     0
    8     0
    9     0

Using an Array Initializer

// Fig. 6.3: InitArray.java
// Initializing the elements of an array with an array initializer.

public class InitArray {
    public static void main(String[] args) {
        // initializer list specifies the initial value for each element
        int[] array = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };

        System.out.printf("%s%s%n", "Index", "Value"); // column headings

        // output each array element's value
        for (int counter = 0; counter < array.length; counter++)
            System.out.printf("%5d%8d%n", counter, array[counter]);
    }
} // end class InitArray

Output

Index Value
    0    32
    1    27
    2    64
    3    18
    4    95
    5    14
    6    90
    7    70
    8    60
    9    37

Calculating the Values to Store in an Array

// Fig. 6.4: InitArray.java
// Calculating the values to be placed into the elements of an array.

public class InitArray {
    public static void main(String[] args) {
        final int ARRAY_LENGTH = 10; // declare constant
        int[] array = new int[ARRAY_LENGTH]; // create array

        // calculate value for each array element
        for (int counter = 0; counter < array.length; counter++)
            array[counter] = 2 + 2 * counter;

        System.out.printf("%s%s%n", "Index", "Value"); // column headings

        // output each array element's value
        for (int counter = 0; counter < array.length; counter++)
            System.out.printf("%5d%8d%n", counter, array[counter]);
    }
} // end class InitArray

Output

Index Value
    0     2
    1     4
    2     6
    3     8
    4    10
    5    12
    6    14
    7    16
    8    18
    9    20

Summing the Elements of an Array

// Fig. 6.5: SumArray.java
// Computing the sum of the elements of an array.

public class SumArray {
    public static void main(String[] args) {
        int[] array = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
        int total = 0;

        // add each element's value to total
        for (int counter = 0; counter < array.length; counter++)
            total += array[counter];

        System.out.printf("Total of array elements: %d%n", total);
    }
} // end class SumArray

Output

Total of array elements: 849

Using Bar Charts to Display Array Data Graphically

// Fig. 6.6: BarChart.java
// Bar chart printing program.

public class BarChart {
    public static void main(String[] args) {
        int[] array = {0, 0, 0, 0, 0, 0, 1, 2, 4, 2, 1};

        System.out.println("Grade distribution:");

        // for each array element, output a bar of the chart
        for (int counter = 0; counter < array.length; counter++) {
            // output bar label ("00-09: ", "90-99: ", "100: ")
            if (counter == 10)
                System.out.printf("%5d: ", 100);
            else
                System.out.printf("%02d-%02d: ", counter * 10, counter * 10 + 9);

            // print bar of asterisks
            for (int stars = 0; stars < array[counter]; stars++)
                System.out.print("*");

            System.out.println();
        }
    }
} // end class BarChart

Output

Grade distribution:
00-09:
10-19:
20-29:
30-39:
40-49:
50-59:
60-69: *
70-79: **
80-89: ****
90-99: **
  100: *

Using the Elements of an Array as Counters

// Fig. 6.7: RollDie.java
// Die-rolling program using arrays instead of switch.
import java.security.SecureRandom;

public class RollDie {
    public static void main(String[] args) {
        SecureRandom randomNumbers = new SecureRandom();
        int[] frequency = new int[7]; // array of frequency counters

        // roll die 6,000,000 times; use die value as frequency index
        for (int roll = 1; roll <= 6000000; roll++)
            ++frequency[1 + randomNumbers.nextInt(6)];

        System.out.printf("%s%10s%n", "Face", "Frequency");

        // output each array element's value
        for (int face = 1; face < frequency.length; face++)
            System.out.printf("%4d%10d%n", face, frequency[face]);
    }
} // end class RollDie

Output

Face Frequency
   1    999690
   2    999512
   3   1000575
   4    999815
   5    999781
   6   1000627

int array_variable[] = new int[10];
for (int i = 0; i < 10; ++i) {
    array_variable[i] = i;
    System.out.print(array_variable[i] + " ");
    i++;
}

int []myArray = new int [5];
for(int i=0; i< myArray.length; i++)
{
    if(i%2 ==0)
        myArray[i] = i+1;
    System.out.print(" "+myArray[i]);
}

double[] arr = new double[15];

int[] x = {0, -2, 1};
int m = x[0];
for(int i=0; i<=2; i++)
    if(x[i] < m)
    {
        m = x[i];
    }
    else
        System.out.print("+ " + x[i]);
System.out.print(" " + m);

int[] odd = {1, 3, 5, 7, 9, 11};
odd[3] = 13; odd[4] = 77;
System.out.println( odd[0] + " " + odd[3] );

public class Main{
    public static void main(String[] args){
        String[] numbers = {"One", "Two", "Three"};
        System.out.println("First Number is: " + numbers[0]);
    }
}

public class Test {
    public static void main(String[] args) {
        int i;
        char[] course_chars = {'C', 'S', '3', '1', '1'};
        for (i = 5; i > 0; i--) {
            System.out.print(course_chars[--i] + " ");
        }
    }
}

public class Main{
    public static void main(String[] args){
        int[] age = {12, 4, 5, 2, 5};
        System.out.println("First Element: " + age[0]);
        System.out.println("Third Element: " + age[2]);
        System.out.println("Fifth Element: " + age[4]);
    }
}

public static void main(String[] args) {
    int arr_variable[] = new int[10];
    for (int i = 0; i < 10; ++i) {
        arr_variable[i] = i;
        System.out.print(arr_variable[i] + " ");
        i++;
    }
}

int arr[] = {0,1, 2, 3, 4, 5, 6, 7, 8,9};
int n = 6;
n = arr[arr[n] / 2];
System.out.println(arr[n] / 2);

// index of a is 0
// index of b is 1
// index of c is 2
char chars[] = {'a','b','c'};
System.out.println(chars[1]);

int[] myArray = {11,12,13,14,15};
System.out.print(myArray[2]+",");
System.out.print(myArray[3]);

int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int n = 6;
n = arr[arr[n] / 2];
System.out.println(arr[n] / 2);

public class SumOddEven {
    public static void main(String[] args) {
        int[] nums = {10, 11, 12, 13, 14, 15};
        int oddSum = 0, evenSum = 0;
        for (int n : nums) {
            if (n % 2 == 0) evenSum += n;
            else            oddSum  += n;
        }
        System.out.println("Even sum: " + evenSum);
        System.out.println("Odd sum: " + oddSum);
    }
}

import java.util.Scanner;
public class ArrayAvg {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[5];
        System.out.print("Enter all the elements: ");
        for (int i = 0; i < 5; i++) arr[i] = sc.nextInt();
        int sum = 0;
        for (int i = 0; i < 5; i++) sum += arr[i];
        System.out.println("sum : " + sum);
        double avg = (double) sum / arr.length;
        System.out.println("Average of Array Element is : " + avg);
    }
}

3. Exception Handling (Try-Catch Statement)

An exception indicates a problem that occurs while a program is executing. To handle an exception, place any code that might throw it inside a try-catch statement.

The try Statement

The try block contains the code that might throw an exception.

The catch Statement

The catch block contains the code that handles the exception if one occurs.

Try-Catch Syntax

try {
    // Block of code to try
}
catch (Exception e) {
    // Block of code to handle errors
}

Exception Example

public class Main {
    public static void main(String[] args) {
        int[] myNumbers = {1, 2, 3};
        System.out.println(myNumbers[10]); // error!
    }
}

Output

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
    at Main.main(Main.java:4)

finally statement lets you execute code, after try...catch, regardless of the result:

public class Main {
    public static void main(String[] args) {
        try {
            int[] myNumbers = {1, 2, 3};
            System.out.println(myNumbers[10]);
        }
        catch (Exception e) {
            System.out.println("Something went wrong.");
        }
        finally {
            System.out.println("The try catch is finished.");
        }
    }
}

Output

Something went wrong.
The try catch is finished.

Exception Example

public class Main {
    public static void main(String[] args) {
        try {
            int[] myNumbers = {1, 2, 3};
            System.out.println(myNumbers[10]);
        }
        catch (Exception e) {
            System.out.println("Something went wrong.");
        }
    }
}

Output

Something went wrong.

4. Enhanced for Statement

Iterates through the elements of an array without using a counter.

• thus avoiding the possibility of "stepping outside" the array

for (parameter : arrayName)
    statement

• parameter has a type and an identifier
• arrayName is the array through which to iterate.

// Fig. 6.9: EnhancedForTest.java
// Using the enhanced for statement to total integers in an array.

public class EnhancedForTest {
    public static void main(String[] args) {
        int[] array = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
        int total = 0;

        // add each element's value to total
        for (int number : array)
            total += number;

        System.out.printf("Total of array elements: %d%n", total);
    }
} // end class EnhancedForTest

Output

Total of array elements: 849

int[] a = {10, 20, 30};
for(int x: a) {
System.out.print(x + " ");
}

int[] evenNo = {2, 4, 6, 8, 10};
________________
    System.out.print(e + " ");
}

String[] fruit = {"apple", "orange", "banana"};
________________
    System.out.println(e);
}

import java.util.Scanner;
public class ArrayStats {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int nb = sc.nextInt();
        int[] tab = new int[nb];
        for (int i = 0; i < nb; i++) tab[i] = sc.nextInt();
        int sum = 0;
        for (int v : tab) sum += v;
        double avg = (double) sum / nb;
        System.out.println("Sum: " + sum);
        System.out.println("Average: " + avg);
        System.out.print("Array: ");
        for (int v : tab) System.out.print(v + " ");
    }
}

5. Passing Arrays to Methods

• To pass an array argument to a method, specify the name of the array without any brackets.
• For example to pass the array hourlyTemperatures:

double[] hourlyTemperatures = new double[24];

The method call will be:

modifyArray(hourlyTemperatures);

The method header will be:

void modifyArray(double[] b)

Example

// Fig. 6.10: PassArray.java
// Passing arrays and individual array elements to methods.

public class PassArray {
    // main creates array and calls modifyArray and modifyElement
    public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5 };

        System.out.printf(
            "Effects of passing reference to entire array:%n" +
            "The values of the original array are:%n");

        // output original array elements
        for (int value : array)
            System.out.printf(" %d", value);

        modifyArray(array); // pass array reference

        System.out.printf("%n%nThe values of the modified array are:%n");

        // output modified array elements
        for (int value : array)
            System.out.printf(" %d", value);

        System.out.printf(
            "%n%nEffects of passing array element value:%n" +
            "array[3] before modifyElement: %d%n", array[3]);

        modifyElement(array[3]); // attempt to modify array[3]

        System.out.printf(
            "array[3] after modifyElement: %d%n", array[3]);
    }

    // multiply each element of an array by 2
    public static void modifyArray(int[] array2) {
        for (int counter = 0; counter < array2.length; counter++)
            array2[counter] *= 2;
    }

    // multiply argument by 2
    public static void modifyElement(int element) {
        element *= 2;
        System.out.printf(
            "Value of element in modifyElement: %d%n", element);
    }
} // end class PassArray

Output

Effects of passing reference to entire array:
The values of the original array are:
 1 2 3 4 5

The values of the modified array are:
 2 4 6 8 10

Effects of passing array element value:
array[3] before modifyElement: 8
Value of element in modifyElement: 16
array[3] after modifyElement: 8

public class Test {
    public static void modify(int[] x) {
        x[0] = 99;
    }

    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        modify(a);
        System.out.println(a[0]);
    }
}

6. Pass-By-Value vs. Pass-By-Reference

• Two ways to pass arguments in method calls in many programming languages are
  • pass-by-value (call-by-value).
  • pass-by-reference (call-by-reference).

pass-by-value

When an argument is passed by value:

• a copy of the argument's value is passed to the called method.
• The called method works exclusively with the copy.
• Changes to the called method's copy do not affect the original variable's value in the caller.

pass-by-reference

When an argument is passed by reference:

• The called method can access the argument's value in the caller directly and modify that data, if necessary.
• It improves performance by eliminating the need to copy possibly large amounts of data.

Java does not allow you to choose pass-by-value or pass-by-reference — all arguments are passed by value.

7. Multidimensional Arrays

• Tables with rows and columns
• Two-dimensional array
• Declaring two-dimensional array b[2][2]

int b[][] = {{1, 2}, {3, 4}};

• 1 and 2 initialize b[0][0] and b[0][1]
• 3 and 4 initialize b[1][0] and b[1][1]

int b[][] = {{1, 2}, {3, 4, 5}};

• row 0 contains elements 1 and 2
• row 1 contains elements 3, 4 and 5

// Fig. 6.12: InitArray.java
// Initializing two-dimensional arrays.

public class InitArray {
    // create and output two-dimensional arrays
    public static void main(String[] args) {
        int[][] array1 = { { 1, 2, 3 },
                           { 4, 5, 6 } };
        int[][] array2 = { { 1, 2 }, { 3 }, { 4, 5, 6 } };

        System.out.println("Values in array1 by row are");
        outputArray(array1); // displays array1 by row

        System.out.printf("%nValues in array2 by row are%n");
        outputArray(array2); // displays array2 by row
    }

    // output rows and columns of a two-dimensional array
    public static void outputArray(int[][] array) {
        // loop through array's rows
        for (int row = 0; row < array.length; row++) {
            // loop through columns of current row
            for (int column = 0; column < array[row].length; column++)
                System.out.printf("%d ", array[row][column]);

            System.out.println();
        }
    }
} // end class InitArray

Output

Values in array1 by row are
1 2 3
4 5 6

Values in array2 by row are
1 2
3
4 5 6

int[][] b = { {1, 2, 3}, {3, 4}};

int[][] arr = {
    {1, 2, 3},
    {4, 5, 6}
};
int val = arr[0][2] + arr[1][2];
System.out.println(val);

int array_variable [][] = {{1,2,3},
                           {4,5,6},
                           {7,8,9}};

System.out.println(array_variable[0][0]);

Module 9 — Classes and Objects I

1. Declaring classes, instance variables, methods

Object Oriented Programming (OOP)

• Encapsulates data (attributes) and methods (behaviors)
• Objects
• Allows objects to communicate
• Well-defined interfaces

What are Classes and Objects?

Another example:

A class is a group of objects which have common properties. It is a template or blueprint from which objects are created. It is a logical entity. It can't be physical.

A class in Java can contain:

• Fields
• Methods
• Constructors
• Blocks
• Nested class and interface

An object is an instance of a class. A class is a template or blueprint from which objects are created. So, an object is the instance (result) of a class.

Object Definitions:

• An object is a real-world entity.
• An object is a runtime entity.
• The object is an entity which has state and behavior.
• The object is an instance of a class.

Instance variable in Java

• A variable which is created inside the class but outside the method is known as an instance variable.
• Instance variable doesn't get memory at compile time.
• It gets memory at runtime when an object or instance is created.
• That is why it is known as an instance variable.

Method in Java

In Java, a method is like a function which is used to expose the behavior of an object. Methods in classes represent a behavior of an object from the class.

Example

// Fig. 7.1: Account.java
// Account class that contains a name instance variable
// and methods to set and get its value.

public class Account {
    private String name; // instance variable

    // method to set the name in the object
    public void setName(String name) {
        this.name = name; // store the name
    }

    // method to retrieve the name from the object
    public String getName() {
        return name; // return value of name to caller
    }
} // end class Account

Instance Variable name

private String name; // instance variable

• Instance variables are declared inside a class declaration but outside the bodies of the class's methods.
• Access Modifiers public and private:
  • Variables or methods declared with access modifier public are accessible from outside the class in which they're declared.
  • Variables or methods declared with access modifier private are accessible only to methods of the class in which they're declared.

Instance Method setName of Class Account

public void setName(String name) {
    this.name = name; // store the name
}

• Indicates that setName receives parameter name of type String — which represents the name that will be passed to the method as an argument.
• If a method contains a local variable with the same name as an instance variable, the method's body can use the keyword this to refer to the shadowed instance variable explicitly.

AccountTest Class That Creates and Uses an Object of Class Account

// Fig. 7.2: AccountTest.java
// Creating and manipulating an Account object.
import java.util.Scanner;

public class AccountTest {
    public static void main(String[] args) {
        // create a Scanner object to obtain input from the command window
        Scanner input = new Scanner(System.in);

        // create an Account object and assign it to myAccount
        Account myAccount = new Account();

        // display initial value of name (null)
        System.out.printf("Initial name is: %s%n%n", myAccount.getName());

        // prompt for and read name
        System.out.println("Please enter the name:");
        String theName = input.nextLine(); // read a line of text
        myAccount.setName(theName); // put theName in myAccount
        System.out.println(); // outputs a blank line

        // display the name stored in object myAccount
        System.out.printf("Name in object myAccount is:%n%s%n",
            myAccount.getName());
    }
} // end class AccountTest

Output

Initial name is: null

Please enter the name:
Jane Green

Name in object myAccount is:
Jane Green

Instantiating an Object — Keyword new

// create an Account object and assign it to myAccount
Account myAccount = new Account();

• Keyword new creates a new object of the specified class — in this case, Account.
• The parentheses to the right of Account are required.

static Methods

Recall that static methods relate to a class as a whole, whereas instance methods are associated with a specific instance (object) of the class and may manipulate the instance variables of that object.

public class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }

    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.makeSound();
    }
}

public class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }

    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.makeSound();
    }
}

2. Default and Explicit Initialization for Instance Variables

• Recall that local variables are not initialized by default. Primitive-type instance variables are initialized by default.
• Instance variables of types byte, char, short, int, long, float and double are initialized to 0, and variables of type boolean are initialized to false.

You can initialize an instance variable as:

private int numberOfStudents = 10;

3. Constructors, private, public, static.

• Each class you declare can optionally provide a constructor with parameters that can be used to initialize an object of a class when the object is created.
• It has the same name as its class and is syntactically similar to a method.
• However, constructors have no explicit return type.

Example

public class MyClass {
    int num;

    MyClass() {
        num = 100;
    }
}

public class ConsDemo {
    public static void main(String args[]) {
        MyClass t1 = new MyClass();
        MyClass t2 = new MyClass();
        System.out.println(t1.num + " " + t2.num);
    }
}

Output

100 100

Parameterized Constructors

// A simple constructor.
class MyClass {
    int x;

    MyClass(int i) {
        x = i;
    }
}

public class ConsDemo {
    public static void main(String args[]) {
        MyClass t1 = new MyClass(10);
        MyClass t2 = new MyClass(20);
        System.out.println(t1.x + " " + t2.x);
    }
}

Output

10 20

• If you declare any variable as static, it is known as a static variable.
• The static variable can be used to refer to the common property of all objects.
• The static variable gets memory only once in the class area at the time of class loading.

class Student {
    int rollno;
    String name;
    String college = "ITS";
}

class Student {
    int rollno;            // instance variable
    String name;
    static String college = "ITS"; // static variable

    Student(int r, String n) {
        rollno = r;
        name = n;
    }

    void display() {
        System.out.println(rollno + " " + name + " " + college);
    }
}

public class TestStaticVariable1 {
    public static void main(String args[]) {
        Student s1 = new Student(111, "Karan");
        Student s2 = new Student(222, "Aryan");
        s1.display();
        s2.display();
    }
}

Output

111 Karan ITS
222 Aryan ITS

Program of the counter without static variable:

class Counter {
    int count = 0; // will get memory each time when the instance is created

    Counter() {
        count++; // incrementing value
        System.out.println(count);
    }

    public static void main(String args[]) {
        // Creating objects
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
    }
}

Output

1
1
1

Program of the counter with static variable:

class Counter {
    static int count = 0;

    Counter() {
        count++; // incrementing value
        System.out.println(count);
    }

    public static void main(String args[]) {
        // Creating objects
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
    }
}

Output

1
2
3

Static Method Example:

class Calculate {
    static int cube(int x) {
        return x * x * x;
    }

    public static void main(String args[]) {
        int result = Calculate.cube(5);
        System.out.println(result);
    }
}

Output

125

Public & Private Modifiers

Public Modifier

package abcpackage;

public class Addition {
    public int addTwoNumbers(int a, int b) {
        return a + b;
    }
}

package xyzpackage;
import abcpackage.*;

public class Test {
    public static void main(String args[]) {
        Addition obj = new Addition();
        System.out.println(obj.addTwoNumbers(10, 21));
    }
}

Output

31

Private Modifier

class ABC {
    private double num = 100;

    private int square(int a) {
        return a * a;
    }
}

public class Example {
    public static void main(String args[]) {
        ABC obj = new ABC();
        System.out.println(obj.num);
        System.out.println(obj.square(10));
    }
}

Output

Compile - time error

class FinalExam {
    private String Student_Name;
    private int Student_ID;
    private String College;

// first constructor
    public FinalExam() {
        System.out.println("Student 1 Informations:");
        this.Student_Name = Student_Name;
        this.Student_ID = Student_ID;
        this.College = College;
    }

// second constructor
    public FinalExam(String Student_Name, int Student_ID) {
        System.out.println("Student 2 Informations:");
        this.Student_Name = Student_Name;
        this.Student_ID = Student_ID;
    }

// third constructor
    public FinalExam(String Student_Name, int Student_ID, String College) {
        System.out.println("Student 3 Informations:");
        this.Student_Name = Student_Name;
        this.Student_ID = Student_ID;
        this.College = College;
    }

    public void setStudent_Name(String Student_Name) {
        this.Student_Name = Student_Name;
    }

    public String getStudent_Name() {
        return Student_Name;
    }

    public void setStudent_ID(int Student_ID) {
        this.Student_ID = Student_ID;
    }

    public int getStudent_ID() {
        return Student_ID;
    }

    public void setCollege(String College) {
        this.College = College;
    }

    public String getCollege() {
        return College;
    }
}

public class FinalExamTest {
    public static void main(String[] args) {
        FinalExam S1 = new FinalExam();
        System.out.println("Student 1: Name: " + S1.getStudent_Name() + ", ID: " + S1.getStudent_ID() + ", College: " + S1.getCollege());

        FinalExam S2 = new FinalExam("Sarah Ahmed", 102);
        System.out.println("Student 2: Name: " + S2.getStudent_Name() + ", ID: " + S2.getStudent_ID() + ", College: " + S2.getCollege());

        FinalExam student3 = new FinalExam("Ali Hassan", 103, "Computer Science");
        System.out.println("Student 3: Name: " + student3.getStudent_Name() + ", ID: " + student3.getStudent_ID() + ", College: " + student3.getCollege());
    }
}

public class Circle{
    double radius = 1;
    public static final double PI = 3.14;
    public static void main(String[] args){
        double volume = PI * radius * radius;
        System.out.println(volume);
    }
}

public class Account {
    public  String owner;    // accessible anywhere
    private double balance;  // accessible only inside Account
}

4. Instantiating and using objects

Each of the following statements creates an object and assigns it to a variable:

Point originOne = new Point(23, 94);
Rectangle rectOne = new Rectangle(originOne, 100, 200);
Rectangle rectTwo = new Rectangle(50, 100);

Each of these statements has three parts:

• Declaration: The code set in bold are all variable declarations that associate a variable name with an object type.
• Instantiation: The new keyword is a Java operator that creates the object.
• Initialization: The new operator is followed by a call to a constructor, which initializes the new object.

public class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }

    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.makeSound();
    }
}

class Cat { void speak() { System.out.println("Meow"); } }

5. Implementing a test class

Example 1:

class Lamp {
    // stores the value for light
    // true if light is on
    // false if light is off
    boolean isOn;

    // method to turn on the light
    void turnOn() {
        isOn = true;
        System.out.println("Light on? " + isOn);
    }

    // method to turn off the light
    void turnOff() {
        isOn = false;
        System.out.println("Light on? " + isOn);
    }
}

class Main {
    public static void main(String[] args) {
        // create objects led and halogen
        Lamp led = new Lamp();
        Lamp halogen = new Lamp();

        // turn on the light by calling method turnOn()
        led.turnOn();

        // turn off the light by calling method turnOff()
        halogen.turnOff();
    }
}

Output

Light on? true
Light on? false

Example 2:

class Account {
    int acc_no;
    String name;
    float amount;

    void insert(int a, String n, float amt) {
        acc_no = a;
        name = n;
        amount = amt;
    }

    void deposit(float amt) {
        amount = amount + amt;
        System.out.println(amt + " deposited");
    }

    void withdraw(float amt) {
        if (amount < amt) {
            System.out.println("Insufficient Balance");
        } else {
            amount = amount - amt;
            System.out.println(amt + " withdrawn");
        }
    }

    // method to check the balance of the account
    void checkBalance() {
        System.out.println("Balance is: " + amount);
    }

    // method to display the values of an object
    void display() {
        System.out.println(acc_no + " " + name + " " + amount);
    }
}

class TestAccount {
    public static void main(String[] args) {
        Account a1 = new Account();
        a1.insert(832345, "Ankit", 1000);
        a1.display();
        a1.checkBalance();
        a1.deposit(40000);
        a1.checkBalance();
        a1.withdraw(15000);
        a1.checkBalance();
    }
}

Output

832345 Ankit 1000.0
Balance is: 1000.0
40000.0 deposited
Balance is: 41000.0
15000.0 withdrawn
Balance is: 26000.0

public class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }

    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        myAnimal.makeSound();
    }
}

public class Car {
    String brand;
    int year;
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }
    public void displayDetails() {
        System.out.println("Brand: " + brand + ", Year: " + year);
    }
    public static void main(String[] args) {
        Car c = new Car("Toyota", 2024);
        c.displayDetails();
    }
}

class demo {
    int a, b, c;
    demo () {
        a = 10; b = 20; c = 30;
    }
    public void print() {
        System.out.println ("a= " + a + " b = " + b + "c = " + c);
    }
}
public class Test {
    public static void main(String[] args) {
        demo obj1 = new demo();
        obj1.a += 1;
        obj1.b += 1;
        System.out.println ("values of obj1: ");
        obj1.print();
    }
}

6. Additional Practice

Module 10 — Classes and Objects II

1. `this` Reference

The problem if we don't use this keyword by the example given below:

class Student {
    int rollno;
    String name;
    float fee;

    Student(int rollno, String name, float fee) {
        rollno = rollno;
        name = name;
        fee = fee;
    }

    void display() {
        System.out.println(rollno + " " + name + " " + fee);
    }
}

class TestThis1 {
    public static void main(String args[]) {
        Student s1 = new Student(111, "ankit", 5000f);
        Student s2 = new Student(112, "sumit", 6000f);
        s1.display();
        s2.display();
    }
}

Output

0 null 0.0
0 null 0.0

The solution using this keyword:

class Student {
    int rollno;
    String name;
    float fee;

    Student(int rollno, String name, float fee) {
        this.rollno = rollno;
        this.name = name;
        this.fee = fee;
    }

    void display() {
        System.out.println(rollno + " " + name + " " + fee);
    }
}

class TestThis1 {
    public static void main(String args[]) {
        Student s1 = new Student(111, "ankit", 5000f);
        Student s2 = new Student(112, "sumit", 6000f);
        s1.display();
        s2.display();
    }
}

Output

111 ankit 5000.0
112 sumit 6000.0

this(): to invoke current class constructor

class A {
    A() {
        System.out.println("hello a");
    }

    A(int x) {
        this();
        System.out.println(x);
    }
}

class TestThis5 {
    public static void main(String args[]) {
        A a = new A(10);
    }
}

Output

hello a
10

Example

// Fig. 8.4: ThisTest.java
// this used implicitly and explicitly to refer to members of an object.

public class ThisTest {
    public static void main(String[] args) {
        SimpleTime time = new SimpleTime(15, 30, 19);
        System.out.println(time.buildString());
    }
} // end class ThisTest

// class SimpleTime demonstrates the "this" reference
class SimpleTime {
    private int hour;   // 0-23
    private int minute; // 0-59
    private int second; // 0-59

    // if the constructor uses parameter names identical to
    // instance variable names the "this" reference is
    // required to distinguish between the names
    public SimpleTime(int hour, int minute, int second) {
        this.hour = hour;     // set "this" object's hour
        this.minute = minute; // set "this" object's minute
        this.second = second; // set "this" object's second
    }

    // use explicit and implicit "this" to call toUniversalString
    public String buildString() {
        return String.format("%24s: %s%n%24s: %s",
            "this.toUniversalString()", this.toUniversalString(),
            "toUniversalString()", toUniversalString());
    }

    // convert to String in universal-time format (HH:MM:SS)
    public String toUniversalString() {
        // "this" is not required here to access instance variables,
        // because method does not have local variables with same
        // names as instance variables
        return String.format("%02d:%02d:%02d",
            this.hour, this.minute, this.second);
    }
} // end class SimpleTime

Output

this.toUniversalString(): 15:30:19
     toUniversalString(): 15:30:19

2. Overloaded Constructors

• Java Constructor overloading is a technique in which a class can have any number of constructors that differ in parameter list.
• The compiler differentiates these constructors by taking into account the number of parameters in the list and their type.

Example of valid constructors for class Account:

Account(int a);
Account(int a, int b);
Account(String a, int b);

class Demo {
    int value1;
    int value2;

    Demo() {
        value1 = 10;
        value2 = 20;
        System.out.println("Inside 1st Constructor");
    }

    Demo(int a) {
        value1 = a;
        System.out.println("Inside 2nd Constructor");
    }

    Demo(int a, int b) {
        value1 = a;
        value2 = b;
        System.out.println("Inside 3rd Constructor");
    }

    public void display() {
        System.out.println("Value1 === " + value1);
        System.out.println("Value2 === " + value2);
    }

    public static void main(String args[]) {
        Demo d1 = new Demo();
        Demo d2 = new Demo(30);
        Demo d3 = new Demo(30, 40);
        d1.display();
        d2.display();
        d3.display();
    }
}

Output

Inside 1st Constructor
Inside 2nd Constructor
Inside 3rd Constructor
Value1 === 10
Value2 === 20
Value1 === 30
Value2 === 0
Value1 === 30
Value2 === 40

Time Class Case Study — check the full case study in Chapter 8, pages from 316 to 322.

class ClassConst{
    ClassConst () {
        System.out.print("hello b ");
    }
    ClassConst (String x) {
        this();
        System.out.print("hello a ");
    }
}
public class Test {
    public static void main(String args[]) {
        ClassConst a = new ClassConst ("hello c");
    }
}

class Demo {
    int value1;
    int value2;

    Demo() {
        value1 = 1;
        value2 = 2;
        System.out.println("Inside 1st Constructor");
    }

    Demo(int a) {
        value1 = a;
        System.out.println("Inside 2nd Constructor");
    }

    Demo(int a, int b) {
        value1 = a;
        value2 = b;
        System.out.println("Inside 3rd Constructor");
    }

    public void display() {
        System.out.println("Value1 === " + value1);
        System.out.println("Value2 === " + value2);
    }

    public static void main(String args[]) {
        Demo d1 = new Demo();
        Demo d2 = new Demo(3);
        Demo d3 = new Demo(3, 4);
        d1.display();
        d2.display();
        d3.display();
    }
}

Inside 1st Constructor
Inside 2nd Constructor
Inside 3rd Constructor
Value1 === 1
Value2 === 2
Value1 === 3
Value2 === 0
Value1 === 3
Value2 === 4

3. Default and No-Argument Constructors

• Every class must have at least one constructor.
• If you do not provide any in a class's declaration, the compiler creates a default constructor that takes no arguments when it's invoked.
• The default constructor initializes the instance variables to the initial values specified in their declarations or to their default values.
• If we do not create any constructor, the Java compiler automatically create a no-arg constructor during the execution of the program.
• This constructor is called default constructor.

4. Composition

• A class can have references to objects of other classes as members.
• This is called composition and is sometimes referred to as a has-a relationship.
• Example:
• An AlarmClock object needs to know the current time and the time when it's supposed to sound its alarm.
• It's reasonable to include two references to Time objects in an AlarmClock object.
• A car has-a steering wheel, a break pedal and an accelerator pedal.

Example — Class Date:

// Fig. 8.7: Date.java
// Date class declaration.

public class Date {
    private int month; // 1-12
    private int day;   // 1-31 based on month
    private int year;  // any year

    private static final int[] daysPerMonth =
        { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    // constructor: confirm proper value for month and day given the year
    public Date(int month, int day, int year) {
        // check if month in range
        if (month <= 0 || month > 12)
            throw new IllegalArgumentException(
                "month (" + month + ") must be 1-12");

        // check if day in range for month
        if (day <= 0 ||
            (day > daysPerMonth[month] && !(month == 2 && day == 29)))
            throw new IllegalArgumentException("day (" + day +
                ") out-of-range for the specified month and year");

        // check for leap year if month is 2 and day is 29
        if (month == 2 && day == 29 && !(year % 400 == 0 ||
            (year % 4 == 0 && year % 100 != 0)))
            throw new IllegalArgumentException("day (" + day +
                ") out-of-range for the specified month and year");

        this.month = month;
        this.day = day;
        this.year = year;

        System.out.printf(
            "Date object constructor for date %s%n", this);
    }

    // return a String of the form month/day/year
    public String toString() {
        return String.format("%d/%d/%d", month, day, year);
    }
} // end class Date

Class Employee

// Fig. 8.8: Employee.java
// Employee class with references to other objects.

public class Employee {
    private String firstName;
    private String lastName;
    private Date birthDate;
    private Date hireDate;

    // constructor to initialize name, birth date and hire date
    public Employee(String firstName, String lastName, Date birthDate, Date hireDate) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.birthDate = birthDate;
        this.hireDate = hireDate;
    }

    // convert Employee to String format
    public String toString() {
        return String.format("%s, %s Hired: %s Birthday: %s",
            lastName, firstName, hireDate, birthDate);
    }
} // end class Employee

Class EmployeeTest

// Fig. 8.9: EmployeeTest.java
// Composition demonstration.

public class EmployeeTest {
    public static void main(String[] args) {
        Date birth = new Date(7, 24, 1949);
        Date hire = new Date(3, 12, 1988);

        Employee employee = new Employee("Bob", "Blue", birth, hire);
        System.out.println(employee);
    }
} // end class EmployeeTest

Output

Date object constructor for date 7/24/1949
Date object constructor for date 3/12/1988
Blue, Bob Hired: 3/12/1988 Birthday: 7/24/1949

5. `enum` Types

It is a special class which defines a set of constants represented as unique identifiers.

enum Level {
    LOW,
    MEDIUM,
    HIGH
}

Level myVar = Level.MEDIUM;

Example

class EnumExample1 {
    // defining the enum inside the class
    public enum Season { WINTER, SPRING, SUMMER, FALL }

    // main method
    public static void main(String[] args) {
        // traversing the enum
        for (Season s : Season.values())
            System.out.println(s);
    }
}

Output

WINTER
SPRING
SUMMER
FALL

Example

class EnumExample1 {
    // defining enum within class
    public enum Season { WINTER, SPRING, SUMMER, FALL }

    // creating the main method
    public static void main(String[] args) {
        // printing all enum
        for (Season s : Season.values()) {
            System.out.println(s);
        }
        System.out.println("Value of WINTER is: " + Season.valueOf("WINTER"));
        System.out.println("Index of WINTER is: " + Season.valueOf("WINTER").ordinal());
        System.out.println("Index of SUMMER is: " + Season.valueOf("SUMMER").ordinal());
    }
}

Output

WINTER
SPRING
SUMMER
FALL
Value of WINTER is: WINTER
Index of WINTER is: 0
Index of SUMMER is: 2

6. Garbage Collection

• Object uses system resources, such as memory.
• We need a disciplined way to give resources back to the system when they're no longer needed.

Garbage collection is the process that:

• Returns memory to system.
• Java performs this automatically.
• Object marked for garbage collection if no references to object.

Finalizer method:

• Returns resources to system.
• Java provides method finalize.
• Defined in java.lang.Object.
• Receives no parameters.
• Returns void.

7. `static` Class Members & `static` import

• static keyword
• static class variable
• Class-wide information
• All class objects share same data
• Access to a class's public static members
• Qualify the member name with the class name and a dot.

Example

// Fig. 8.12: Employee.java
// static variable used to maintain a count of the number of
// Employee objects in memory.

public class Employee {
    private static int count = 0; // number of Employees created
    private String firstName;
    private String lastName;

    // initialize Employee, add 1 to static count and
    // output String indicating that constructor was called
    public Employee(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
        ++count; // increment static count of employees
        System.out.printf("Employee constructor: %s %s; count = %d%n",
            firstName, lastName, count);
    }

    // get first name
    public String getFirstName() {
        return firstName;
    }

    // get last name
    public String getLastName() {
        return lastName;
    }

    // static method to get static count value
    public static int getCount() {
        return count;
    }
} // end class Employee

Example

// Fig. 8.13: EmployeeTest.java
// static member demonstration.

public class EmployeeTest {
    public static void main(String[] args) {
        // show that count is 0 before creating Employees
        System.out.printf("Employees before instantiation: %d%n", Employee.getCount());

        // create two Employees; count should be 2
        Employee e1 = new Employee("Susan", "Baker");
        Employee e2 = new Employee("Bob", "Blue");

        // show that count is 2 after creating two Employees
        System.out.printf("%nEmployees after instantiation:%n");
        System.out.printf("via e1.getCount(): %d%n", e1.getCount());
        System.out.printf("via e2.getCount(): %d%n", e2.getCount());
        System.out.printf("via Employee.getCount(): %d%n", Employee.getCount());

        // get names of Employees
        System.out.printf("%nEmployee 1: %s %s%nEmployee 2: %s %s%n",
            e1.getFirstName(), e1.getLastName(),
            e2.getFirstName(), e2.getLastName());
    }
} // end class EmployeeTest

Output

Employees before instantiation: 0
Employee constructor: Susan Baker; count = 1
Employee constructor: Bob Blue; count = 2

Employees after instantiation:
via e1.getCount(): 2
via e2.getCount(): 2
via Employee.getCount(): 2

Employee 1: Susan Baker
Employee 2: Bob Blue

• A static import declaration enables you to import the static members of a class or interface so you can access them via their unqualified names in your class.
• That is, the class name and a dot (.) are not required when using an imported static member.
• A static import declaration has two forms:
• One that imports a particular static member: import static packageName.ClassName.staticMemberName;
• One that imports all static members of a class: import static packageName.ClassName.*;

Example

// Fig. 8.14: StaticImportTest.java
// Static import of Math class methods.
import static java.lang.Math.*;

public class StaticImportTest {
    public static void main(String[] args) {
        System.out.printf("sqrt(900.0) = %.1f%n", sqrt(900.0));
        System.out.printf("ceil(-9.8) = %.1f%n", ceil(-9.8));
        System.out.printf("E = %f%n", E);
        System.out.printf("PI = %f%n", PI);
    }
} // end class StaticImportTest

Output

sqrt(900.0) = 30.0
ceil(-9.8) = -9.0
E = 2.718282
PI = 3.141593

8. `final` Instance Variables

• final keyword
• Indicates that variable is not modifiable.
• Any attempt to modify final variable results in error. private final int INCREMENT = 5;
• Declares variable INCREMENT as a constant.
• Enforces principle of least privilege.

Example

class Bike9 {
    final int speedlimit = 90; // final variable

    void run() {
        speedlimit = 400;
    }

    public static void main(String args[]) {
        Bike9 obj = new Bike9();
        obj.run();
    }
} // end of class

Output

Compile Time Error

class Test {
    private static final int x = 10;
    public static void main (String [] args) {
        System.out.print(x + "*");
        {
            x++;
        }
    }
}

9. Creating packages

Package is a:

• Group of related classes and interfaces.
• Helps manage complexity of application components.
• Facilitates software reuse.
• Provides convention for unique class names.

Popular package-naming convention:

• Reverse Internet domain name.
• e.g., com.deitel

Create Package pack

package pack;

public class A {
    public void msg() {
        System.out.println("Hello");
    }
}

Create Package mypack

package mypack;
import pack.*;

class B {
    public static void main(String args[]) {
        A obj = new A();
        obj.msg();
    }
}

Output

Hello

10. Additional Practice — `FinalExam` Class

Read this program carefully and answer the questions below. It is a worked example of constructor overloading combined with this and getter/setter encapsulation.

class FinalExam {
    private String Student_Name;
    private int Student_ID;
    private String College;

    // first constructor (no-arg)
    public FinalExam() {
        System.out.println("Student 1 Informations:");
        this.Student_Name = Student_Name;
        this.Student_ID = Student_ID;
        this.College = College;
    }

    // second constructor (2 args)
    public FinalExam(String Student_Name, int Student_ID) {
        System.out.println("Student 2 Informations:");
        this.Student_Name = Student_Name;
        this.Student_ID = Student_ID;
    }

    // third constructor (3 args)
    public FinalExam(String Student_Name, int Student_ID, String College) {
        System.out.println("Student 3 Informations:");
        this.Student_Name = Student_Name;
        this.Student_ID = Student_ID;
        this.College = College;
    }

    public void setStudent_Name(String Student_Name) { this.Student_Name = Student_Name; }
    public String getStudent_Name() { return Student_Name; }
    public void setStudent_ID(int Student_ID) { this.Student_ID = Student_ID; }
    public int getStudent_ID() { return Student_ID; }
    public void setCollege(String College) { this.College = College; }
    public String getCollege() { return College; }
}

public class FinalExamTest {
    public static void main(String[] args) {
        FinalExam S1 = new FinalExam();
        System.out.println("Student 1: Name: " + S1.getStudent_Name() + ", ID: " + S1.getStudent_ID() + ", College: " + S1.getCollege());

        FinalExam S2 = new FinalExam("Sarah Ahmed", 102);
        System.out.println("Student 2: Name: " + S2.getStudent_Name() + ", ID: " + S2.getStudent_ID() + ", College: " + S2.getCollege());

        FinalExam student3 = new FinalExam("Ali Hassan", 103, "Computer Science");
        System.out.println("Student 3: Name: " + student3.getStudent_Name() + ", ID: " + student3.getStudent_ID() + ", College: " + student3.getCollege());
    }
}

Student 1 Informations:
Student 1: Name: null, ID: 0, College: null
Student 2 Informations:
Student 2: Name: Sarah Ahmed, ID: 102, College: null
Student 3 Informations:
Student 3: Name: Ali Hassan, ID: 103, College: Computer Science

Module 11 — Inheritance and Polymorphism

1. Super classes and Subclasses

Inheritance

• It is a mechanism in which one object acquires all the properties and behaviors of a parent object.
• Inheritance represents the IS-A relationship which is also known as a parent-child relationship.

Features:

• Software reusability
• Create new class from existing class
• Absorb existing class's data and behaviors
• Enhance with new capabilities

Terms used in Inheritance

• Class: A class is a group of objects which have common properties. It is a template or blueprint from which objects are created.
• Sub Class/Child Class: Subclass is a class which inherits the other class. It is also called a derived class, extended class, or child class.
• Super Class/Parent Class: Superclass is the class from where a subclass inherits the features. It is also called a base class or a parent class.

• Reusability: As the name specifies, reusability is a mechanism which facilitates you to reuse the fields and methods of the existing class when you create a new class. You can use the same fields and methods already defined in the previous class.

• Subclass extends superclass (referred as base class)

• Subclass (referred as derived class)
• More specialized group of objects
• Behaviors inherited from superclass
• Can customize
• Add its own fields and methods
• Additional behaviors
• The subclass exhibits the behaviors of its superclass and can modify those behaviors

Class hierarchy

• Direct superclass
• Inherited explicitly (one level up hierarchy)
• Indirect superclass
• Inherited two or more levels up hierarchy

Single inheritance

• Inherits from one superclass

Multiple inheritance

• Inherits from multiple superclasses
• Java does not support multiple inheritance

Types of inheritance in java

1. Single (ClassB inherits from ClassA)
2. Multilevel (ClassC inherits from ClassB, which inherits from ClassA)
3. Hierarchical (ClassB and ClassC both inherit from ClassA)

is-a relationship and the has-a relationship

In an is-a relationship:

• An object of a subclass can also be treated as an object of its superclass e.g., a car is a vehicle.
• Vehicle properties/behaviors also car properties/behaviors

In has-a represents:

• Composition
• An object contains as members references to other objects e.g., a car has a steering wheel
• An object of one class is an object of another class as well.

For example:

• A CarLoan is a Loan as are HomeImprovementLoans and MortgageLoans. Thus, in Java, class CarLoan can be said to inherit from class Loan.

In this context:

• Class Loan is a superclass
• Class CarLoan is a subclass
• A CarLoan is a specific type of Loan
• But it's incorrect to claim that every Loan is a CarLoan — the Loan could be any type of loan.
• Superclass typically represents larger set of objects than subclasses

Examples:

Inheritance hierarchy

• Inheritance relationships: tree-like hierarchy structure
• Each class becomes either:
  • superclass
    • Supply data/behaviors to other classes
  • subclass
    • Inherit data/behaviors from other classes

University Community Member Hierarchy

• CommunityMember
  • Employee
    • Faculty
      • Administrator
      • Teacher
    • Staff
  • Student
  • Alumnus

Shape Hierarchy

• Shape
  • TwoDimensionalShape
    • Circle
    • Square
    • Triangle
  • ThreeDimensionalShape
    • Sphere
    • Cube
    • Tetrahedron

class B
{
    void show(){}
}
class A
{
    void hide(){}
}

2. protected Members

protected access offers:

• An intermediate level of access between public and private.
• A superclass's protected members can be accessed:
• by members of that superclass
• by members of its subclasses
• by members of other classes in the same package
• Subclass access superclass member
• Keyword super and a dot (.)

class Vehicle{

    protected String brand ="Kia";
    protected String color = "White";
    protected int year = 2020;
void run()
{
    System.out.println(" Vehicle is moving");
}
}

class Car extends Vehicle{

void display(){
    System.out.println(" brand: "+brand +" color: "+color + " year: "+year);}

void stop(){
    System.out.println(" Car stopped moving");}
}

public class TestFinal{
public static void main(String args[]){

    Car c = new Car();
    c.display();
    c.run();
    c.stop();
}
}

3. Relationship Between Super classes and Subclasses

Superclass and subclass relationship

• Example: Point/circle inheritance hierarchy
• Point
• x-y coordinate pair
• Circle
• x-y coordinate pair
• Radius
• Area()

Example

class Employee {
    float salary = 40000;
}

class Programmer extends Employee {
    int bonus = 10000;

    public static void main(String args[]) {
        Programmer p = new Programmer();
        System.out.println("Programmer salary is:" + p.salary);
        System.out.println("Bonus of Programmer is:" + p.bonus);
    }
}

Output

Programmer salary is:40000.0
Bonus of programmer is:10000

Single Inheritance Example

class Animal {
    void eat() {
        System.out.println("eating...");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("barking...");
    }
}

class TestInheritance {
    public static void main(String args[]) {
        Dog d = new Dog();
        d.bark();
        d.eat();
    }
}

Output

barking...
eating...

Multilevel Inheritance Example

class Animal {
    void eat() {
        System.out.println("eating...");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("barking...");
    }
}

class BabyDog extends Dog {
    void weep() {
        System.out.println("weeping...");
    }
}

class TestInheritance2 {
    public static void main(String args[]) {
        BabyDog d = new BabyDog();
        d.weep();
        d.bark();
        d.eat();
    }
}

Output

weeping...
barking...
eating...

Hierarchical Inheritance Example

class Animal {
    void eat() {
        System.out.println("eating...");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("barking...");
    }
}

class Cat extends Animal {
    void meow() {
        System.out.println("meowing...");
    }
}

class TestInheritance3 {
    public static void main(String args[]) {
        Cat c = new Cat();
        c.meow();
        // c.bark(); // C.T.Error
        c.eat();
    }
}

Output

meowing...
eating...

The final Keyword

• If you don't want other classes to inherit from a class, use the final keyword:

final class Vehicle {
}

class Car extends Vehicle {
}

Compile error:

Main.java:9: error: cannot inherit from final Vehicle
class Main extends Vehicle {
1 error

Example for Super Keyword in Java:

class Superclass {
    int i = 20;

    void display() {
        System.out.println("Superclass display method");
    }
}

class Subclass extends Superclass {
    int i = 100;

    void display() {
        super.display();
        System.out.println("Subclass display method");
        System.out.println(" i value =" + i);
        System.out.println("superclass i value =" + super.i);
    }
}

class SuperUse {
    public static void main(String args[]) {
        Subclass obj = new Subclass();
        obj.display();
    }
}

Output

Superclass display method
Subclass display method
 i value = 100
superclass i value = 20

Example for protected members:

public class Shape {
    protected double height;
    protected double width;
    private double test;

    public void setValues(double height, double width) {
        this.height = height;
        this.width = width;
    }
}

public class Rectangle extends Shape {
    public double getArea() {
        // test = 10.2;
        // Error cannot access private variable
        return height * width; // accessing protected members
    }
}

Example for protected members (continued):

public class Triangle extends Shape {
    public double getArea() {
        return height * width / 2;
    }
}

public class TestProgram {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        Triangle triangle = new Triangle();
        rectangle.setValues(5, 4);
        triangle.setValues(5, 10);

        System.out.println("Area of rectangle : " + rectangle.getArea());
        System.out.println("Area of triangle: " + triangle.getArea());
    }
}

Output

Area of rectangle : 20.0
Area of triangle: 25.0

public void deposit (double amount)
{
    transactionCount ++;
    super.deposit (amount);
}

class Employee {
    int    employeeID;
    String name;
    double salary;
}

class Teacher extends Employee {
    double bonus;
    public Teacher(int id, String name, double salary, double bonus) {
        this.employeeID = id;
        this.name       = name;
        this.salary     = salary;
        this.bonus      = bonus;
    }
}

public class Tester {
    public static void main(String[] args) {
        Teacher instructor1 = new Teacher(101, "Ahmed", 5000, 500);
        Teacher instructor2 = new Teacher(102, "Sara",  6000, 600);
        System.out.println("instructor1 salary: " + instructor1.salary);
        System.out.println("instructor2 salary: " + instructor2.salary);
    }
}

class Person {
    String first_name;
    String last_Name;
    void printInf() {
        System.out.println("First Name is " + first_name + "last Name is " +
last_Name);
    }
}
class Student extends Person {
    double GPA;
    String department;

    Student() {
        first_name = "Ahmed ";
        last_Name = " Alghamdi ";
        GPA = 4;
        department = "Computer Science";
    }
    void printInf(){
        super.printInf();
        System.out.println(" GPA is "+ GPA + " department is "+ department);
    }
}

// Second Class
public class FinalTester {
    public static void main(String[] args) {
        Person P = new Person();
        Student s = new Student();
        P.printInf();
        s.printInf();
    }
}

First Name is nulllast Name is null
First Name is Ahmed last Name is  Alghamdi
GPA is 4.0 department is Computer Science

4. Polymorphism Examples

Polymorphism

• means "many forms", and it occurs when we have many classes that are related to each other by inheritance.
• Polymorphism uses those methods to perform different tasks. This allows us to perform a single action in different ways.
• Treat objects in same class hierarchy as if all superclass
• Abstract class
• Common functionality
• Makes programs extensible
• New classes added easily, can still be processed

In our examples

• Use abstract superclass Shape
• Defines common interface (functionality)
• Point, Circle and Cylinder inherit from Shape
• Class Employee for a natural example

Example

class Shapes {
    public void area() {
        System.out.println("The formula for area of ");
    }
}

class Triangle extends Shapes {
    public void area() {
        System.out.println("Triangle is 1/2 * base * height ");
    }
}

class Circle extends Shapes {
    public void area() {
        System.out.println("Circle is 3.14 * radius * radius ");
    }
}

class Main {
    public static void main(String[] args) {
        Shapes myShape = new Shapes();    // Create a Shapes object
        Shapes myTriangle = new Triangle(); // Create a Triangle object
        Shapes myCircle = new Circle();    // Create a Circle object

        myShape.area();
        myTriangle.area();
        myShape.area();
        myCircle.area();
    }
}

Output

The formula for area of Triangle is 1/2 * base * height
The formula for area of Circle is 3.14 * radius * radius

Polymorphism in Java can be performed by two different methods:

Method Overloading

• Defined as a process that can create multiple methods of the same name in the same class, and all the methods work in different ways.
• Method overloading occurs when there is more than one method of the same name in the class

Method Overriding

• Defined as a process when the subclass or a child class has the same method as declared in the parent class.

Method Overriding Example:

class Vehicle {
    void run() {
        System.out.println("Vehicle is moving");
    }
}

class Car2 extends Vehicle {
    void run() {
        System.out.println("car is running safely");
    }

    public static void main(String args[]) {
        Car2 obj = new Car2();
        obj.run(); // calling method
    }
}

• Overriding is done by using a reference variable of the superclass.
• Which method to be called is determined based on the object which is being referred to by the reference variable.
• This is also known as Upcasting.

class A {}
class B extends A {}

A a = new B(); // upcasting

Example

class Animal {
    void eat() {
        System.out.println("Animals Eat");
    }
}

class herbivores extends Animal {
    void eat() {
        System.out.println("Herbivores Eat Plants");
    }
}

class omnivores extends Animal {
    void eat() {
        System.out.println("Omnivores Eat Plants and meat");
    }
}

class carnivores extends Animal {
    void eat() {
        System.out.println("Carnivores Eat meat");
    }
}

class main {
    public static void main(String args[]) {
        Animal A = new Animal();
        Animal h = new herbivores(); // upcasting
        Animal o = new omnivores();  // upcasting
        Animal c = new carnivores(); // upcasting
        A.eat();
        h.eat();
        o.eat();
        c.eat();
    }
}

Output

Animals eat
Herbivores Eat Plants
Omnivores Eat Plants and meat
Carnivores Eat meat

class Animal {
void eat() { System.out.println("Animal eats"); }
}
class Cat extends Animal {
void eat() { System.out.println("Cat eats fish"); }
}
class Main {
public static void main(String[] args) {
Animal a = new Cat();
a.eat();
}
}

class Draw{
    public void Color(int x) { }
    public void Color(int x, int y) { }
    public void Color(int x, int y, int z) { }
}

class MathCalculation{
    public void Add(int x) { }
    public void Add(int x, double y) {}
    public void Add(int x, int y, int z) {}
}

class A {
    void print() {System.out.println(" class A");}
}
class B extends A {
    void print(int x) { System.out.println(" class B ");}
}
class C extends A {
    void print(double y) {System.out.println("class C ");}
}
class Main {
    public static void main(String[] args) {
        B obj = new B();
        obj.print();
        obj.print(10.4);
        obj.print(5);
    }
}

class Father {
    int age = 55;
    void display_Name() {
        System.out.println("Ahmed, Age: "+age);
    }
}
class Son extends Father {
    int age = 18;
    void display_Name() {
        System.out.println("Omar,Age:"+age);
    }
    public static void main(String[] args) {
        Son A1 = new Son();
        A1.display_Name();
    }
}

class Mom {
    String name = "Layla";
    void my_Name(){
        System.out.println(name);
    }
}
class daughter extends Mom{
    String name = "Zainab";
    void my_Name(){
        System.out.println(name);
    }
    public static void main(String[] args) {
        daughter first = new daughter();
        System.out.println(first.name);
    }
}

class A {
    int i;
    void display() {
        System.out.println(i);
    }
}

class B extends A {
    int j;
    void display() {
        System.out.println(j);
    }
}

public class InheritanceDemo {
    public static void main(String[] args) {
        B obj = new B();
        obj.i = 1;
        obj.j = 2;
        obj.display();
    }
}

2

5. Abstract Classes and Methods

Abstract class:

• is a restricted class that cannot be used to create objects
• to access it, it must be inherited from another class.

Abstract method:

• can only be used in an abstract class, and it does not have a body.
• The body is provided by the subclass (inherited from).

Example

abstract class Animal {
    public abstract void animalSound();

    public void sleep() {
        System.out.println("Zzz");
    }
}

• If you try to execute: Animal myObj = new Animal(); // will generate an error

Example

abstract class Animal {
    public abstract void animalSound();

    public void sleep() {
        System.out.println("Zzz");
    }
}

class Cat extends Animal {
    public void animalSound() {
        System.out.println("The cat says: meow meow");
    }
}

class Main {
    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.animalSound();
        myCat.sleep();
    }
}

Output

The cat says: meow meow
Zzz

An interface:

• is a completely "abstract class" that is used to group related methods with empty bodies.
• To access the interface methods, the interface must be "implemented".
• The body of the interface method is provided by the "implement" class

Interface Example:

interface Animal {
    public void animalSound();
    public void sleep();
}

class Cat implements Animal {
    public void animalSound() {
        System.out.println("The cat says: meow meow ");
    }

    public void sleep() {
        System.out.println("Zzz");
    }
}

class Main {
    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.animalSound();
        myCat.sleep();
    }
}

Output

The cat says: meow meow
Zzz

6. Additional Practice

Module 12 — Strings and Characters

1. Fundamentals of strings and characters

Characters:

• The fundamental building blocks of Java source programs.
• A character literal is an integer value represented as a character in single quotes.
• The value of a character literal is the integer value of the character in the Unicode character set.

Class String:

• Used to represent strings in Java.

String name = "ali";
if (name == "ali")
    System.out.print("ALI ");
System.out.println("GOOD");

public static void main(String[] args) {
    String name1 = "FOX", name2 = "DOG";
    if (name1 == "FOX")
        System.out.println("FOX ");
        System.out.println("Good");
    if (name2 == "CAT") {
        System.out.println("DINO");
    }
}

2. Class String, Class Character

Class String provides constructors for initializing String objects in a variety of ways.

// Fig. 14.1: StringConstructors.java
// String class constructors.

public class StringConstructors
{
    public static void main(String[] args)
    {
        char[] charArray = { 'b', 'i', 'r', 't', 'h', ' ', 'd', 'a', 'y'};
        String s = new String("hello");

        // use String constructors
        String s1 = new String();
        String s2 = new String(s);
        String s3 = new String(charArray);
        String s4 = new String(charArray, 6, 3);

        System.out.printf(
            "s1 = %s%ns2 = %s%ns3 = %s%ns4 = %s%n", s1, s2, s3, s4);
    }
} // end class StringConstructors

Output

s1 = 
s2 = hello
s3 = birth day
s4 = day

String Methods length, charAt and getChars

// Fig. 14.2: StringMiscellaneous.java
// This application demonstrates the length, charAt and getChars
// methods of the String class.

public class StringMiscellaneous
{
    public static void main(String[] args)
    {
        String s1 = "hello there";
        char[] charArray = new char[5];

        System.out.printf("s1: %s", s1);

        // test length method
        System.out.printf("%nLength of s1: %d", s1.length());

        // loop through characters in s1 with charAt and display reversed
        System.out.printf("%nThe string reversed is: ");
        for (int count = s1.length() - 1; count >= 0; count--)
            System.out.printf("%c", s1.charAt(count));

        // copy characters from string into charArray
        s1.getChars(0, 5, charArray, 0);

        System.out.printf("%nThe character array is: ");
        for (char character : charArray)
            System.out.print(character);
        System.out.println();
    }
} // end class StringMiscellaneous

Output

s1: hello there
Length of s1: 11
The string reversed is: ereht olleh
The character array is: hello

Comparing Strings

Java String class compareTo() method compares the given string with the current string lexicographically.

1. If s1 > s2, it returns a positive number.
2. If s1 < s2, it returns a negative number.
3. If s1 == s2, it returns 0.

public class CompareToExample
{
    public static void main(String[] args)
    {
        String myStr1 = "Hello";
        String myStr2 = "Hello";

        System.out.println(myStr1.compareTo(myStr2));
        // Returns 0 because they are equal
    }
}

s1 = "hello"
s2 = "goodbye"

s1.compareTo(s2)  →  32
s2.compareTo(s1)  →  -2

public class Test {
    public static void main(String args[]) {
        System.out.println("cargo".compareTo("cathode"));
        System.out.println("car".compareTo("Car"));
        System.out.println("hello".compareTo("hello"));
    }
}

Figure 3 — Lexicographic Comparison:

The letter r comes before t.

Class Character

// Fig. 14.15: StaticCharMethods.java
// Character static methods for testing characters and converting case.
import java.util.Scanner;

public class StaticCharMethods
{
    public static void main(String[] args)
    {
        Scanner scanner = new Scanner(System.in); // create scanner
        System.out.println("Enter a character and press Enter");
        String input = scanner.next();
        char c = input.charAt(0); // get input character

        // display character info
        System.out.printf("is defined: %b%n", Character.isDefined(c));
        System.out.printf("is digit: %b%n", Character.isDigit(c));
        System.out.printf("is first character in a Java identifier: %b%n",
            Character.isJavaIdentifierStart(c));
        System.out.printf("is part of a Java identifier: %b%n",
            Character.isJavaIdentifierPart(c));
        System.out.printf("is letter: %b%n", Character.isLetter(c));
        System.out.printf("is letter or digit: %b%n", Character.isLetterOrDigit(c));
        System.out.printf("is lower case: %b%n", Character.isLowerCase(c));
        System.out.printf("is upper case: %b%n", Character.isUpperCase(c));
        System.out.printf("to upper case: %s%n", Character.toUpperCase(c));
        System.out.printf("to lower case: %s%n", Character.toLowerCase(c));
    }
} // end class StaticCharMethods

Output

Enter a character and press Enter
A
is defined: true
is digit: false
is first character in a Java identifier: true
is part of a Java identifier: true
is letter: true
is letter or digit: true
is lower case: false
is upper case: true
to upper case: A
to lower case: a

Check the book for more examples on String and Character:

• String Class Methods:
  • String Method equals
  • String Method equalsIgnoreCase
  • String Method regionMatches
  • String Methods startsWith and endsWith
  • String Method valueOf
• Locating Characters and Substrings in Strings
• Extracting Substrings from Strings
• Concatenating Strings

String Method equals

public class StringEqualsExample
{
    public static void main(String[] args)
    {
        String s1 = new String("hello");
        String s2 = "hello";
        String s3 = "Hello";

        System.out.println(s1 == "hello"); // false
        System.out.println(s1.equals("hello")); // true
        System.out.println(s2 == "hello"); // true
        System.out.println(s1.equals(s3)); // false
        System.out.println(s1.equalsIgnoreCase(s3)); // true
    }
}

String Method regionMatches

public class StringMiscellaneous
{
    public static void main(String[] args)
    {
        String s1 = "Happy Birthday";
        String s2 = "happy birthday";

        // test regionMatches (ignore case)
        System.out.println(" s3.regionMatches(0, s4, 0, 5): "
            +s1.regionMatches (0, s2, 0, 5));

        // test regionMatches (ignore case)
        System.out.println(" s3.regionMatches (true, 0, s4, 0, 5): "
            +s1.regionMatches (true, 0, s2, 0, 5));
    }
}

Output

----jGRASP exec: java StringMiscellaneous
s3.regionMatches (0, s4, 0, 5): false
s3.regionMatches (true, 0, s4, 0, 5): true
----jGRASP: operation complete.

startsWith and endsWith

public class StringMiscellaneous
{
    public static void main(String[] args)
    {
        String array[] = {"started", "starting"};
        for(String s: array)
        {
            // test method startsWith
            System.out.println("string "+ s +" starts with st? "+ s.startsWith("st"));
            // test method startsWith starting from position 2 of string
            System.out.println("string "+s+" starts with art at position 2? "+ s.startsWith("art",2));
            // test method endsWith
            System.out.println("string "+s+ " end with ed? "+ s.endsWith("ed"));
        }
    }
}

Output

----jGRASP exec: java StringMiscellaneous
string started starts with st? true
string started starts with art at position 2? true
string started end with ed? true
string starting starts with st? true
string starting starts with art at position 2? true
string starting end with ed? false

String Method valueOf (static method)

public class StringMiscellaneous
{
    public static void main(String[] args)
    {
        char array[] = {'a', 'b', 'c'};
        int x = 50;
        System.out.println(" char array: "+String.valueOf(array));
        System.out.println(" x: " +String.valueOf(x));
    }
}

Output

----jGRASP exec: java StringMiscellaneous
char array: abc
x: 50

Locating Characters

public class StringMiscellaneous
{
    public static void main(String[] args)
    {
        String letters = "abcdabcd";
        System.out.println(" c is located at " +letters.indexOf('c'));
        System.out.println(" c is located at " +letters.lastIndexOf('c'));
        System.out.println(" abc is located at " +letters.indexOf("abc"));
    }
}

Output

----jGRASP exec: java StringMiscellaneous
c is located at 2
c is located at 6
abc is located at 0

Extracting Substrings from Strings and Concatenating Strings

public class StringMiscellaneous
{
    public static void main(String[] args)
    {
        String s = "Hello World!";
        String s2 = "Happy";
        String s3 = "Birthday";
        int x = 10;

        System.out.println(" substring from index 6 to the end is "+s.substring(6));
        System.out.println(" Substring from index 1 up to, but not including 7 is "+ s.substring(1,7));
        System.out.println(" Result of s2.concat(s3) = "+ s2.concat(s3));
        System.out.println(" the value of x is "+ x);
    }
}

Output

----jGRASP exec: java StringMiscellaneous
substring from index 6 to the end is World!
Substring from index 1 up to, but not including 7 is ello W
Result of s2.concat(s3) = HappyBirthday
the value of x is 10

String value1 = "Work hard";
System.out.println(value1.length());

char array[] = {' ', 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'};
String value = new String(array, 3, 5);
System.out.println(value);