1 Review of Basic Concepts

in Java

Introduction to Programming 2

Topics

Object-Oriented Concepts

Java Program Structure

Introduction to Programming 2

Object-Oriented Concepts

Object-Oriented Design

Focuses on object and classes based on real world scenarios

Emphasizes state, behavior and interaction of objects

Advantages:

Faster development

Increased quality

Easier maintenance

Enhanced modifiability

Increase software reuse

Class

Allows you to define new data types

Blueprint
Introduction to Programming 2

Object-Oriented Concepts

Object

An entity that has a state, behavior and identity with a well-defined

role in problem space

An actual instance of a class

Created every time you instantiate a class using the new keyword.

Student registration system example

Attribute

Data element of an object

Stores information about the object

A.K.A. Data member, instance variable, property, data field

Student registration system example

Introduction to Programming 2

Object-Oriented Concepts

Method

Describes the behavior of an object

Also called a function or a procedure

Student registration system example

Constructor

Method-like

For creating and initializing a new object

Not members of an object

Introduction to Programming 2

Object-Oriented Concepts

Package

Grouping of classes and/or subpackages

Analogous to a directory

Encapsulation

Principle of hiding design or implementation information not relevant

to the current object

Abstraction

Ignoring aspects of a subject not relevant to the current purpose to

focus on those that are
Introduction to Programming 2

Object-Oriented Concepts

Inheritance

Relationship between classes wherein one class is the superclass or

the parent class of another

Refers to the properties and behaviors received from an ancestor

Also know as a "is-a" relationship

SuperHero

FlyingSuperHero

UnderwaterSuperHero

Introduction to Programming 2

Object-Oriented Concepts

Polymorphism

"poly" means many while "morph" means form

Ability of an object to assume may different forms

Interface

Contract in the form of a collection of method and constant

declarations

Implementing class promises to follow the contract.

Introduction to Programming 2

Java Program Structure:

Declaring Classes

Syntax
<classDeclaration> ::=
<modifier> class <name> {
<attributeDeclaration>*
<constructorDeclaration>*
<methodDeclaration>*
}
where

Modifier

Refers to an access modifier or other types of modifiers

Name

Is an identifier for the name of the class

Introduction to Programming 2

Java Program Structure:

Declaring Classes
1

