Scribd
Upload
48 views

Classes & Interfaces: Java's Object Oriented System

Java uses classes and interfaces to define objects and specify behavior. A class defines the data and methods of an object, while an interface specifies methods without defining them. Classes can inherit functionality from other classes and implement interfaces. Abstract classes provide partial implementations and force subclasses to implement remaining methods. This allows common behavior to be shared while allowing customization. Interfaces specify behavior without implementation, allowing classes to implement multiple interfaces.

Uploaded by

Harsha
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PDF, TXT or read online on Scribd
48 views

Classes & Interfaces: Java's Object Oriented System

Java uses classes and interfaces to define objects and specify behavior. A class defines the data and methods of an object, while an interface specifies methods without defining them. Classes can inherit functionality from other classes and implement interfaces. Abstract classes provide partial implementations and force subclasses to implement remaining methods. This allows common behavior to be shared while allowing customization. Interfaces specify behavior without implementation, allowing classes to implement multiple interfaces.

Uploaded by

Harsha
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 31

Classes &

Interfaces
Java’s Object Oriented System

Justin Mazzola Paluska


Keywords
z Class – a template of a data object
z Interface – a specification
z Instance – an instantiation of a Class or Interface
physically represented in memory

z Method – a set sequence of instructions

class members
z Instance Field – variable associated with a
particular instance.
z Static Field – variable shared among all instances
of a Class
Data Types
z There are two types in Java
z Primitive types
z Reference types

z Most of your time is spent using Reference


types.
Reference Types
z Also known as Objects
z To create an instance of a reference type,
use the new keyword in Java
z The new keyword:
1. Makes space for the new object in memory
2. Calls the constructor you specify
3. Returns a reference to the new object
Example Instantiation of a Class
BankAccount account = new BankAccount();

Class
Name Class
Instance Constructor
Variable
Name
Use of instances
z Call methods off of instances:
z account.withdraw(amount);
z account.deposit(amount);
z Access its instance variables:
z account.id
z account.balance
z When we're done with an object, we just stop
using it.
z Java will garbage collect the object when there
are no more references to it.
Defining a Class
z The template for a class definition follows:
[access] [abstract/final] class className
[extends superClassName]
[implements interfaceNames…] {
//constructors
//member functions
//member variables
}
Simple Example
public class BankAccount {
…
}
Class Members
z In class definitions we can define the
following members:
z Constructors
z Instance and static methods
z Instance and static fields
z Nested classes
Constructors
z Must have the same name of the Class that
they are in
z Can have multiple constructors per Class
z Handles initialization of your class
z Template:
[access] className ([arguments…]) {
//constructor body
}
Example:
Single Constructor
public class BankAccount {
public BankAccount () {
…
}
} Notice that the name of
the constructor is the
same as the class
Example:
Multiple Constructors
public class BankAccount {
public BankAccount () {
…
}
public BankAccount (int initialAmount) {
…
} These are different
} constructors because they
take in different arguments
Methods
z Methods perform functions
z Methods work on the state of the class
z Like Scheme, methods can take in multiple
arguments, and return up to one value
z If no value is to be returned, use the keyword void
z A class can have as many methods as needed
z Template:
[access] returnType methodName ([arguments…]) {
//method body
}
Example Methods
public class BankAccount {
public void withdraw (int amount) {
…
}
public int getAmount () {
…
}
}
Method Overloading
z A class can have two functions with the same
name in a class as long as their arguments
differ.
z Example:
z void foo () {…}
z void foo (int bar) {…}
z Java knows which method to call based on
the method signature
z Example: myClass.foo(7) //calls 2nd method
Fields
z A field is like a variable, it stores state
z A field has a associated data type which
determines the type of data that this field will
hold
z Template:
[access] dataType fieldName [= value];
Example Fields
public class BankAccount {
public int balance;
public Date lastWithdrawal;
public List transactions;
}
Bringing It Together
public class BankAccount {
private int balance; Field
public BankAccount () {
balance = 0;
Constructor
}
public void withdraw (int amount) {
balance = balance – amount;
}
Methods
public void deposit (int amount) {
balance = balance + amount;
}
}
Accessors
z Before we saw the placeholder [access].
z There are 4 types of access keywords to
describe which classes have access:
z public – any other class in any package
z protected – any subclass has access
z (default) – only classes within the same package
z private – only accessible from within a class
z Good for keeping data abstraction intact
Inheritance
z Allows classes to inherit functionality from
other classes
z Allows data and procedural abstraction
z Decreases complexity of large software
systems
Checking and Savings
z Two separate ideas with different behaviors,
but there exists overlap of functionality

BankAccount

CheckingAccount SavingsAccount
Interfaces
z An interface is a specification of a Class
z Declares methods but does not define them
z Interfaces do not have constructors
z Template:
[access] interface interfaceName
[extends interfaceNameList…] {
//method declarations
}
Example Interface
public interface BankAccount {
public void withdraw (int amount);
public void deposit (int amount);
public int getBalance ();
}

Notice that for method


declarations, the method
body is not defined.
How do we use the Interface?
z We make classes or other interface
implement or extend the interface.
z If a class implements an interface, that class
must provide an implementation (a method
body) for every method specified by the
interface
z If a class implements multiple interfaces, it must
implement all methods of every interface it
chooses to implement
Example Interface Use
public class CheckingAccount implements BankAccount {
private int balance;
public CheckingAccount (int initial) {
balance = initial;
}
Since
//implemented methods from BankAccount CheckingAccount
public void withdraw (int amount) { implements
balance = balance – amount; BankAccount, it
} must provide
implementations
public void deposit (int amount) { for these methods
balance = balance + amount;
}
public int getBalance () {
return balance;
}
}
Abstract Classes
z Abstract classes are a mix between
interfaces and classes
z can have defined method bodies
z can have fields
z Helps to capture the idea of state as well as
functionality
z Template:
See Class template (use keyword abstract)
Advantage of Abstract Classes
z For our BankAccount example we can
choose to provide implementations for
methods we know is common, and
declarations for methods that might differ
z Let’s build an abstract class for BankAccount
Example:
Abstract Class
public abstract class BankAccount {
protected int balance;
public int getBalance () {
return balance;
}
public void deposit (int amount) {
balance = balance + amount;
}
public void withdraw (int amount);
}
Example:
Class Extension
public class CheckingAccount extends BankAccount {
public CheckingAccount () {
balance = 0;
}
public void withdraw (int amount) {
balance = balance – amount;
}
}
Example:
Class Extension
public class SavingsAccount extends BankAccount {
private int numberOfWithdrawals;
public SavingsAccount () {
balance = 0;
numberOfWithdrawals = 0;
}
public void withdraw (int amount) {
if (numberOfWithdrawals > 5) {
throw new RuntimeException (“Cannot make >5 withdrawals a month”);

} else {
balance = balance – amount;
numberOfWithdrawals++;
}
}
public void resetNumOfWithdrawals () {…}
}
Break

You might also like