Java Quiz Revision

• An algorithm = a step-by-step process.
• A computer program = a step-by-step set of instructions for a computer.
• Every computer program is an algorithm. Algorithms have a long history in science, technology, engineering & math.
• Early computers: far less complex, smaller memories, simpler programs, usually executed only one program at a time.
• Modern computers: smaller but far more complex, can execute many programs at the same time.

• Computer scientists introduced objects and OOP to help manage the growing complexity of modern computers.
• Prof. Alan Kay is one of the fathers of OOP. He named it, with colleagues at PARC, back in 1966.
• OOP is centred on creating objects rather than procedures/functions.
• Objects are a melding of data + the procedures that manipulate that data.
• Wikipedia definition: OOP is a programming paradigm based on "objects", which are data structures that contain data (fields) and code (procedures).
• In OO programming, programs are designed by making them out of objects that interact with one another.

• An object is anything that can be represented by data.
• It can be physical or just an abstract idea:
  • airplane → physical object that can be manipulated by a computer
  • bank transaction → an object that is not physical
• To a computer, an object is simply something that can be represented by data in the computer's memory and manipulated by computer programs.

• Object-oriented programs use objects.
• An object is a thing, both tangible and intangible: Account, Vehicle, Employee…
• To create an object in a program we must first provide a definition of how it behaves and what information it maintains. That definition is a class.
• An object is called an instance of a class.

• The notation is based on the industry standard UML = Unified Modeling Language.
• Class → a rectangle with the class name inside (e.g. Account, Motorcycle).
• Object → a rectangle with the underlined object name inside (e.g. SV198).
• Object with class name → <Object Name> : <Class Name>, shows which class the object is an instance of, e.g. SV198 : BankAccount.

• To make a class or object do a task, we send a message to it.
• You can only send a message to classes/objects that understand it: they must have a matching method to handle it.
• Method defined for a class → class method. Method defined for an object → instance method.
• A value passed with a message = an argument of the message.

• An object is made of data values + methods.
• Instance data value → info specific to each individual instance. e.g. every BankAccount keeps its own current balance.
• Class data value → info shared by all instances or aggregate info about the instances.
  • minimum balance → shared by all Account objects
  • average balance of all BankAccounts → aggregate information
• There is ONE copy of a class data value for the whole class, shared by all instances.

• Inheritance = a mechanism to design two or more entities that are different but share many common features.
• Common features are defined in the superclass. Classes that inherit them are subclasses.
• superclass = ancestor · subclass = descendant
• In the diagrams the arrow (hollow triangle) points UP to the superclass.

• Like building a skyscraper, complex software needs a disciplined approach.
• Software engineering = applying a systematic and disciplined approach to the development, testing and maintenance of a program.
• Software life cycle = the sequence of stages from conception to operation of a program. It has 5 stages:

• Two popular OOP languages: Java and C++.
• Other OOP languages: Objective C, Perl, Python, JavaScript, Simula, Modula, Ada, Smalltalk.

• A Java identifier = a sequence of letters, digits, underscores (_) and dollar signs ($), with the first character a non-digit.
• Used to name a class, object, method, and others.

Customer customer;            // 1. declaration
customer = new Customer( );   // 2. creation

• Combine both into one statement: Student john = new Student(); instead of Student john; + john = new Student();

Customer customer;
customer = new Customer( );   // first object
customer = new Customer( );   // second object

• Syntax: <object>.<method>(<arguments>); e.g. account.deposit(200.0); · student.setName("john"); · car1.startEngine();
• A Java program is made of 3 components: comments, import statements, class declarations.

/* The program is
   expected to print Java */          // comment
public class Main{                    // class
  String attribute;
  public void display() {             // method
    System.out.println(attribute);}
  public static void main(String[] args) {
    Main obj = new Main();
    // obj.attribute = "Hello"; This line is commented
    obj.attribute = "Java";
    obj.display();
  }
}

import java.util.Scanner;
public class Main {
  public static void main(String[] args) {
    String S;
    Scanner in = new Scanner(System.in);
    System.out.println("Enter a string");
    S = in.nextLine();
    System.out.println("You enter a string " + S);
  }}

