1 Review of Basic Concepts
in Java
I nt roduct ion t o Program m ing 2 1
Topics
Ç Object-Oriented Concepts
Ç Java Program Structure
I nt roduct ion t o Program m ing 2 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
I nt roduct ion t o Program m ing 2 3
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 everytime 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
I nt roduct ion t o Program m ing 2 4
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
I nt roduct ion t o Program m ing 2 5
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
I nt roduct ion t o Program m ing 2 6
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
I nt roduct ion t o Program m ing 2 7
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.
I nt roduct ion t o Program m ing 2 8
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
I nt roduct ion t o Program m ing 2 9
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 }
I nt roduct ion t o Program m ing 2 10
Java Program Structure:
Declaring Attributes
Ç Syntax:
<attributeDeclaration> ::=
<modifier> <type> <name> [= <default_value>];
<type> ::=
byte | short | int | long | char | float | double
| boolean | <class>
I nt roduct ion t o Program m ing 2 11
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 }
I nt roduct ion t o Program m ing 2 12
Java Program Structure:
Declaring Methods
Ç Syntax:
<methodDeclaration> ::=
<modifier> <returnType> <name>(<parameter>*) {
<statement>*
}
<parameter> ::=
<parameter_type> <parameter_name>[,]
I nt roduct ion t o Program m ing 2 13
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 }
I nt roduct ion t o Program m ing 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
I nt roduct ion t o Program m ing 2 15
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 }
I nt roduct ion t o Program m ing 2 16
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 }
9 }
I nt roduct ion t o Program m ing 2 17
Java Program Structure:
Accessing Object Members
Ç
Dot not at ion:
<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);
I nt roduct ion t o Program m ing 2 18
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 }
14 } I nt roduct ion t o Program m ing 2 19
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>+
I nt roduct ion t o Program m ing 2 20
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 }
I nt roduct ion t o Program m ing 2 21
Java Program Structure:
The Access Modifiers
I nt roduct ion t o Program m ing 2 22
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 }
I nt roduct ion t o Program m ing 2 23
12 }
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
I nt roduct ion t o Program m ing 2 24
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 }
I nt roduct ion t o Program m ing 2 25
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!
I nt roduct ion t o Program m ing 2 26
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...
I nt roduct ion t o Program m ing 2 27
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 }
I nt roduct ion t o Program m ing 2 28
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
I nt roduct ion t o Program m ing 2 29
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...
I nt roduct ion t o Program m ing 2 30
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 }
I nt roduct ion t o Program m ing 2 31
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 */
}
I nt roduct ion t o Program m ing 2 32
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
I nt roduct ion t o Program m ing 2 33
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...
I nt roduct ion t o Program m ing 2 34
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 }
I nt roduct ion t o Program m ing 2 35
Java Program Structure:
Interface
Ç Syntax:
<interfaceDeclaration> ::=
<modifier> interface <name> {
<attributeDeclaration>*
[<modifier> <returnType> <name>
(<parameter>*);]*
}
Ç Members are public when the interface is declared public
I nt roduct ion t o Program m ing 2 36
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
I nt roduct ion t o Program m ing 2 37
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...
I nt roduct ion t o Program m ing 2 38
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 }
27 } I nt roduct ion t o Program m ing 2 39
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
I nt roduct ion t o Program m ing 2 40
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 }
I nt roduct ion t o Program m ing 2 41
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 }
I nt roduct ion t o Program m ing 2 42
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) {}
}
I nt roduct ion t o Program m ing 2 43
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 constructor
I nt roduct ion t o Program m ing 2 44
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 }
I nt roduct ion t o Program m ing 2 45
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
I nt roduct ion t o Program m ing 2 46
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...
I nt roduct ion t o Program m ing 2 47
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 }
I nt roduct ion t o Program m ing 2 48
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 }
I nt roduct ion t o Program m ing 2 49
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
I nt roduct ion t o Program m ing 2 50
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
I nt roduct ion t o Program m ing 2 51
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...
I nt roduct ion t o Program m ing 2 52
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 }
I nt roduct ion t o Program m ing 2 53
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++;
I nt roduct ion t o Program m ing 2 54
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 {}
I nt roduct ion t o Program m ing 2 55
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
I nt roduct ion t o Program m ing 2 56
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
I nt roduct ion t o Program m ing 2 57
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 }
I nt roduct ion t o Program m ing 2 58
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...
I nt roduct ion t o Program m ing 2 59
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 }
I nt roduct ion t o Program m ing 2 60
Summary
Ç
Obj ect - Orient ed Concept s
– Obj ect - Orient ed Design – Package
– Class – Encapsulat ion
– Obj ect – Abst ract ion
– At t ribut e – I nherit ance
– Met hod – Polym orphism
– Const ruct or – I nt erface
I nt roduct ion t o Program m ing 2 61
Summary
Ç
Java Program St ruct ure
– Declaring Java Classes – I nherit ance
– Declaring At t ribut es – Overriding Met hods
– Declaring Met hods – Abst ract Classes and Met hods
– Declaring a Const ruct or – I nt erface
– I nst ant iat ing a Class – The t his Keyw ord
– Accessing Obj ect Mem bers – The super Keyword
– Packages – The st at ic Keyword
– The Access Modifiers – The final Keyw ord
– Encapsulat ion – I nner Classes
I nt roduct ion t o Program m ing 2 62
