Session 03

Classes and Objects

(http://docs.oracle.com/javase/tutorial/java/javaOO/index.html)

Session 03 - Classes and Objects

 Objectives
1-Programming Paradigms
2-OOP basic concepts
3-How to identify classes
4-How to declare/use a class
5-Common modifiers (a way to hide some
members in a class)
6-Cotrolling access to members of a class using
modifiers
7-Overriding methods in sub-classes
8-Nested classes

Session 03 - Classes and Objects

9-Benefits of OO implementation:
inheritance, polymorphism
10-Working with interfaces
11-Working with Abstract methods and
classes
12-Enum type

Session 03 - Classes and Objects

 Programming Paradigms
• High-level programming languages (from 3rd
generation languages) are divided into (Wikipedia):
Paradigm Description
Procedural-oriented (imperative) Program= data + algorithms. Each algorithm is
paradigm-POP implemented as a function (group of statements)
(3rd generation language) and data are it’s parameters (C-language)

Object-oriented paradigm (OOP) Programs = actions of some objects. Object = data

(3rd generation language) + behaviors. Each behavior is implemented as a
method ( C++, Java, C#,…)
Functional paradigm Domain-specific languages. Basic functions were
(4th generation language) implemented. Programs = a set of functions ( SQL)

Declarative/Logic paradigm Program = declarations + inference rules ( Prolog,

(5th generation language) CLISP, …)

Session 03 - Classes and Objects

 Programming Paradigms: POP vs. OOP
Procedure-Oriented Program Class A
{
data1
data1
data2
Function1 ()
Function1 (data1)
Function2 ()
Function2 (data1)
}
Function3 (data2)
Function4 (data2) Class B
{
data2 Common
Object = Data + Methods
Function3 () methods
Basic Concepts Function4()
for
- Encapsulation Particular accessing a
methods: } data field:
- Inheritance Constructors
- Polymorphism Type getField()
void setField (Type newValue)
Session 03 - Classes and Objects
OOP Concepts

• Encapsulation
• Inheritance
• Polymorphism

Session 03 - Classes and Objects

 OOP Concepts: Encapsulation

Aggregation of data and behavior.

• Class = Data (fields/properties) + Methods
• Data of a class should be hidden from the outside.
• All behaviors should be accessed only via methods.
• A method should have a boundary condition: Parameters
must be checked (use if statement) in order to assure that
data of an object are always valid.
• Constructor: A special method it’s code will execute
when an object of this class is initialized.

Session 03 - Classes and Objects

 OOP Concepts: Inheritance - 1
Ability allows a class having members of an
existed class ➔ Re-used code, save time
class PERSON class STUDENT

ID_Num ID_Num
Name Name
YearOfBirth inherited YearOfBirth
Address Address
getID_Num() getID_Num()
setID_Num(newID) setID_Num(newID)
...... ......
“is a”
relationship
RollNum
class STUDENT
Score
extensions
RollNum getScore()
Score setSore(newScore)
getScore() ......
setSore(newScore)
......
Son = Father + extensions

Session 03 - Classes and Objects

 OOP Concepts: Inheritance -2
How to detect father class?
Finding the intersection of concerned classes.
⚫ Electric Products< code, name, make, price, guaranty, voltage, power>
⚫ Ceramic Products < code, name, make, price, type >
⚫ Food Products < code, name, make, price , date, expiredDate >

Product
code
name
make
price

ElectricProduct Food
guaranty Ceramic
date
voltage type expiredDate
power
Session 03 - Classes and Objects
 OOP Concepts: Polymorphism

Ability allows many versions of a method

based on overloading and overriding
methods techniques.
Overloading: A class can have some
methods which have the same name but
their parameter types are different.
Overriding: A method in father class can be
overridden in it’s derived classes (body of a
method can be replaced in derived classes).
Session 03 - Classes and Objects
 How to Identity a Class
• Main noun: Class
• Nouns as modifiers of main noun: Fields
• Verbs related to main noun: Methods
class Vehicle {
Vehicle has attributes of String manufacturer;
int manufacture year;
manufacturer, manufacture
double cost;
year, cost, color String color;
Write a Java program that Vehicle input() {
<code>
will allow input a Vehicle,
}
output its. void output() {
<code>
}
}
11
 Declaring/Using a Java Class

[public] class ClassName [extends FatherClass] {

[modifier] Type field1 [= value];
[modifier] Type field2 [= value]; Modifiers will be
// constructor introduced later.
[modifier] ClassName (Type var1,…) {
<code>
How many
}
constructors should
[modifier] methodName (Type var1,…) { be implemented? ➔
<code> Number of needed
} ways to initialize an
……. object.
}
What should we will write in constructor’s body? ➔ They usually
are codes for initializing values to descriptive variables
Session 03 - Classes and Objects
 Defining Constructors
• Constructors that are invoked to create
objects from the class blueprint.
• Constructor declarations look like method
declarations—except that they use the
name of the class and have no return
type.
• The compiler automatically provides a no-
argument, default constructor for any class
without constructors.

Session 03 - Classes and Objects

 Defining Methods

• Typical method declaration:

[modifier] ReturnType methodName (params) {
<code>
}

• Signature: data help identifying something

• Method Signature:
name + order of parameter types

Session 03 - Classes and Objects

Passing Arguments a Constructor/Method

• Java uses the mechanism passing by

value. Arguments can be:
• Primitive Data Type Arguments
• Reference Data Type Arguments (objects)

Session 03 - Classes and Objects

 Vehicle Management System

• Code a class named Car, Motor, Truck

are directly derived from base class
Vehicle object.

Session 03 - Classes and Objects

public class Vehicle { //super class
private String manufacturer;
private int year;
private double cost;
private String color;
public Vehicle(){}
public Vehicle(String manufacturer, int
year,double cost, String color){
this.manufacturer=manufacturer;
this.year=year;
this.cost=cost;
this.color=color;
}

Session 03 - Classes and Objects

public String getManufacturer() {
return manufacturer;}
public void setManufacturer(String
manufacturer) {
this.manufacturer = manufacturer;}
public int getYear() {
return year;}
public void setYear(int year) {
this.year = year;}
public double getCost() {
return cost;}
public void setCost(double cost) {
this.cost = cost;}

Session 03 - Classes and Objects

public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String toString(){
return
manufacturer+"\t"+year+"\t"+cost+"\t"+colo
r;
}
}
Session 03 - Classes and Objects
 Creating Objects
• Class provides the blueprint for objects;
you create an object from a class.
• Point p = new Point(23, 94);
• Statement has three parts:
• Declaration: 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 (memory is allocated).
• Initialization: The new operator is followed by a call
to a constructor, which initializes the new object
(values are assigned to fields).

Session 03 - Classes and Objects

 Type of Constructors
Create/Use an object of a class
• Default constructor: Constructor with no parameter.
• Parametric constructor: Constructor with at least one
parameter.
• Create an object
ClassName obj1=new ClassName();
ClassName obj2=new ClassName(params);
• Accessing a field of the object
object.field
• Calling a method of an object
object.method(params)

Session 03 - Classes and Objects

 Notes about Constructors

• If we do not implement any constructor, compiler

will insert to the class a system default
constructor.
• If we implement a constructor, compiler does not
insert default constructor.

Session 03 - Classes and Objects

 Object class

• The java.lang.Object class is the root of

the class hierarchy. Every class has
Object as a superclass. All objects,
including arrays, implement the methods
of this class.
• Class constructors: Object() This is the
Single Constructor.

Session 03 - Classes and Objects

• String toString() This method returns a
string representation of the object.
• boolean equals(Object obj) This method
indicates whether some other object is
"equal to" this one.
• int hashCode() This method returns a
hash code value for the object.
• Class getClass() This method returns the
runtime class of this Object.

Session 03 - Classes and Objects

Session 03 - Classes and Objects
 Common Modifiers - 1
• Modifier (linguistics) is a word which can bring out the
meaning of other word (adjective →noun, adverb →
verb)
• Modifiers (OOP) are keywords that give the compiler
information about the nature of code (methods), data,
classes.
• Java supports some modifiers in which some of them are
common and they are called as access modifiers
(public, protected, default, private).
• Common modifiers will impose level of accessing on
• class (where it can be used?)
• methods (whether they can be called or not)
• fields (whether they may be read/written or not)

Session 03 - Classes and Objects

 Common Modifiers - 2

Access level
Applied to
Free-accessing public
interface
package/ subclass

protected
class
outside cannot access
private
members of
interface/class
package
no specifier
(default)
Interface is a group of prototyped
methods and they will be
Order: implemented in a class afterward.
public > protected > default > private It will be introduced later.
Session 03 - Classes and Objects
 Access Level

Subclass-
Same
Modifier Class Outside World
Package
package

private Y N N N

No (default) Y Y N N

protected Y Y Y N

public Y Y Y Y

Session 03 - Classes and Objects

Tips on Choosing an Access Level

• Use the most restrictive access level that

makes sense for a particular member.
Use private unless you have a good
reason not to.
• Avoid public fields except for constants.
Public fields tend to link you to a particular
implementation and limit your flexibility in
changing your code.

Session 03 - Classes and Objects

Overloading Method

Session 03 - Classes and Objects

 Access Modifier Overridden

Legal private default protected public

Illegal public protected default private

The sub-class must be more opened than it’s father

Session 03 - Classes and Objects

 Modifier final
• Final class:
Class can not
have sub-
class
• Final data is a
constant.
• Final method:
a method can
not be
overridden.

Session 03 - Classes and Objects

 Modifier static
Class variable/ Object variable
• Object variable: Variable of each object
• Class Variable: A variable is shared in all
objects of class. It is stored separately. It is
declared with the modifier static
• Class variable is stored separately. So, it
can be accessed as:
object.staticVar
ClassName.staticVar

Session 03 - Classes and Objects

Modifier static: Class variable/ Object variable

y-=7
1000 x=5

y=6
800 x=4

obj1 1000
obj2 800
N 10 → 9999

Session 03 - Classes and Objects

 Modifier static:
static code – Free Floating Block
All static code run only
one time when the first
time the class
containing them is
accesses

The second access

Session 03 - Classes and Objects
 Modifier static: Static method
• It is called as class method/global method and it is
called although no object of this class is created.
• Entry point of Java program is a static method
• Syntax for calling it: ClassName.staticMethod(args)
• Static methods:
• can access class variables and class methods
directly only.
• cannot access instance variables or instance
methods directly—they must use an object
reference.
• cannot use the this keyword as there is no
instance for this to refer to
Session 03 - Classes and Objects
What should be static in a class?

• Constants:
• The static modifier, in combination with
the final modifier, is also used to define
constants. The final modifier indicates
that the value of this field cannot
change.
static final double PI =
3.141592653589793;

Session 03 - Classes and Objects

 Methods with
Arbitrary Number of Arguments
A group is treated as an array
group.length →number of elements
group[i]: The element at the position i

Session 03 - Classes and Objects

 Exanple: a vehicle
public class SingleVehicle {
public Vehicle input(){
Vehicle v;
String manufacturer;
int year;
double cost;
String color;
Scanner in=new Scanner(System.in);
System.out.print("Manufacturer:");
manufacturer=in.nextLine();
System.out.print("Manufacture
year:");

Session 03 - Classes and Objects

year=Integer.parseInt(in.nextLine());
System.out.print("Cost:");
cost=Double.parseDouble(in.nextLine());
System.out.print("Color:");
color=in.nextLine();
v=new Vehicle(manufacturer, year, cost,
color);
return v;
}
public void output(Vehicle v){
System.out.println(v.toString());
}}

Session 03 - Classes and Objects

 Example: Array of vehicles
public class ArrayVehicle {
public Vehicle[] input(int n){
Vehicle[] v=new Vehicle[n];
String manufacturer;
int year;
double cost;
String color;
Scanner in=new Scanner(System.in);
for(int i=0;i<n;i++){
System.out.print("Manufacturer:");
manufacturer=in.nextLine();

Session 03 - Classes and Objects

System.out.print("Manufacture year:");
year=Integer.parseInt(in.nextLine());
System.out.print("Cost:");
cost=Double.parseDouble(in.nextLine());
System.out.print("Color:");
color=in.nextLine();
v[i]=new Vehicle(manufacturer, year, cost,
color);}
return v; }
public void output(Vehicle[] v){
System.out.println("Manufacturer Year Cost
Color");
for(int i=0;i<v.length;i++)
System.out.println(v[i].toString());
}}
Session 03 - Classes and Objects
 Simple Uses of Inner Classes

• Inner classes are classes defined within

other classes
• The class that includes the inner class is
called the outer class
• There is no particular location where the
definition of the inner class (or classes) must
be place within the outer class
• Placing it first or last, however, will guarantee
that it is easy to find

Session 03 - Classes and Objects

 Simple Uses of Inner Classes

• An inner class definition is a member of the

outer class in the same way that the instance
variables and methods of the outer class are
members
• An inner class is local to the outer class definition
• The name of an inner class may be reused for
something else outside the outer class definition
• If the inner class is private, then the inner class
cannot be accessed by name outside the definition of
the outer class

Session 03 - Classes and Objects

 Inner/Outer Classes
public class Outer
{
private class Inner
{
// inner class instance variables
// inner class methods

} // end of inner class definition

// outer class instance variables

// outer class methods
}

Session 03 - Classes and Objects

 Simple Uses of Inner Classes

• There are two main advantages to inner classes

• They can make the outer class more self-contained
since they are defined inside a class
• Both of their methods have access to each other's
private methods and instance variables
• Using an inner class as a helping class is one of
the most useful applications of inner classes
• If used as a helping class, an inner class should be
marked private

Session 03 - Classes and Objects

 Shadowing (1)

• Declaration of a type in a particular scope

has the same name as another declaration
in the enclosing scope, then the
declaration shadows the declaration of
the enclosing scope.

Session 03 - Classes and Objects

 Shadowing Variable (2)

Mechanism: Local data is treated first

Session 03 - Classes and Objects

 Implementing
Object-Oriented Relationships
• 3 common relations in classes:
• “is a/ a kind of”
• “has a”
• association
• Examples:
• Student is a person
• “A home is a house that has a family and a
pet.”
• A Professor has some students and a
professor can be contained in one Student
Session 03 - Classes and Objects
 Implementing
Object-Oriented Relationships…
The relation “is a” is Person The relation “has a”
implemented as a - String name, address is implemented as
sub-class - String birthDate reference

Classes Professor, + String getName();

Student are sub-classes + void setName(String n);
of the class Person …….

Sub-classes inherit the

structure of super class
is a

Professor Student
- String department - String studentId, majorField
+ String getDepartment(); teach - String degreeSought
+ void setDepartment(String d); + String getStudentId();
+ void setStudentID(String id)
….
The class Professor has the The class Student has
field Student[] students the field Professor pr
Session 03 - Classes and Objects
 Inheritance
• There are some sub-classes from one super class ➔ An
inheritance is a relationship where objects share a
common structure: the structure of one object is a sub-
structure of another object.
• The extends keyword is used to create sub-class.
• A class can be directly derived from only one class (
Java is a single-inherited OOP language).
• If a class does not have any super class, then it is
implicitly derived from Object class.
• Unlike other members, constructor cannot be inherited
(constructor of super class can not initialize sub-class
objects)

Session 03 - Classes and Objects

 Inheritance…
• How to construct a class hierarchy? → Intersection
⚫ Electric Products< code, name, make, price, guaranty, voltage, power>
⚫ Ceramic Products < code, name, make, price, type >
⚫ Food Products < code, name, make, price , date, expiredDate >

Product
code
name
make
price

ElectricProduct Ceramic Food

guaranty type date
voltage expiredDate
power

Session 03 - Classes and Objects

Inheritance…: “super” Keyword
• Constructors Are Not Inherited
• super(...) for Constructor Reuse
• super(arguments); //invoke a super class
constructor
• The call must be the first statement in the
subclass constructor
• Replacing the Default Parameterless
Constructor

Session 03 - Classes and Objects

 Inheritance…: “super” Keyword
• We use the Java keyword super as the
qualifier for a method call:
super. methodName(arguments);
• Whenever we wish to invoke the version of
method methodName that was defined by our
superclass.
• super() is used to access the superclass's
constructor. And It must be the first statement
in the constructor of the subclass.

Session 03 - Classes and Objects

Inheritance…

Session 03 - Classes and Objects

Inheritance…

Session 03 - Classes and Objects

public class Point {
private int x,y;
public Point(int x,int y){
this.x=x; this.y=y;}
…..//getter & setter }
public class Polygon {
protected Point d1, d2, d3, d4;
public void setD1(Point d1) {this.d1=d1;}
public Point getD1(){return d1;}
@Override
public String toString(){
return
d1.getX()+"\t"+d1.getY()+"\t"+d2.getX()+"\t"+d2.ge
tY()+
"\t"+d3.getX()+"\t"+d3.getY()+"\t"+d4.getX()+"\t"+
d4.getY(); }}

Session 03 - Classes and Objects

public class Square extends Polygon{
public Square(){
d1 = new Point(0,0); d2 = new Point(0,1);
d3 = new Point (1,0);d4 = new Point(1,1);
}
}
public class Main {
public static void main(String args[]){
Square sq = new Square();
System.out.println(sq.toString());
}
}

Session 03 - Classes and Objects

public class Person {
private String name;
private String bithday;
public Person() {
} // getter & setter }
public class Employee extends Person {
private double salary;
public double getSalary() { return salary; }
public void setSalary(double salary){
this.salary = salary; }
@Override
public String toString() {
//return name + "\t" + birthday + "\t" + salary;
return super.getName() + "\t" +
super.getBithday() + "\t" + salary;
}}
Session 03 - Classes and Objects
public class Main {
public static void main(String
args[]){
Employee e = new Employee();
e.setName("To Ngoc Van");
e.setBithday("3/4/1994");
e.setSalary(4.4);
System.out.println(e.toString());
}
}

Session 03 - Classes and Objects

1. public class Polygon { Output???
protected Point d1, d2, d3, d4;
public Polygon() {
System.out.println(“Polygon class");
}……}
2. public class Square extends Polygon{
public Square(){
System.out.println(“Square class");
}}
3. public class Main {
public static void main(String args[]){
Square hv = new Square();
}}

Session 03 - Classes and Objects

1. public class Polygon {
protected Point d1, d2, d3, d4;
//a constructor is not default contructor
……}
2. public class Square extends Polygon{
public Square(){
System.out.println(“Square class");
}}
3. public class Main {
public static void main(String args[]){
Square hv = new Square();
}}
Why Error???

Session 03 - Classes and Objects

Overriding and Hiding Methods (1)
• Overriding a method: An instance method in a
subclass with the same signature (name, plus
the number and the type of its parameters) and
return type as an instance method in the
superclass overrides the superclass's method.
• Use the @Override annotation that instructs the
compiler that you intend to override a method in the
superclass (you may not use it because overriding is
default in Java).
• Hiding a method: Re-implementing a static
method implemented in super class

Session 03 - Classes and Objects

Overriding and Hiding Methods (2)

Session 03 - Classes and Objects

 Polymorphism
• The ability of two or more objects
belonging to different classes to respond
to exactly the same message (method
call) in different class-specific ways.
• Inheritance combined with overriding
facilitates polymorphism.

Session 03 - Classes and Objects

 Polymorphism…
Student

- String name;
+ void print();

GraduateStudent UndergraduateStudent

- String underGraduateDegree; - String highSchool;

+ GraduateStudent(String n, String ug) + UndergraduateStudent(String n, String h)

+ void print(); + void print ();

Session 03 - Classes and Objects

 Overriding Inherited Methods
Overridden method: An inherited method is re-written

Overloaded methods: Methods have the same

name but their parameters are different in a class

Session 03 - Classes and Objects

How Can Overridden Method be
Determined?

Session 03 - Classes and Objects

 Exampe
• Code a class named Car, Motor, Truck
are directly derived from base class
Vehicle object.
public class Car extends Vehicle {
private String typeofEngine;
private int seats;
public Car(){
super();
}

Session 03 - Classes and Objects

public Car(String manufacturer, int
year,double cost, String color, String
typeofEngine, int seats){
super(manufacturer, year, cost,color);
this.typeofEngine=typeofEngine;
this.seats=seats;
}
public String getTypeofEngine() {
return typeofEngine;
}
public void setTypeofEngine(String
typeofEngine) {
this.typeofEngine = typeofEngine;
}
Session 03 - Classes and Objects
public int getSeats() {
return seats;
}
public void setSeats(int seats) {
this.seats = seats;
}
public String toString(){
return
super.toString()+"\t"+typeofEngine+"
\t"+seats;
}}

Session 03 - Classes and Objects

Example: Array of Car, Motor, Truck
public class ArrayVehicles {
private Vehicle[] list;
private int n;
public ArrayVehicles(){
n=0;
list=new Vehicle[50];
}
public int getNumberofVehicle(){
return n;
}
Session 03 - Classes and Objects
private Vehicle input(){
Vehicle v;
String manufacturer;
int year; double cost;
String color;
Scanner in=new Scanner(System.in);
System.out.print("Manufacturer:");
manufacturer=in.nextLine();
System.out.print("Manufacture year:");
year=Integer.parseInt(in.nextLine());
System.out.print("Cost:");
cost=Double.parseDouble(in.nextLine());
System.out.print("Color:");
color=in.nextLine();
v=new Vehicle(manufacturer, year, cost,
color);
return v;
}

Session 03 - Classes and Objects

public void inputMotor(){
double power;
Vehicle v=input();
Scanner in=new Scanner(System.in);
System.out.print("Power:");
power=in.nextDouble();
list[n++]=new
Motor(v.getManufacturer(),v.getYear(
),v.getCost(),v.getColor(), power);
}

Session 03 - Classes and Objects

public void inputCar(){
String typeofEngine;
int seats;
Vehicle v=input();
Scanner in=new Scanner(System.in);
System.out.print("Type of engine:");
typeofEngine=in.nextLine();
System.out.print("Number of Seats:");
seats=in.nextInt();
list[n++]=new
Car(v.getManufacturer(),v.getYear(),
v.getCost(),v.getColor(), typeofEngine,
seats);
}

Session 03 - Classes and Objects

public int getNumberofCar(){
int count=0;
for(int i=0;i<n;i++)
if(list[i] instanceof Car)
count++;
return count; }
public int getNumberofMotor(){
int count=0;
for(int i=0;i<n;i++)
if(list[i] instanceof Motor)
count++;
return count;
}

Session 03 - Classes and Objects

public void output(){
if(getNumberofCar()>0){
System.out.println("List of Cars");
System.out.println("Manufacturer Year
Cost Color TypeofEngine
NumberofSeats");
for(int i=0;i<n;i++){
if(list[i] instanceof Car)
System.out.println(list[i].toString());
}
System.out.println("-------------------");
System.out.println("Number of
cars:"+getNumberofCar());
}
Session 03 - Classes and Objects
if(getNumberofMotor()>0){
System.out.println("List of Motors");
System.out.println("Manufacturer Year
Cost Color Power");
for(int i=0;i<n;i++){
if(list[i] instanceof Motor)
System.out.println(list[i].toString());
}
System.out.println("-------------------");
System.out.println("Number of
motors:"+getNumberofMotor());
}

Session 03 - Classes and Objects

if(getNumberofTruck()>0){
System.out.println("List of Trucks");
System.out.println("Manufacturer Year
Cost Color Load");
for(int i=0;i<n;i++){
if(list[i] instanceof Truck)
System.out.println(list[i].toString());
}
System.out.println("-------------------");
System.out.println("Number of
trucks:"+getNumberofTruck());
}
}

Session 03 - Classes and Objects

 Menu

public class Main {

public static void main(String[]
args) {
ArrayVehicles a=new
ArrayVehicles();
Scanner in=new
Scanner(System.in);

Session 03 - Classes and Objects

while(true){
System.out.print("\n 1. input a Car");
System.out.print("\n 2. input a Motor");
System.out.print("\n 3. input a Truck");
System.out.print("\n 4. output");
System.out.print("\n 0. Exit");
System.out.print("\n Your choice(0->4):
");
int choice;
choice=in.nextInt();
switch(choice){
case 1:a.inputCar();
break;

Session 03 - Classes and Objects

case 2:a.inputMotor();
break;
case 3:a.inputTruck();
break;
case 4:a.output();
break;
case 0:
System.out.println("Bye!!!!");
System.exit(0);
break;
default:System.out.println("only to
choose (0->4)");
}}}}
Session 03 - Classes and Objects
 Interfaces
• An interface is a reference type, similar to a
class, that can contain only constants,
initialized fields, static methods, prototypes
(abstract methods, default methods), static
methods, and nested types.
• It will be the core of some classes
• Interfaces cannot be instantiated because they
have no-body methods.
• Interfaces can only be implemented by classes
or extended by other interfaces.

Session 03 - Classes and Objects

Interfaces…

Session 03 - Classes and Objects

 Interfaces…

m3(), m4() in A
cannot implement
m3(), m4() in
InterfaceDemo,
attempting to assign
weaker access
privileges, were
public

Default methods of an interface must be overridden as public methods in

concrete classes.
Session 03 - Classes and Objects
Session 03 - Classes and Objects
 Abstract Classes
• Used to define what behaviors a class is
required to perform without having to
provide an explicit implementation.
• It is the result of so-high generalization
• Syntax to define a abstract class
• public abstract class className{ ... }
• It isn’t necessary for all of the methods in an
abstract class to be abstract.
• An abstract class can also declare implemented
methods.

Session 03 - Classes and Objects

Abstract Classes…

Modified

Session 03 - Classes and Objects

 Abstract Classes…

This class have no abstract method but it is declared as an

abstract class. So, we can not initiate an object of this class.

Session 03 - Classes and Objects

 Abstract Classes…

Error.
Why?

Session 03 - Classes and Objects

Implementing Abstract Methods
• Derive a class from an abstract superclass, the
subclass will inherit all of the superclass’s
features, all of abstract methods included.
• To replace an inherited abstract method with
a concrete version, the subclass need merely
override it.
• Abstract classes cannot be instantiated

Session 03 - Classes and Objects

Session 03 - Classes and Objects
 Type Casting in Inheritance
• You can cast an instance of a child class to its parent
class. Casting an object of child class to a parent class is
called upcasting.
• Casting an object of a parent class to its child class is
called downcasting.
• class Vehicle { String manufacturer; }
• class Car extends Vehicle {String
typeofEngine; }
• public class TypeCastExample {
public static void main(String[] args) {
Vehicle v1 = new Vehicle();
Vehicle v2 = new Car();//upcasting
Car v3 = (Car) new Vehicle();//downcasting
Car v4 = new Car(); } }
Session 03 - Classes and Objects
 Enum Types
• An enum type is a special data type that
enables for a variable to be a set of
predefined constants.
• We use enum types any time you need to
represent a fixed set of named-constants
(uppercase). New/ Java Enum

Session 03 - Classes and Objects

 Enum Type simple example
enum Season { SPRING, SUMMER, AUTUMN, WINTER }

class Main {
static void fun(Season x)
{switch(x)
{case SPRING: System.out.println("It is spring"); break;
case SUMMER: System.out.println("It is summer"); break;
case AUTUMN: System.out.println("It is autumn"); break;
case WINTER: System.out.println("It is winter");
}
}
public static void main(String[] args) {
Season x = Season.WINTER; fun(x);

for(Season y: Season.values()) {
System.out.print(y + ": "); fun(y);
}
System.out.println();
}
}

Session 03 - Classes and Objects

Enum Type with parameter constructor
enum Season {
SPRING(25, 11), SUMMER(32, 13), AUTUMN(23, 10), WINTER(10, 9);
private final int avgTemp, dayLength;
Season(int x, int y) {
avgTemp = x; dayLength = y;
}
public void display() {
System.out.println(this + " average temperature is " + avgTemp);
System.out.println(this + " average day's length is " + dayLength);
}
}

class Main {
public static void main(String[] args) {
Season x = Season.WINTER;
x.display();
System.out.println();
}
}

Session 03 - Classes and Objects

 Summary
• The class, how to declare fields, methods, and
constructors.
• Hints for class design:
• Main noun → Class
• Descriptive nouns → Fields
• Methods: Constructors, Getters, Setters, Normal
methods
• Creating and using objects.
• Use the dot operator to access the object's
instance variables and methods.

Session 03 - Classes and Objects

• Overriding methods in sub-classes
• Controlling Access to Members of a Class
using modifiers
• Nested Classes
• Benefits of OO implementation:
Inheriatance ans Polymorphism
• Working with Interfaces.
• Working with Abstract Methods and
Classes.
• Enum Type

Session 03 - Classes and Objects