• Why use standard classes? Don't reinvent the wheel. If existing objects satisfy our needs, use them.
• Learning to use standard classes is the first step toward mastering OOP; learn existing classes before defining your own.

• System.out is an instance of the PrintStream class, a simple way to show results on the console window (its look depends on the Java tool you use).
• print → keeps printing from the end of the current output (same line).
• println → skips to the next line after printing its argument.

System.out.print("How do you do? ");
System.out.print("My name is ");
System.out.print("Jon Java. ");

System.out.println("How do you do? ");
System.out.println("My name is ");
System.out.println("Jon Java. ");

String name;                  // 1
name = new String("Jon Java"); // 2

Indexing: the position (index) of the first character is 0.

import java.util.*;
//import java.util.Date;
//import java.util.Scanner;
public class Main {
  public static void main(String[] args) {
    Date today;
    today = new Date( );
    System.out.println(today);
  }
}

import java.util.Date;
import java.text.SimpleDateFormat;
...
Date today = new Date( );
SimpleDateFormat sdf1, sdf2;
sdf1 = new SimpleDateFormat("MM/dd/yy");
sdf2 = new SimpleDateFormat("MMMM dd, yyyy");
String a = sdf1.format(today);
String b = sdf2.format(today);
System.out.println(a + "\n" + b);

• java.util.* imports all classes in java.util (so both Date and Scanner).
• MM = month number · MMMM = full month name · dd = day · yy / yyyy = 2- / 4-digit year.

• A Scanner object reads data from standard input System.in (the keyboard).
• First associate a Scanner with System.in, then read.

import java.util.Scanner;
public class Main {
  public static void main(String args[]) {
    String name;
    Scanner in = new Scanner(System.in);
    name = in.nextLine();
    System.out.println("Hello there, " + name);
    System.out.println("Welcome to Java");
  }
}

• Before adding x + y we must declare their data type: int x, y; or int x; int y;
• 6 numerical data types: byte, short, int, long (integers) and float, double (real numbers).
• Declare several at once: int i, j, k; · float numberOne, numberTwo; · long bigInteger; · double bigNumber;
• Initialise while declaring: int count = 10, height = 34;

long a = 323456789098765L;
System.out.println(a);

• Assignment syntax: <variable> = <expression>; e.g. sum = firstNumber + secondNumber; · avg = (one + two + three) / 3.0;

• x + 3 * y → x is added to 3*y (multiply first).
• Higher precedence is evaluated first. Same precedence → left to right (for most operators).

• Mixed expression = operands of different types. If x is float and y is int, x * y is a float.
• Promotion rules: the expression's type = the type of the operand with the highest precision.

int x = 10;
float y;
y = (float) x / 3;
System.out.println(y);

• A variable's value can change. If the value must remain the same, use a constant (a named constant).
• The reserved word final declares a constant: final double PI = 3.14159; · final int MONTH_IN_YEAR = 12;
• Naming style for constants: ALL_CAPS with underscores.

final int x = 10;
x = 20;          // not allowed
int y;
y = x / 5;
System.out.println(y);

int x = 10;
x = 20;          // fine
int y;
y = x / 5;
System.out.println(y);

int num = 15;
System.out.print(num);   //print a variable
System.out.print(" ");   //print a string
System.out.print(10);    //print a constant

• Use a DecimalFormat object (import java.text.DecimalFormat;) to format numerical output.
• new DecimalFormat("0.000") → three decimal places (rounded).
• No-import alternative: String.format("%.3f", num)

double num = 123.45789345;
DecimalFormat df = new DecimalFormat("0.000");
System.out.println(num);
System.out.print(df.format(num));

double num = 123.45789345;
String formatted = String.format("%.3f", num);
System.out.println(formatted);

final double PI = 3.14159;
double radius, area, circumference;
radius = 2.35;
area = PI * radius * radius;
circumference = 2.0 * PI * radius;
System.out.println("Given Radius: " + radius);
System.out.println("Area: " + area);
System.out.println("Circumference: " + circumference);

import java.text.*;
final double PI = 3.14159;
final String TAB = "\t";
final String NEWLINE = "\n";
DecimalFormat df = new DecimalFormat("0.000");
radius = 2.35;
...
System.out.println(
 "Given Radius:  " + TAB + df.format(radius) + NEWLINE +
 "Area:          " + TAB + df.format(area) + NEWLINE +
 "Circumference: " + TAB + df.format(circumference));

