Review of Basic Concepts

1
 Topics
● Object-Oriented Concepts
● Declaring a class
● Declaring properties in a class
● Declaring methods in a class
● Declaring constructor methods
● Creating object instances
● Accessing object members (properties, methods)
● Access modifiers

2
 Topics
● Object-Oriented Concepts In Java program
– encapsulation
– inheritance
● Overriding methods (of a super class) by the ones
in sub-class
● Abstract class and abstract methods
● Interface
● “this”, “super”, “static”, “final” keywords
● Inner classes

3
Object Oriented (OO) Concepts

4
 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
5
– Considered as a blueprint or template to create objects
 Object-Oriented Concepts
● Object (instance)
– 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.
● Attribute (property, field)
– Data element of an object
– Stores information about the object
– A.K.A. Data member, instance variable, property, data field

6
 Object-Oriented Concepts
● Method
– Describes the behavior of an object
– Also called a function or a procedure

● Constructor (method)
– Method-like
– For creating and initializing a new object

7
 Object-Oriented Concepts
● Package
– Grouping of classes and/or sub-packages
– Analogous to a directory of a file system

● Encapsulation
– Principle of hiding the implementation details not relevant
to the user of the class

● Abstraction
– Ignoring aspects of a subject not relevant to the current
purpose to focus on those that are 8
 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

9
 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.

10
Declaring a Class

11
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
12
 Java Program Structure: Declaring
Classes
1 class SuperHero {
2 String superPowers[];
3 void setSuperPowers(String superPowers[]) {
4 this.superPowers = superPowers;
5 }
6 void printSuperPowers() {
7 for (int i = 0; i < superPowers.length; i++) {
8 System.out.println(superPowers[i]);
9 }
10 }
11 }

13
Declaring Properties (Attributes)

14
Java Program Structure: Declaring
Attributes
● Syntax:
<attributeDeclaration> ::=
<modifier> <type> <name> [=
<default_value>];

<type> ::=
byte | short | int | long | char | float
| double | boolean | <class>

15
Java Program Structure: Declaring
Attributes
1 public class AttributeDemo {
2 private String studNum;
3 public boolean graduating = false;
4 protected float unitsTaken = 0.0f;
5 String college;
6 }

16
Declaring Methods

17
Java Program Structure: Declaring
Methods
● Syntax:
<methodDeclaration> ::=
<modifier> <returnType> <name>
(<parameter>*) {
<statement>*
}
<parameter> ::=
<parameter_type> <parameter_name>[,]

18
Java Program Structure: Declaring
Methods
1 class MethodDemo {
2 int data;
3 int getData() {
4 return data;
5 }
6 void setData(int data) {
7 this.data = data;
8 }
9 void setMaxData(int data1, int data2) {
10 data = (data1>data2)? data1 : data2;
11 }
12 }
19
Declaring Constructors

20
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-arg constructor)

– No arguments
21
Java Program Structure: Declaring
a Constructor
1 class ConstructorDemo {
2 private int data;
3 public ConstructorDemo() {
4 data = 100;
5 }
6 ConstructorDemo(int data) {
7 this.data = data;
8 }
9 }

22
Creating an Object Instance

23
 Java Program Structure:
Instantiating a Class
● Syntax:
new <constructorName>(<parameters>)

● Example:
1 class ConstructObj {
2 int data;
3 ConstructObj() {
4 /* initialize data */
5 }
6 public static void main(String args[]) {
7 ConstructObj obj = new ConstructObj();
8 }
24
9 }
Accessing Object Members

25
Java Program Structure: Accessing
Object Members
●
Dot notation:
<object>.<member>

● Some examples:
String myString = new String(“My String”);
//Access length method
System.out.println(“Length: ” + myString.length());

int intArr = {1, 2, 3, 4, 5};

