Java 102

Java 102: Intro to Object-oriented
Programming with Java

Introduction
• Your Name: Manuela Grindei
• Your day job: Software Developer @ Gamesys
• Your last holiday destination: Dublin

Java 102
• Object-oriented Programming
– Fundamentals
• Classes & Objects
• Methods & Constructors
• Encapsulation
• Inheritance
– Libraries & Clients

Java 102: Intro to Object-
oriented Programming with Java
Fundamentals

Classes
• Java is an object-oriented language
• Its constructs represent concepts from the
real world
• Each Java program has at least one class that
knows how to do certain actions or has
properties
• Classes in Java may have methods and
properties (a.k.a. attributes or fields)

Objects
• Objects are created using Classes as a
blueprint
• Each object is an instance of a Class
• Objects must be instantiated before they can
be accessed or used in a program
• Objects are instantiated using the new
keyword

Example 2: Creating Car Objects
• These two Car instances are created with the
new operator:
Car car1 = new Car();
Car car2 = new Car();
• Now the variables car1 and car2 represent
new instances of Car:
car1.color=“blue”;
car2.color=“red”;!

Encapsulation
public class Car {
private String make;
private String model;
private String color;
public void setColor(String color) {
this.color = color;
}
public String getColor() {
return this.color;
}
void startEngine() {
System.out.println("starting
engine");
}
void stopEngine(){
System.out.println("stopping
engine");
}
variables store the state of the objects that
are created from this class. Ideally these
should not be accessed directly by other
objects
getters and setters encapsulation the state
of objects. All access to object variables
should be done through this mechanism
Methods encapsulate the behavior of
objects created from this class

Packages
• Packages are used for grouping classes within
a java project
• Packages provide a way to organise code into
cohesive groups
• They are just folders on the filesystem
• IDEs replace the slashes with a dot by
convention

Hands-on Exercise
Creating Objects

Exercise: Creating Objects
• Create a new Java project named Java102
• Create a new package named exercise.carfactory
• Create a class named Car in the exercise.carfactory
package
• Add color, make and model properties to the Car class
• Create a java program named CarFactory (in same
package) that creates two instances of the class Car,
changes their colors to Blue and Pink and prints a message
to the console
• Run the class CarFactory and observe the message in the
Console

Solution: Creating Objects
package exercise.creatingobjects;
public class Car {
String make;
String model;
String color;
}
package exercise.creatingobjects;
public class CarFactory {
public static void main(String[] args) {
Car firstCar = new Car();
Car secondCar = new Car();
firstCar.color = "Blue";
secondCar.color = "Pink";
System.out.println("Just finished painting new cars");
}
}
Car.java
CarFactory.java

Functions
• A sequence of program instructions that perform
a specific task that are packaged as a unit
• Takes 0 or more input arguments
• Returns one output value
• May have side effects
• Examples:
– Scientists use mathematical functions to calculate
formulas
– Programmers use functions to build modular
programs

Methods
• Two types…
– Class Level Methods
– Object/instance level methods
• Class level methods are referred to as static methods
• Method declaration referred to as the signature
– Method name
– Parameter types
• Examples:
– Built-in static methods: Math.random(), Math.abs(),
Integer.parseInt().
– I/O libraries: System.out.print(),
– User-defined methods: main(), etc

Benefits of Methods
• Methods enable you to build a new layer of
abstraction
– Take you beyond pre-packaged libraries
– You build the functionality you need
• Process outline
– Step 1: identify a useful feature
– Step 2: implement it
– Step 3: use it (re-use it in any of your programs)

Scope
• The block of code that can refer to that named variable
e.g. A variable's scope is code following in the block
• Best practice: declare variables to limit their scope

Hands-on Exercise
Working with Methods

Exercise: Working with Methods
• What happens when you compile and run the
following code?
public class Cubes {
static int cube (int i){
int j = i * i * i;
return j;
}
int N = Integer.parseInt(args[0]);
for (int i=0 ;i<= N; i++) {
System.out.println(i + " " + cube(i));
}
}
}

Solution: Working with Methods
public class Cubes {
static int cube (int i){
int j = i * i * i;
return j;
}
int N = Integer.parseInt(args[0]);
for (int i=0 ;i<= N; i++) {
System.out.println(i + " " + cube(i));
}
}
}
% java Cubes 6
0 0
1 1
2 8
3 27
4 64
5 125
6 216

Constructors
• Constructors are special methods
• They are called only once when the class is being instantiated
Tax t = new Tax(40000, “CA”,4);
• They must have the same name as the class
• They can’t return a value and you don’t use void as a return type
public class Tax {
// class variables / fields
private double grossIncome;
private String state;
private int dependents;
// Constructor
public Tax (double grossIncome, String state, int depen){
// class variable initialization
this.grossIncome = grossIncome;
this.state = state;
this.dependents = dependents;
}
}

Method Overloading
• Method overloading means having a class with more
than one method having the same name but
different argument lists
class LoanShark{
int calcLoanPayment(int amount, int numberOfMonths){
// by default, calculate for New York state
calcLoanPayment(amount, numberOfMonths, “NY”);
}
int calcLoanPayment(int amount, int numberOfMonths, String state){
// Your code for calculating loan payments goes here
}
}

Hands-on Exercise
Method Overloading

Exercise : Method Overloading
• Create a new package named exercise.methodoverloading
• Create a BasicRateTax class with a method calcTax() that returns 20% of a fixed
base income of £1000
• Create a java program named TaxCollector that creates a new BasicRateTax object,
calls the calcTax() method and prints the output to the console
• Run the TaxCollector program and ensure it always prints 200.00 as calculated tax
• Add new calcTax() method to BasicRateTax class that takes a double grossIncome
parameter and calculates the tax as 20% of the grossIncome if it’s greater than the
base income of £1000
• Change the TaxCollector program to call the new calcTax(double grossIncome)
method and passing the gross Income value from the command line
• Run the TaxCollector program and see if the tax is correctly calculated.
• Re-run the program with different Gross Income values and check the output

Solution: Method Overloading
package exercise.methodoverloading;
public class BasicRateTax {
private static final double BASE_INCOME = 1000.00;
private static final double BASIC_TAX_RATE = 0.20;
public double calcTax (){
return BASE_INCOME * BASIC_TAX_RATE;
}
public double calcTax(double grossIncome){
if (grossIncome < BASE_INCOME){
return calcTax();
}
return grossIncome * BASIC_TAX_RATE;
}
}

Solution: Method Overloading
public class TaxCollector {
double grossIncome = Double.parseDouble(args[0]);
BasicRateTax taxCalculator = new BasicRateTax();
double tax = taxCalculator.calcTax(grossIncome);
System.out.println("Tax due is " + tax);
}
}
% java TaxCollector 2000
Tax due is 400.0
Tax due is 2000.0