• Math is in java.lang, automatically imported. It contains class methods for common math functions, called as Math.method().
• ½ sin(x − π/√y) in Java: (1.0 / 2.0) * Math.sin( x - Math.PI / Math.sqrt(y) )

• Needed in simulations and games, e.g. rolling a die → integer between 1 and 6.
• Use the Random class from java.util. (Math.random also works but is harder to use.)
• Most of the time we want integers → the nextInt method.

import java.util.Random;
public class Main {
  public static void main(String[] args) {
    Random ran = new Random();
    int num = ran.nextInt(6);
    System.out.println(num);
  }
}

• Standard classes (String, GregorianCalendar, JFrame…) won't meet all our needs; we must define classes customised for our applications.
• It's the first step toward the skills needed to build large programs.
• Classes we define ourselves = programmer-defined classes.

class BicycleRegistration {
  public static void main(String[] args) {
    Bicycle bike1, bike2;
    String  owner1, owner2;
    bike1 = new Bicycle( );
    bike1.setOwnerName("Adam Smith");
    bike2 = new Bicycle( );
    bike2.setOwnerName("Ben Jones");
    owner1 = bike1.getOwnerName( );
    owner2 = bike2.getOwnerName( );
    System.out.println(owner1 + " owns a bicycle.");
    System.out.println(owner2 + " also owns a bicycle.");
  }
}

class Bicycle {
  // Data Member
  private String ownerName;
  //Constructor: Initialises the data member
  public void Bicycle( ) {
    ownerName = "Unknown";
  }
  //Returns the name of this bicycle's owner
  public String getOwnerName( ) {
    return ownerName;
  }
  //Assigns the name of this bicycle's owner
  public void setOwnerName(String name) {
    ownerName = name;
  }
}

Once the Bicycle class is defined, we can create multiple instances; each has its own copy of ownerName.

A a = new A();
for (int i = 0; i < 10; i++) {
  String keyedinname = scanner.nextLine();
  a.setname(keyedinname);
}

for (int i = 0; i < 10; i++) {
  A a = new A();
  String keyedinname = scanner.nextLine();
  a.setname(keyedinname);
}

• void → a method that does not return a value (e.g. setOwnerName).
• Value-returning method → when called, returns a value to the caller. getOwnerName() returns the value of instance variable ownerName, which was declared as String, so its return type is String.
• A value-returning method must have return <expression>;
• The expression's type must be compatible with the declared return type: if the return type is int, you can return int, short or byte.

• A constructor is a special method executed when a new instance of the class is created.
• Syntax: public <class name> ( <parameters> ) { <statements> }. <class name> = the class this constructor belongs to.
• Same name as the class · NO return type (not even void)
• Purpose: initialise data members. For Bicycle, set the owner name to a value that shows no real name is assigned yet.
• Since it runs when the instance is created, it's the most logical place to initialise data members and do other set-up tasks.

example 1: who makes the constructor?

public class Kitty{
  public static void main(String []args){
    Kitty myKitty = new Kitty( );}
}

public class Kitty{
  public Kitty(){
    //no need this constructor
  }
  public static void main(String []args){
    Kitty myKitty = new Kitty( ); }
}

example 2: constructor vs method with the same name

public class Kitty{
  public Kitty(String name){
    System.out.println("Passed Name is :" + name);
  }
  public static void main(String []args){
    Kitty myKitty = new Kitty("molly");
  }
}

public class Kitty{
  String name;
  public void Kitty(){
    System.out.println("Passed Name is :" + name);
  }
  public static void main(String []args){
    Kitty myKitty = new Kitty( );
    myKitty.name = "molly";
    myKitty.Kitty();
  }
}

class SecondMain {
  public static void main(String[] args) {
    Bicycle bike;
    Account acct;
    String  myName = "Jon Java";
    bike = new Bicycle( );
    bike.setOwnerName(myName);
    acct = new Account( );
    acct.setOwnerName(myName);
    acct.setInitialBalance(250.00);
    acct.add(25.00);
    acct.deduct(50);
    System.out.println(bike.getOwnerName() + " owns a bicycle and");
    System.out.println("has $ " + acct.getCurrentBalance() +
                       " left in the bank");
  }
}