//Access length attribute
System.out.println(“Length: ” + intArr.length);
26
Java Program Structure: Accessing
Object Members
1 class ConstructObj {
2 int data;
3 ConstructObj() {
4 /* initialize data */
5 }
6 void setData(int data) {
7 this.data = data;
8 }
9 public static void main(String args[]) {
10 ConstructObj obj = new ConstructObj();
11 obj.setData = 10; //access setData()
12 System.out.println(obj.data); //access data
13 } 27
14 }
Packages

28
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>*
29
<classDeclaration>+
Java Program Structure: Packages
1 package registration.reports;
2 import registration.processing.*;
3 import java.util.List;
4 import java.lang.*; //imported by default
5 class MyClass {
6 /* details of MyClass */
7 }

30
Access Modifiers

31
Java Program Structure:
The Access Modifiers

32
OO Concepts in Java program:
Encapsulation, Inheritance

33
 Java Program Structure:
Encapsulation
● Hide members by making them private
● Example
1 class Encapsulation {
2 private int secret;
3 public boolean setSecret(int secret) {
4 if (secret < 1 || secret > 100)
5 return false;
6 this.secret = secret;
7 return true;
8 }
9 public getSecret() {
10 return secret;
11 }
12 }

34
 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

35
 Java Program Structure:
Inheritance
1 import java.awt.*;
2

3 class Point {
4 int x;
5 int y;
6 }
7

8 class ColoredPoint extends Point {

9 Color color;
10 }

36
Overriding Methods
(by Sub-Class)

37
 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!

38
 Java Program Structure:
Overriding Methods
1 class Superclass {
2 void display(int n) {
3 System.out.println("super: " + n);
4 }
5 }
6

7 class Subclass extends Superclass {

8 void display(int k) {
9 System.out.println("sub: " + k);
10 }
11 }
12

13 // continued... 39
 Java Program Structure:
Overriding Methods
14 class OverrideDemo {
15 public static void main(String args[]) {
16 Subclass SubObj = new Subclass();
17 Superclass SuperObj = SubObj;
18 SubObj.display(3);
19 ((Superclass)SubObj).display(4);
20 }
21 }

40
 Java Program Structure:
Overriding Methods
● Version of method called
– Based on actual 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

41
 Java Program Structure:
Overriding Methods
1 class Superclass {
2 void overriddenMethod() {
3 }
4 }
5 class Subclass1 extends Superclass {
6 public void overriddenMethod() {
7 }
8 }
9 class Subclass2 extends Superclass {
10 void overriddenMethod() {
11 }
12 }
13 //continued... 42
 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 }
43
Abstract Class &
Abstract Methods

44
 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 */
– }

45
 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

46
 Java Program Structure: Abstract
Classes and Methods
1 abstract class SuperHero {
2 String superPowers[];
3 void setSuperPowers(String superPowers[]) {
4 this.superPowers = superPowers;
5 }
6 void printSuperPowers() {
7 for (int i = 0; i < superPowers.length; i++) {
8 System.out.println(superPowers[i]);
9 }
10 }
11 abstract void displayPower();
12 }
13 //continued... 47
 Java Program Structure: Abstract
Classes and Methods
1 class FlyingSuperHero extends SuperHero {
2 void displayPower() {
3 System.out.println("Fly...");
4 }
5 }
6

7 class Spiderman extends SuperHero {

8 void displayPower() {
9 System.out.println("Communicate with sea" +
10 " creatures...");
11 System.out.println("Fast swimming ability...");
12 }
13 } 48
Interface

49
Java Program Structure: Interface
● Syntax:
<interfaceDeclaration> ::=
<modifier> interface <name> {
<attributeDeclaration>*
[<modifier> <returnType> <name>
(<parameter>*);]*
}

● Members are public when the interface is declared

public

50
 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
51
 Java Program Structure: Interface
1 interface MyInterface {
2 void iMethod();
3 }
4

