Java 102 intro to object-oriented programming in java

Java 102: Intro to Object-oriented
Programming with Java

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
• IDE’s replace the slashes with a dot as part of
convention

Hands-on Exercise
Creating Objects

Functions
• A sequence of program instructions that perform
a specific task that are packaged as a unit
• Takes zero 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.
– Takes you beyond pre-packaged libraries.
– You build the functionality you need
• Process.
– 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

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

Inheritance
• Ability to define a new class based on an existing one.
• E.g. lets 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

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

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 intro to object-oriented programming in java

More Related Content

What's hot (14)

Viewers also liked (20)

Similar to Java 102 intro to object-oriented programming in java (20)

Recently uploaded (20)

Java 102 intro to object-oriented programming in java