class Account {
  private String ownerName;
  private double balance;
  public Account( ) {
    ownerName = "Unassigned";
    balance = 0.0;
  }
  public void add(double amt) {
    balance = balance + amt; }
  public void deduct(double amt) {
    balance = balance - amt; }
  public double getCurrentBalance( ) {
    return balance; }
  public String getOwnerName( ) {
    return ownerName; }
  public void setInitialBalance(double bal) {
    balance = bal; }
  public void setOwnerName(String name) {
    ownerName = name; }
}

250.00 + 25.00 − 50 = 225.0

class Demo {
  public void compute(int i, int j, double x) {
    double result = i + j + x;
    System.out.println("Computation result: " + result);
  }
}
class Account {
  private double balance = 0.0;
  public void add(double amt) {
    balance = balance + amt;
    System.out.println("Current Balance: " + balance);
  }
}
public class Main {
  public static void main(String[] args) {
    Account acct = new Account();
    acct.add(400);
    Demo demo = new Demo();
    int i = 5;
    int k = 14;
    demo.compute(i, k, 20);
  }
}

• Argument = a value we pass to a method (caller side), e.g. acct.add(400); → 400 is the argument.
• Parameter = a placeholder in the called method that holds the passed value, e.g. add(double amt) → amt is the parameter.

• public and private set the accessibility of data members and methods.
• private → client classes cannot access it. public → client classes can.
• Declaring a class's internal details private and hiding them from clients = information hiding.

Service obj = new Service();
obj.memberOne = 10;   // ✓ public
obj.memberTwo = 20;   // ✗ private
obj.doOne();          // ✓ public
obj.doTwo();          // ✗ private

class Service {
  public  int memberOne;
  private int memberTwo;
  public void doOne() { … }
  private void doTwo() { … }
}

• Access modifiers help implement the encapsulation principle of OOP.
• Java has 4 access modifiers: public, protected, default (package-private), private.
• Other (non-access) modifiers: static, final, abstract.

import java.util.Scanner;
class Carpeting {
  //Attribute (default access)
  int length;
  int width;
  float price;
  //Method
  public void calculatePrice() {
    System.out.println("The carpet price is :RM"
      + length * width * price);
  }
  // Main Method
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    Carpeting carpet = new Carpeting();
    System.out.println("Enter the room length (ft.):");
    carpet.length = in.nextInt();
    System.out.println("Enter the room width (ft.) :");
    carpet.width = in.nextInt();
    System.out.println("Enter the carpet price per sq. ft. :");
    carpet.price = in.nextFloat();
    carpet.calculatePrice();
  }
}

import java.util.Scanner;
class Carpeting {
  int length;
  int width;
  float price;
  public void calculatePrice() {
    System.out.println("The carpet price is :RM"
      + length * width * price);
  }
}
public class A {
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    Carpeting carpet = new Carpeting();
    ...same input lines...
    carpet.calculatePrice();
  }
}

import java.util.Random;
class Die {
  private static final int MAX_NUMBER = 6;
  private static final int MIN_NUMBER = 1;
  private static final int NO_NUMBER  = 0;
  private int number;
  private Random random;
  public Dice( ) {              // should be Die( )
    random = new Random();
    number = NO_NUMBER;
  }
  //Rolls the dice
  public void roll( ) {
    number = random.nextInt(MAX_NUMBER - MIN_NUMBER + 1) + MIN_NUMBER;
  }
  //Returns the number on this dice
  public int getNumber( ) {
    return number;
  }
}

• static final → one shared copy (class constant) whose value can't change.
• nextInt(6 − 1 + 1) + 1 = nextInt(6) + 1 → 1 to 6.

// You cannot do: Shape s = new Shape(); // ERROR!
abstract class Shape {
  String color;
  public void setColor(String color) {
    this.color = color;
  }
  public static void main(String[] args) {
    System.out.println("Look at the abstract conceptual");
  }
}

• So far we called methods of another class (object). You can also call a method from another method of the same class.
• In that case, just use the method name, no dot notation.

• Any class can be a main class: just include the main method.