5 class MyClass1 implements MyInterface {

6 public void iMethod() {
7 System.out.println("Interface method.");
8 }
9 void myMethod() {
10 System.out.println("Another method.");
11 }
12 }
13 //continued... 52
Java Program Structure: Interface
14 class MyClass2 implements MyInterface {
15 public void iMethod() {
16 System.out.println("Another implementation.");
17 }
18 }
19 class InterfaceDemo {
20 public static void main(String args[]) {
21 MyClass1 mc1 = new MyClass1();
22 MyClass2 mc2 = new MyClass2();
23 mc1.iMethod();
24 mc1.myMethod();
25 mc2.iMethod();
26 }
53
27 }
“this” keyword

54
 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

55
 Java Program Structure:
The this Keyword
● Disambiguate local attribute from a local variable
1 class ThisDemo1 {
2 int data;
3 void method(int data) {
4 this.data = data;
5 /*
6 this.data refers to the attribute
7 while data refers to the local variable
8 */
9 }
10 }

56
 Java Program Structure:
The this Keyword
● Refer to the object that invoked the non-static
method
1 class ThisDemo2 {
2 int data;
3 void method() {
4 System.out.println(data); //this.data
5 }
6 void method2() {
7 method(); //this.method();
8 }
9 }

57
 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) {}
}
58
 Java Program Structure:
The this Keyword
● Refer to other constructors
1 class ThisDemo3 {
2 int data;
3 ThisDemo3() {
4 this(100);
5 }
6 ThisDemo3(int data) {
7 this.data = data;
8 }
9 }
● Call to this() should be the first statement in 59
constructor
“super” keyword

60
 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 {
2 String firstName;
3 String lastName;
4 Person(String fname, String lname) {
5 firstName = fname;
6 lastName = lname;
7 }
61
8 }
 Java Program Structure:
The super Keyword
9 //continuation...
10 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
62
 Java Program Structure:
The super Keyword
● Referring to superclass members
1 class Superclass{
2 int a;
3 void display_a(){
4 System.out.println("a = " + a);
5 }
6 }
7

8 //continued...

63
 Java Program Structure:
The super Keyword
9 class Subclass extends Superclass {
10 int a;
11 void display_a(){
12 System.out.println("a = " + a);
13 }
14 void set_super_a(int n){
15 super.a = n;
16 }
17 void display_super_a(){
18 super.display_a();
19 }
20 }
64
 Java Program Structure:
The super Keyword
21 class SuperDemo {
22 public static void main(String args[]){
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 } 65
“static” keyword

66
 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
67
 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

68
 Java Program Structure:
The static Keyword
1 class Demo {
2 static int a = 0;
3 static void staticMethod(int i) {
4 System.out.println(i);
5 }
6 static { //static block
7 System.out.println("static block");
8 a += 1;
9 }
10 }
11

12 //continued...
69
 Java Program Structure:
The static Keyword
13 class StaticDemo {
14 public static void main(String args[]) {
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 } 70
 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++;

71
“final” keyword

72
 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 {}
73
● class WrongClass extends MyClass {}
 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

74
Inner Classes

75
 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

76
 Java Program Structure: Inner
Classes
● Methods of the inner class can directly access
members of the outer class
– Example:
1 class Out {
2 int OutData;
3 class In {
4 void inMeth() {
5 OutData = 10;
6 }
7 }
8 }

77
 Java Program Structure: Inner
Classes
1 class OuterClass {
2 int data = 5;
3 class InnerClass {
4 int data2 = 10;
5 void method() {
6 System.out.println(data);
7 System.out.println(data2);
8 }
9 }
10

11 //continued...

78
 Java Program Structure:
9 public static void main(String args[]) {
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 }

79
 Summary
●
Object-Oriented
Concepts – Package
– Object-Oriented – Encapsulation
Design
– Abstraction
– Class
– Inheritance
– Object
– Polymorphism
– Attribute
– Interface
– Method
– Constructor

80
 Summary
●
Java Program
Structure – Inheritance
– Declaring Java Classes – Overriding Methods
– Declaring Attributes – Abstract Classes and
– Declaring Methods Methods
– Declaring a – Interface
Constructor – The this Keyword
– Instantiating a Class – The super Keyword
– Accessing Object – The static Keyword
Members
– The final Keyword
– Packages 81
– Inner Classes