Inheritance
• Ability to define a new class based on an existing one
e.g. let’s create a James Bond Car from our existing Car class

Class Inheritance
<<abstract>>
Person
Employee Contractor
extends

Method Overriding
• If a subclass has the method with the same name
and argument list, it will override (suppress) the
corresponding method of its ancestor
• Method overriding comes handy in the following
situations:
– The source code of the super class is not available, but
you still need to change its functionality
– The original version of the method is still valid in some
cases, and you want to keep it as is

Exercise: Inheritance
• Create a new package named exercise.inheritance
• Create a class named HigherRateTax in the exercise.inheritance package that
extends BasicRateTax and add an empty calcTax(double grossIncome) method
• Add the code to HigherRateTax.calcTax(double grossIncome) method to calculate
the tax as follows:
– 20% of grossIncome if up to £34,000 (hint: reuse the BasicRateTax.calcTax(double
grossIncom) method)
– 40% of grossIncome if above £34,000 but less than £150,000
– 50% of grossIncome if £150,000 or above
• Run the existing TaxCollector program with some large gross income amounts and
observe that your changes didn’t have any effect on the calculate tax. Why?
• Change the code of the TaxCollector to instantiate HigherRateTax instead of
BasicRateTax
• Run the TaxCollector program again and observe that now the new percentage is
properly applied. You are now using the overridden version of the method
calcTax().