class Bicycle {
  //definition of the class as shown before comes here
  public static void main(String[] args) {
    Bicycle myBike;
    myBike = new Bicycle( );
    myBike.setOwnerName("Jon Java");
    System.out.println(myBike.getOwnerName() + "owns a bicycle");
  }
}

• Use this in any method or constructor to refer to the current object, the one that called the method or invoked the constructor.
• There are many uses; we focus on the first two:
  • this.variable → refers to the current class instance variable
  • this() → invokes the current class constructor

public class Circle {
  double radius;  // member variable
  public Circle(double radius) { // argument
    this.radius = radius;
    System.out.println(radius);
  }
  public static void main(String [] args){
    Circle circle = new Circle(789);
  }
}

public Circle(double radius) {
  this.radius = 500;
  System.out.println(radius);
  System.out.println(this.radius);
}
...
Circle circle = new Circle(789);

• To avoid the naming conflict, you could rename the field (e.g. Rad_radius = radius;), but radius is more meaningful, so Java gives us this to resolve the conflict.

class Student10{
  int id;
  String name;
  Student10(int id, String name){
    id = id;       //supposed to be this.id
    name = name;   //supposed to be this.name
  }
  void display(){System.out.println(id+" "+name);}
  public static void main(String args[]){
    Student10 s1 = new Student10(111,"Karan");
    Student10 s2 = new Student10(321,"Aryan");
    s1.display();
    s2.display();
  }
}

Student10(int id, String name){
  this.id = id;
  this.name = name;
}

class Student12{
  int id;
  String name;
  Student12(int i, String n){
    id = i;
    name = n;
  }
  void display(){System.out.println(id+" "+name);}
  ...
  Student12 e1 = new Student12(111,"karan");
  Student12 e2 = new Student12(222,"Aryan");
}

• Method overloading = the same method name with different implementations (versions).
• The versions must be distinguishable by their argument list: number, type, or order of arguments.
• The caller picks a version by supplying the matching arguments.

public class TestMethodOverloading {
  public int average(int n1, int n2) {              // A
    return (n1 + n2) / 2;
  }
  public double average(double n1, double n2) {     // B
    return (n1 + n2) / 2;
  }
  public int average(int n1, int n2, int n3) {      // C
    return (n1 + n2 + n3) / 3;
  }
  public static void main(String[] args) {
    TestMethodOverloading tester = new TestMethodOverloading();
    System.out.println(tester.average(1, 2));       // Use A
    System.out.println(tester.average(1.0, 2.0));   // Use B
    System.out.println(tester.average(1, 2, 3));    // Use C
    System.out.println(tester.average(1.0, 2));     // Use B
    // System.out.println(tester.average(1, 2, 3, 4)); // Compilation Error
  }
}

• Like methods, constructors can also be overloaded: several constructors, each with a different parameter list.
• package Overload; as the first line puts the class into the package Overload. That's how classes are organised into a package.

package Overload;
public class StudentData {
  private int stuID;
  private String stuName;
  private int stuAge;
  StudentData() {                       // default constructor
    stuID = 100;
    stuName = "New Student";
    stuAge = 18;
  }
  StudentData(int num1, String str, int num2) { // parameterized
    stuID = num1;
    stuName = str;
    stuAge = num2;
  }
  //Getter and setter methods
  public int getStuID() { return stuID; }
  public void setStuID(int stuID) { this.stuID = stuID; }
  public String getStuName() { return stuName; }
  public void setStuName(String stuName) { this.stuName = stuName; }
  public int getStuAge() { return stuAge; }
  public void setStuAge(int stuAge) { this.stuAge = stuAge; }
}
class TestOverloading {
  public static void main(String args[]) {
    StudentData myobj = new StudentData();            // default
    ...print name, age, ID...
    StudentData myobj2 = new StudentData(555, "Chaitanya", 25); // parameterized
    ...print name, age, ID...
  }
}

public Circle() {                   // 1st Constructor
  radius = 1.0;
  color = "red";
}
public Circle(double r) {           // 2nd Constructor
  radius = r;
  color = "red";
}
public Circle(double r, String c) { // 3rd Constructor
  radius = r;
  color = c;
}

