JEDI Slides-Intro2-Chapter01-Review of Basic Concepts in Java

7/29/2019 JEDI Slides-Intro2-Chapter01-Review of Basic Concepts in Java

1/62

Introduction to Programming 2 1

1 Review of Basic Conceptsin Java


2/62


Topics

? Object-Oriented Concepts

? Java Program Structure


3/62


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


4/62


Object-Oriented Concepts? Object

An entity that has a state, behavior and identity with a well-definedrole in problem space

An actual instance of a class

Created everytime you instantiate a class using the newkeyword.

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



5/62


Object-Oriented Concepts

? Method

Describes the behavior of an object

Also called a function or a procedure


? Constructor

Method-like

For creating and initializing a new object Not members of an object


6/62



? Package

Grouping of classes and/or subpackages

Analogous to a directory

? Encapsulation

Principle of hiding design or implementation information not relevantto the current object

? Abstraction

Ignoring aspects of a subject not relevant to the current purpose tofocus on those that are


7/62



? Inheritance

Relationship between classes wherein one class is the superclass orthe parent class of another

Refers to the properties and behaviors received from an ancestor Also know as a "is-a" relationship

SuperHero

Superman Spiderman Powerpuff

Blossom Buttercup Bubbles

SuperHero

Superman Spiderman Powerpuff

Blossom Buttercup Bubbles


8/62



? 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 constantdeclarations

Implementing class promises to follow the contract.


9/62


Java Program Structure:

Declaring Classes? Syntax

::=

class {

*

*

*

}

where

Modifier

? Refers to an access modifier or other types of modifiers

Name

? Is an identifier for the name of the class


10/62



Declaring Classes1 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 }


12/62



Declaring Attributes1 public class AttributeDemo {

2 private String studNum;

3 public boolean graduating = false;

4 protected float unitsTaken = 0.0f;

5 String college;

6 }


13/62



Declaring Methods? Syntax:

::=

(*) {

*

}

::=

[,]


14/62



Declaring Methods1 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 }


15/62



Declaring a Constructor? Syntax:

::=

(*) {

*}

where

Modifier

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

? Default constructor

No arguments

Empty body


16/62



Declaring a Constructor1 class ConstructorDemo {

2 private int data;

3 public ConstructorDemo() {

4 data = 100;5 }

6 ConstructorDemo(int data) {

7 this.data = data;

8 }

9 }


17/62



Instantiating a Class? Syntax:new ()

? 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 }


18/62



Accessing Object Members? Dot notation:

.

? 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);


19/62


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 }


10 ConstructObj obj = new ConstructObj();

11 obj.setData = 10; //access setData()

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

13 }

14 }


20/62



Packages? Syntax for indicating that the code belongs to a package: ::=

package ;

? Syntax for importing other packages:

::=

import ;

? Source code format:

[]

*

+


21/62



Packages1 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 }


22/62



The Access Modifiers


23/62

Introduction to Programming 223

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 }


24/62



Inheritance? Creating a child class or a subclass: Use extends in declaring the class

Syntax:

class extends

? A class can only extend one parent class


25/62



Inheritance1 import java.awt.*;2

3 class Point {

4 int x;

5 int y;

6 }

7

8 class ColoredPoint extends Point {

9 Color color;10 }


26/62



Overriding Methods? Subclass defines a method whose signature is identical to amethod 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!


27/62



Overriding Methods1 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...


28/62



Overriding Methods14 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 }


29/62



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


30/62



Overriding Methods1 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...


31/62



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 }


32/62



Abstract Classes and Methods? Syntax:abstract

(*);

? Class containing an abstractmethod should be declaredabstract

abstract class {

/* constructors, fields and methods */

}


33/62



Abstract Classes and Methods? abstractkeyword is not for: Constructor

static method

? Classes that extends an abstract class:

Should implement all abstractmethods

Otherwise, the subclass itself should be declared abstract


34/62


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


Abstract Classes and Methods


35/62


36/62



Interface? Syntax: ::=

interface {

*

[

(*);]*

}

? Members are publicwhen the interface is declared public


37/62


Java Program Structure:Interface

? Interface attributes:

Implicitly staticand final

Must be initialized

? Modifiers:

Access modifiers: public, package

Must be initialized

? Implementing an interface: Use implementskeyword

Should implement all the interface's methods

A class can implement several interfaces


38/62


39/62


Java Program Structure:Interface

14 class MyClass2 implements MyInterface {

15 public void iMethod() {

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

17 }

18

}19 class InterfaceDemo {


21 MyClass1 mc1 = new MyClass1();

22 MyClass2 mc2 = new MyClass2();

23 mc1.iMethod();

24 mc1.myMethod();

25 mc2.iMethod();

26 }

27 }


40/62



The thisKeyword? 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


41/62



The thisKeyword? Disambiguate local attribute from a local variable1 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 }


42/62



The thisKeyword? Refer to the object that invoked the non-static method1 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 }


43/62



The thisKeyword? 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) {}

}


44/62



The thisKeyword? Refer to other constructors1 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


45/62


Java Program Structure:The superKeyword

? Related to inheritance

Invoke superclass constructors

Can be used like the thiskeyword to refer to members of thesuperclass

? 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 }

8 }


46/62


47/62



The superKeyword? Referring to superclass members1 class Superclass{

2 int a;

3 void display_a(){

4 System.out.println("a = " + a);

5 }

6 }

7

8 //continued...


48/62



The superKeyword9 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 }


49/62



The superKeyword21 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 }


50/62



The staticKeyword? Applied to members of a class: Attributes

Methods

Inner classes

? Allows accessing of static or class members withoutinstantiation

? Class variables

Behave like a global variable

Can be accessed by all instances of the class


51/62



The staticKeyword? Class methods May be invoked without creating an object of its class

Can only access static members of the class

Cannot refer to thisorsuper

? staticblocks

Executed only once, when the class is loaded

For initializing class variables


52/62



The staticKeyword1 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...


53/62



The staticKeyword13 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 }


54/62



The finalKeyword? Applied to variables, methods and classes

? Restricts what we can do with the variables, methods andclasses

? finalvariable

Cannot be modified once its value has been set

Example:

final int data = 10;

data++;


55/62


Java Program Structure:The finalKeyword

? finalmethod Cannot be overridden

Example:

final void myMethod() { //in a parent class

}void myMethod() { //in a child class

}

? finalclass

Cannot be inherited

Example:

final public class MyClass {}

class WrongClass extends MyClass {}


56/62



The finalKeyword? Keyword may be placed before after other modifierspublic final static void meth() {} or

final public static void meth() {} or ...

//order of modifiers is not important


57/62



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


58/62



Inner Classes? Methods of the inner class can directly access members ofthe outer class

Example:

1 class Out {

2 int OutData;

3 class In {

4 void inMeth() {

5 OutData = 10;

6 }

7 }

8 }


59/62



Inner Classes1 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...


60/62




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 }


61/62


62/62


Summary

? Java Program Structure

Declaring Java Classes

Declaring Attributes

Declaring Methods

Declaring a Constructor

Instantiating a Class

Accessing Object Members

Packages The Access Modifiers

Encapsulation

Inheritance

Overriding Methods

Abstract Classes and Methods

Interface

The this Keyword

The super Keyword

The staticKeyword The f inalKeyword

Inner Classes

JEDI Slides-Intro2-Chapter01-Review of Basic Concepts in Java

Documents

Transcript of JEDI Slides-Intro2-Chapter01-Review of Basic Concepts in Java