class SuperHero {

String superPowers[];

void setSuperPowers(String superPowers[])

this.superPowers = superPowers;

4
5

void printSuperPowers() {
for (int i = 0; i < superPowers.length; i++) {

System.out.println(superPowers[i]);

10
11

}
Introduction to Programming 2

10

Java Program Structure:

Declaring Attributes

Syntax:
<attributeDeclaration> ::=
<modifier> <type> <name> [= <default_value>];
<type> ::=
byte | short | int | long | char | float | double
| boolean | <class>

Introduction to Programming 2

11

Java Program Structure:

Declaring Attributes
1

public class AttributeDemo {

private String studNum;

public boolean graduating = false;

protected float unitsTaken = 0.0f;

String college;

Introduction to Programming 2

12

Java Program Structure:

Declaring Methods

Syntax:
<methodDeclaration> ::=
<modifier> <returnType> <name>(<parameter>*) {
<statement>*
}
<parameter> ::=
<parameter_type> <parameter_name>[,]

Introduction to Programming 2

13

Java Program Structure:

Declaring Methods
1

class MethodDemo {

int data;

int getData() {

return data;

void setData(int data) {

this.data = data;

7
8

void setMaxData(int data1, int data2) {

data = (data1>data2)? data1 : data2;

10

11
12

}
Introduction to Programming 2

14

Java Program Structure:

Declaring a Constructor

Syntax:
<constructorDeclaration> ::=
<modifier> <className> (<parameter>*) {
<statement>*
}
where

Modifier

Can be any access modifier but not other types of modifiers.

Default constructor

No arguments

Empty body
Introduction to Programming 2

15

Java Program Structure:

Declaring a Constructor
1

class ConstructorDemo {

private int data;

public ConstructorDemo() {
data = 100;

4
5

ConstructorDemo(int data) {
this.data = data;

8
9

Introduction to Programming 2

16

Java Program Structure:

Instantiating a Class

Syntax:

new <constructorName>(<parameters>)

Example:
1

class ConstructObj {

int data;

ConstructObj() {
/* initialize data */

4
5

public static void main(String args[]) {

ConstructObj obj = new ConstructObj();

8
9

Introduction to Programming 2

17

Java Program Structure:

Accessing Object Members

Dot notation:
<object>.<member>

An example:
String myString = new String(My String);
//Access length method
System.out.println(Length: + myString.length());
Output: Length: 9

Introduction to Programming 2

18

Java Program Structure:

Accessing Object Members

Another example
int intArr = {1, 2, 3, 4, 5};
//Access length attribute
System.out.println(Length: + intArr.length);
Output: Length: 5

Introduction to Programming 2

19

Java Program Structure:

Accessing Object Members
1

class ConstructObj {

int data;

ConstructObj() {
/* initialize data */

4
5

void setData(int data) {

this.data = data;

7
8

public static void main(String args[]) {

10

ConstructObj obj = new ConstructObj();

11

obj.setData(10);

12

System.out.println(obj.data); //access data

}

13
14

//access setData()

Introduction to Programming 2

20

Java Program Structure:

Accessing Object Members
Output:
10

Introduction to Programming 2

21

Java Program Structure:

Packages

Syntax for indicating that the code belongs to a package:

<packageDeclaration> ::=
package <packageName>;

Syntax for importing other packages:

<importDeclaration> ::=
import <packageName.elementAccessed>;

Source code format:

[<packageDeclaration>]
<importDeclaration>*
<classDeclaration>+
Introduction to Programming 2

22

Java Program Structure:

Packages
1

package registration.reports;

import registration.processing.*;

import java.util.List;

import java.lang.*;

class MyClass {
/* details of MyClass */

6
7

//imported by default

Introduction to Programming 2

23

Java Program Structure:

The Access Modifiers

Introduction to Programming 2

24

Java Program Structure:

Encapsulation

Hide members by making them private

Example
1

class Encapsulation {

private int secret;

public boolean setSecret(int secret) {

if (secret < 1 || secret > 100)

return false;

5
6

this.secret = secret;

return true;

public getSecret() {
return secret;

10

11
12

Introduction to Programming 2

25

Java Program Structure:

Encapsulation

What if I do not want to allow other classes to modify the

value of secret?
Answer: Make the setSecret() method private.

Introduction to Programming 2

26

Java Program Structure:

Inheritance

Creating a child class or a subclass:

Use extends in declaring the class

Syntax:
class <childClassName> extends <parentClassName>

A class can only extend one parent class

Introduction to Programming 2

27

Java Program Structure:

Inheritance
1

import java.awt.*;

2
3

class Point {

int x;

int y;

7
8

class ColoredPoint extends Point {

Color color;

9
10

Introduction to Programming 2

28

Java Program Structure:

Overriding Methods

Subclass defines a method whose signature is identical to a

method in the superclass
Signature of a method

Information found in the method header definition

Return type

Method name

Parameter list of the method

Different from method overloading!

Introduction to Programming 2

29

Java Program Structure:

Overriding Methods
1

class Superclass {
void display(int n) {

System.out.println("super: " + n);

4
5

6
7

class Subclass extends Superclass {

void display(int k) {

System.out.println("sub: " + k);

10
11

12
13

// continued...

Introduction to Programming 2

30

Java Program Structure:

Overriding Methods
14

class OverrideDemo {
public static void main(String args[]) {

15
16

Subclass SubObj = new Subclass();

17

Superclass SuperObj = SubObj;

18

SubObj.display(3);

19

((Superclass)SubObj).display(4);
}

20
21

Introduction to Programming 2

31

Java Program Structure:

Overriding Methods
Output:
sub: 3
sub: 4

Introduction to Programming 2

32

Java Program Structure:

Overriding Methods

Version of method called

Based on actual data type of the object that invoked the method

Access modifier for the methods need not be the same

Access modifier of the overriding method

Same access modifier as that of the overridden method

Less restrictive access modifier

Introduction to Programming 2

33

Java Program Structure:

Overriding Methods
1

class Superclass {

void overriddenMethod() {

class Subclass1 extends Superclass {

public void overriddenMethod() {

class Subclass2 extends Superclass {

10

void overriddenMethod() {

11

12

13

//continued...

Introduction to Programming 2

34

Java Program Structure:

Overriding Methods
14

/* class Superclass {

15

void overriddenMethod() {

16

17

} */

18

class Subclass3 extends Superclass {

19

protected void overriddenMethod() {

20

21

22

class Subclass4 extends Superclass {

23

private void overriddenMethod() {

24

25

}
Introduction to Programming 2

35

Java Program Structure:

Overriding Methods

Subclass4 causes a compile time error

private access modifier is more restrictive compared to
package/default modifier

Introduction to Programming 2

36

Java Program Structure:

Abstract Classes and Methods

Syntax:
abstract <modifier> <returnType> <name>
(<parameter>*);

Class containing an abstract method should be declared

abstract
abstract class <name> {
/* constructors, fields and methods */
}

Introduction to Programming 2

37

Java Program Structure:

Abstract Classes and Methods

abstract keyword is not for:

Constructor

static method

abstract classes cannot be instantiated

Classes that extends an abstract class:

Should implement all abstract methods

Otherwise, the subclass itself should be declared abstract

Introduction to Programming 2

38

Java Program Structure:

Abstract Classes and Methods
1

abstract class SuperHero {

String superPowers[];

void setSuperPowers(String superPowers[])

this.superPowers = superPowers;

4
5

void printSuperPowers() {
for (int i = 0; i < superPowers.length; i++) {

System.out.println(superPowers[i]);

9
10

11

abstract void displayPower();

12

13

//continued...

Introduction to Programming 2

39

Java Program Structure:

Abstract Classes and Methods
1

class FlyingSuperHero extends SuperHero {

void displayPower() {

System.out.println("Fly...");

4
5

6
7

class Spiderman extends SuperHero {

void displayPower() {

System.out.println("Communicate with sea" +

" creatures...");

10

System.out.println("Fast swimming ability...");

11

12
13

}
Introduction to Programming 2

40

Java Program Structure:

Interface

Syntax:
<interfaceDeclaration> ::=
<modifier> interface <name> {
<attributeDeclaration>*
[<modifier> <returnType> <name>
(<parameter>*);]*
}

Members are public when the interface is declared public

Introduction to Programming 2

41

Java Program Structure:

Interface

Interface attributes:

Implicitly static and final

Must be initialized

Modifiers:

Access modifiers: public, package

Must be initialized

Implementing an interface:

Use implements keyword

Should implement all the interface's methods

A class can implement several interfaces

Introduction to Programming 2

42

Java Program Structure:

Interface
1

interface MyInterface {
void iMethod();

2
3

4
5

class MyClass1 implements MyInterface {

public void iMethod() {

System.out.println("Interface method.");

7
8

void myMethod() {
System.out.println("Another method.");

10

11
12

13

//continued...

Introduction to Programming 2

43

Java Program Structure:

Interface
14

class MyClass2 implements MyInterface {

public void iMethod() {

15

System.out.println("Another implementation.");

16

17
18

19

class InterfaceDemo {
public static void main(String args[]) {

20
21

MyClass1 mc1 = new MyClass1();

22

MyClass2 mc2 = new MyClass2();

23

mc1.iMethod();

24

mc1.myMethod();

25

mc2.iMethod();
}

26
27

Introduction to Programming 2

44

Java Program Structure:

Interface
Output:
Interface method.
Another method.
Another implementation.

Introduction to Programming 2

45

Java Program Structure:

The this Keyword

Why this?
1. Disambiguate local attribute from a local variable
2. Refer to the object that invoked the non-static method
3. Refer to other constructors

Introduction to Programming 2

46

Java Program Structure:

The this Keyword

Disambiguate local attribute from a local variable

1

class ThisDemo1 {

int data;

void method(int data) {

this.data = data;

/*

this.data refers to the attribute

while data refers to the local variable

*/

9
10

}
Introduction to Programming 2

47

Java Program Structure:

The this Keyword

Refer to the object that invoked the non-static method

1

class ThisDemo2 {

int data;

void method() {
System.out.println(data);

4
5

void method2() {
method();

//this.method();

8
9

//this.data

Introduction to Programming 2

48

Java Program Structure:

The this Keyword

Method Overloading

Different methods within a class sharing the same name

Parameter lists should differ

Number of parameters

Type of parameters

Constructors can also be overloaded

An example:
class MyClass {
void myMeth() {}
void myMeth(int i) {}
void myMeth(int i, int j) {}
}
Introduction to Programming 2

49

Java Program Structure:

The this Keyword

Refer to other constructors

1

class ThisDemo3 {

int data;

ThisDemo3() {

this(100);

ThisDemo3(int data) {
this.data = data;

8
9

Call to this() should be the first statement in constructor

Introduction to Programming 2

50

Java Program Structure:

The super Keyword

Related to inheritance

Invoke superclass constructors

Can be used like the this keyword to refer to members of the

superclass

Calling superclass constructors

1

class Person {

String firstName;

String lastName;

Person(String fname, String lname) {

firstName = fname;

lastName = lname;
}

7
8

Introduction to Programming 2

51

Java Program Structure:

The super Keyword
9
10

//continuation...
class Student extends Person {

11

String studNum;

12

Student(String fname, String lname, String sNum)

13

super(fname, lname);

14

studNum = sNum;
}

15
16

super()

Refers to the immediate superclass

Should be first statement in the subclass's constructor

Introduction to Programming 2

52

Java Program Structure:

The super Keyword

Referring to superclass members

1

class Superclass{

int a;

void display_a(){
System.out.println("a = " + a);

5
6

7
8

//continued...

Introduction to Programming 2

53

Java Program Structure:

The super Keyword
9

class Subclass extends Superclass {

10

int a;

11

void display_a(){
System.out.println("a = " + a);

12
13

14

void set_super_a(int n){

super.a = n;

15
16

17

void display_super_a(){
super.display_a();

18

19
20

}
Introduction to Programming 2

54

Java Program Structure:

The super Keyword
21

class SuperDemo {
public static void main(String args[]){

22
23

Superclass SuperObj = new Superclass();

24

Subclass SubObj = new Subclass();

25

SuperObj.a = 1;

26

SubObj.a = 2;

27

SubObj.set_super_a(3);

28

SuperObj.display_a();

29

SubObj.display_a();

30

SubObj.display_super_a();

31

System.out.println(SubObj.a);
}

32
33

Introduction to Programming 2

55

Java Program Structure:

The super Keyword
Output:
a = 1
a = 2
a = 3
2

Introduction to Programming 2

56

Java Program Structure:

The static Keyword

Applied to members of a class:

Attributes

Methods

Inner classes

Allows accessing of static or class members without

instantiation
Class variables

Behave like a global variable

Can be accessed by all instances of the class

Introduction to Programming 2

57

Java Program Structure:

The static Keyword

Class methods

May be invoked without creating an object of its class

Can only access static members of the class

Cannot refer to this or super

static blocks

Executed only once, when the class is loaded

For initializing class variables

Introduction to Programming 2

58

Java Program Structure:

The static Keyword
1

class Demo {

static int a = 0;

static void staticMethod(int i) {

System.out.println(i);

4
5

static {

//static block

System.out.println("static block");

a += 1;
}

9
10

11
12

//continued...
Introduction to Programming 2

59

Java Program Structure:

The static Keyword
13

class StaticDemo {
public static void main(String args[]) {

14
15

System.out.println(Demo.a);

16

Demo.staticMethod(5);

17

Demo d = new Demo();

18

System.out.println(d.a);

19

d.staticMethod(0);

20

Demo e = new Demo();

21

System.out.println(e.a);

22

d.a += 3;

23

System.out.println(Demo.a+", "+d.a+", "+e.a);

}

24
25

Introduction to Programming 2

60

Java Program Structure:

The static Keyword
Output:
This is a static block.
1
5
1
0
1
4, 4, 4

Introduction to Programming 2

61

Java Program Structure:

The final Keyword

Applied to variables, methods and classes

Restricts what we can do with the variables, methods and
classes
final variable

Cannot be modified once its value has been set

Example:
final int data = 10;
data++;

Introduction to Programming 2

62

Java Program Structure:

The final Keyword

final method

Cannot be overridden

Example:
final void myMethod() { //in a parent class
}
void myMethod() { //in a child class
}

final class

Cannot be inherited

Example:
final public class MyClass {}
class WrongClass extends MyClass {}
Introduction to Programming 2

63

Java Program Structure:

The final Keyword

Keyword may be placed before after other modifiers

public final static void meth() {} or
final public static void meth() {} or ...
//order of modifiers is not important

Introduction to Programming 2

64

Java Program Structure:

Inner Classes

Class declared within another class

Accessing the members of the inner class:

Need to instatiate an inner class member first

Example:
innerObj.innerMember = 5;
//innerObj is an instance of the inner class
//innerMember is a member of the inner class

Introduction to Programming 2

65

Java Program Structure:

Inner Classes

Methods of the inner class can directly access members of

the outer class

Example:
1
2
3
4
5
6
7
8

class Out {
int OutData;
class In {
void inMeth() {
OutData = 10;
}
}
}

Introduction to Programming 2

66

Java Program Structure:

Inner Classes
1

class OuterClass {

int data = 5;

class InnerClass {

int data2 = 10;

void method() {

System.out.println(data);

System.out.println(data2);
}

8
9

10
11

//continued...

Introduction to Programming 2

67

Java Program Structure:

public static void main(String args[]) {

9
10

OuterClass oc = new OuterClass();

11

InnerClass ic = oc.new InnerClass();

12

System.out.println(oc.data);

13

System.out.println(ic.data2);

14

ic.method();
}

15
16

Introduction to Programming 2

68

Java Program Structure:

Output:
5
10

Introduction to Programming 2

69

Summary

Object-Oriented Concepts

Object-Oriented Design

Package

Class

Encapsulation

Object

Abstraction

Attribute

Inheritance

Method

Polymorphism

Constructor

Interface

Introduction to Programming 2

70

Summary

Java Program Structure

Declaring Java Classes

Inheritance

Declaring Attributes

Overriding Methods

Declaring Methods

Abstract Classes and Methods

Declaring a Constructor

Interface

Instantiating a Class

The this Keyword

Accessing Object Members

The super Keyword

Packages

The static Keyword

The Access Modifiers

The final Keyword

Encapsulation

Inner Classes

Introduction to Programming 2

71