A boolean expression gives true or false. Relational operators compare two values:

Examples from the slide: testScore < 80 · testScore * 2 >= 350 · 30 < w / (h * h) · x + y != 2 * (a + b) · 2 * Math.PI * radius <= 359.99

• Use braces { } if the then or else block has more than one statement. A block in braces is a compound statement.

if (testScore < 70)
{
    System.out.println("You did not pass");    // then block
    System.out.println("Try harder next time");
}
else
{
    System.out.println("You did pass");        // else block
    System.out.println("Keep up the good work");
}

if ( <boolean expression> ) {
    …
} else {
    …
}

if ( <boolean expression> )
{
    …
}
else
{
    …
}

Both styles do the same thing. They only differ in where the braces go; pick one and use it consistently.

• Syntax: if ( <boolean expression> ) <then block>. There is no else block.
• If the expression is false, nothing extra happens; the program just carries on.

if (testScore >= 95)                              // boolean expression
    System.out.println("You are an honor student");  // then block

• The then and else blocks can contain any valid statements, including other if statements.
• An if statement containing another if statement is a nested-if statement.

if (testScore >= 70) {
    if (studentAge < 10) {
        System.out.println("You did a great job");
    } else {
        System.out.println("You did pass");   //test score >= 70
    }                                          //and age >= 10
} else { //test score < 70
    System.out.println("You did not pass");
}

• A boolean operator takes boolean values as its operands and returns a boolean value.
• The three boolean operators: and && · or || · not !

if (temperature >= 65 && distanceToDestination < 2) {
    System.out.println("Let's walk");
} else {
    System.out.println("Let's drive");
}

Walk only when it's warm (≥ 65) and close (< 2). If either part is false, drive.

truth table: extra, not on the slides. && needs both true · || needs at least one true · ! flips the value

Reversing a condition: reverse the relational operator and switch the if and else blocks to get equivalent code.

if (age < 0) {
  println("Invalid age is entered");
} else {
  println("Valid age is entered");
}

if ( !(age < 0) ) {
  println("Valid age is entered");
} else {
  println("Invalid age is entered");
}

if (age >= 0) {
  println("Valid age is entered");
} else {
  println("Invalid age is entered");
}

Testing a range (slide title "Boolean variables"): in maths we write 80 ≤ x < 90. In Java, to test that x is within the specified lower and upper bounds:

• Primitive data types (int, double…) have only one way to compare them.
• Objects (reference data types) have two ways:
  • ① test whether two variables point to the same object → use ==
  • ② test whether two distinct objects have the same contents → use equals

• Chapter 1 introduced numerical constants (final). Another type of constant in Java is the enumerated constant.
• Used properly, enumerated constants support more reliable and robust programs.
• They're defined with the reserved word enum.

compare both structures

class Student {
  public static final int FRESHMAN  = 0;
  public static final int SOPHOMORE = 1;
  public static final int JUNIOR    = 2;
  public static final int SENIOR    = 3;
}

class Student {
  public static enum GradeLevel
    {FRESHMAN, SOPHOMORE, JUNIOR, SENIOR}
}

The enum version is shorter, and a GradeLevel can only hold one of those 4 values. An int could hold any number, like 7.

• Declaration syntax: enum <enumerated type> { <constants> }
• Examples:
  • enum Month {JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER}
  • enum Gender {MALE, FEMALE}
  • enum SkillLevel {NOVICE, INTERMEDIATE, ADVANCED, EXPERT}

enum Fruit {APPLE, ORANGE, BANANA}

Fruit f1, f2, f3;
f1 = Fruit.APPLE;
f2 = f1;
System.out.println("Favorite Fruit is " + f2);

Fruit favoriteFruit = …;
switch (favoriteFruit) {
    case Fruit.APPLE:  …
        break;
    case Fruit.ORANGE: …
        break;
    case Fruit.BANANA: …
        break;
}

Accessing an enum from outside: if the enum type in a class is declared public, other classes can use it as ClassName.EnumName.

class Faculty {
    public static enum Rank {LECTURER, ASSISTANT, ASSOCIATE, FULL}
    . . .
}
class SampleMain {
    . . .
    Faculty.Rank rank = Faculty.Rank.ASSISTANT;
    . . .
}