Solution: Inheritance
package exercise.inheritance;
import exercise.methodoverloading.BasicRateTax;
public class HigherRateTax extends BasicRateTax {
public double calcTax(double grossIncome){
double tax = 0.0;
if (grossIncome <=34000.00){
tax = super.calcTax(grossIncome);
} else if (grossIncome > 34000 && grossIncome <=150000) {
tax = grossIncome * 0.40;
} else if (grossIncome > 150000){
tax = grossIncome * 0.50;
}
return tax;
}
}

Solution: Inheritance
import exercise.inheritance.HigherRateTax;
public class TaxCollector {
double grossIncome = Double.parseDouble(args[0]);
BasicRateTax taxCalculator = new HigherRateTax ();
double tax = taxCalculator.calcTax(grossIncome);
System.out.println("Tax due is " + tax);
}
}
Tax due is 20400.0
Tax due is 6400.0
Tax due is 77500.0

Classes and Objects Summary
• A class declaration names the class and encloses the class body between
braces { }
• The class name can be preceded by modifiers e.g. public, private
• The class body contains fields, methods, and constructors
• A class uses fields to contain state information and uses methods to
implement behaviour
• Constructors that initialize a new instance of a class share its name and
look like methods without a return type
• Specify a class variable or a class method by using the static keyword in
the member's declaration
• Class variables are shared by all instances of a class and can be accessed
through the class name as well as an instance reference
• You create an object from a class by using the new operator and a
constructor
• The garbage collector automatically cleans up unused objects

Java 102: Intro to Object-oriented
Programming with Java
Java Libraries

Definitions
• Library - a module whose methods are
primarily intended for use by many other
programs
• Client - a program that calls a library
• API - the contract between client and
implementation
• Implementation - a program that implements
the methods in an API

Example: Standard Random
• A library to generate pseudo-random numbers
Source: http://search.dilbert.com/comic/Tour%20Of%20Accounting

Standard Random Implementation
public class StdRandom {
//between 0 and N-1
public static int uniform (int N){
return (int)(Math.random() * N);
}
// between lo and hi
public static double uniform (double lo, double hi){
return lo + (int)(Math.random() * (hi-lo));
}
// truth with probability
public static boolean bernoulli(double p){
return Math.random() < p;
}
}

Hands-on Exercise
Using a Java Library

Exercise: Using Libraries
• Create a new package named exercise.libraryclient
• Create a class named CardDealer with an empty
deal() method that takes no arguments and returns
a String
• Implement the card dealer to use the StdRandom
library to deal playing cards randomly from an
infinite deck of cards
• Create a CardDealerTest program to test the
CardDealer class

Exercise: Using the StdRandom Library
public class CardDealer {
private static final String[] SUITES = { "D", "H", "C", "S"
};
private static final int TOTAL_CARDS_PER_SUITE = 13;
public String deal() {
// select a random suite
String suite = SUITES[StdRandom.uniform(SUITES.length)];
// select a random rank
int rank = StdRandom.uniform (TOTAL_CARDS_PER_SUITE ) +
1;
String card = rank + suite;
// return the dealt card
return card;
}
}

Testing the CardDealer Program
public class CardDealerTest {
CardDealer dealer = new CardDealer();
for (int i=0;i<5;i++){
String card = dealer.deal();
System.out.println( “ Card “ + i + “ is “ + card);
}
}
}

Java Libraries Summary
• Why use libraries?
– Makes code easier to understand
– Makes code easier to debug
– Makes code easier to maintain and improve
– Makes code easier to reuse

Homework Exercise
• Invent and program any sample application to
illustrate inheritance
• For example, think of the classes Cat and Dog,
Man and Woman, or a store inventory that
has to be discounted...

Further Reading
• OO Concepts - http://docs.oracle.com/javase/tutorial/java/concepts/index.html
• Classes and Objects – http://docs.oracle.com/javase/tutorial/java/javaOO/index.html
• Interfaces and Inheritance - http://docs.oracle.com/javase/tutorial/java/IandI/index.html
• Tools, tips and tricks for Unit Testing Java applications - http://www.junit.org

Java 102

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Java 102

Similar to Java 102 (20)

More from Manuela Grindei

More from Manuela Grindei (6)

Recently uploaded

Recently uploaded (20)

Java 102