Developing Applications for Android - Lecture#2

Developing Applications
for Android

Muhammad Usman Chaudhry
SZABIST CS4615

Lecture # 2

Today - OOP Revision
● Classes & Obejcts Overview
● Nested Classes
○ Static nested & Inner classes
○ Local & anonymous classes
● Inheritance
● Method Overriding & Dynamic Polymorphism
● Abstraction
● Interfaces
● Packages
● Annotations & Javadocs

Muhammad Usman Chaudhry CS4615 SZABIST

Today - Design Patterns
● Design Patterns Overview
● Context Pattern
● Adapter Pattern
● Separation of Concerns
○ Model-View-Controller


Classes & Objects
● Coming code example will explain:
○ Classes
○ Objects
○ Encapsulation
○ Constructors
○ Class Members & Methods
○ Instance Members & Methods
○ Entry Point
○ Getter & Setters


//Student.java
class Student{ Access
Modifier Attribute
private String studentName;
Static
private static int count; Member
Not Recommended Setter
public void setStudentName(String _studentName){
if(!_studentName.equals("")) this.studentName = _studentName;
}
Validation
Getter
public String getStudentName(){
return this.studentName;
}
Instance
Method
public String getEncodedUrlForStudentName(){
return UrlEncoder.encode(this.getStudentName(),"UTF-8");
}
...


...
Class Method
public static int getCount(){
return Student.count;
}
Default Constructor
public Student(){
Calling 1-argument
this("No Name"); constructor
} 1-argument
public Student(String studentName){ Constructor
this.setStudentName(studentName);
} Entry Point
public static void main(String[] args){
Object of Type
Student stduent = new Student();
Student
String name = student.getName();
int count = Student.getCount(); Instance Method
Call
}
} Class Method Call


Nested Classes
● Java allows defining class within another class.
● Nested classes are divided into 2 more
categories:
○ Static Nested Classes (Declared Static)
○ Inner Nested Classes (Non-static)
■ Local Classes
■ Anonymous Classes
○ Both Inner & Static nested classes have
member scope.
● Examples & Uses are in coming slides.


Example: Static & Inner Nested Classes
//Outer class can only be public or package-private
class OuterClass{
private int someVariable;
//Modifier can be private, protected, public or package-private
static class StaticNestedClass{
//Cannot access private members of outer class directly.
}
class InnerClass{
//Can access private members of outer class
OuterClass oc = OuterClass.this; // implicit reference available
int a = oc.someVariable; //can be done
int b = OuterClass.this.someVariable; //is another way to access...
}
//Cannot declare static members within inner nested class.
}


Example: Accessing Nested Inner Class

//Accessing Nested Inner Class
OuterClass oc = new OuterClass(); //Either create new object or use previous instance
OuterClass.InnerClass innerClassObject = oc.new InnerClass(); //Way#1
OuterClass.InnerClass innerClassObject = new OuterClass().new InnerClass(); //Way#2

● Way#1 is using previous instance so all
values of the object of outer class will be
intact and accessible via inner class.
● Way#2 is creating new instance of outer
class as well.


Example: Accessing Nested Static Class

//Accessing Nested Static Class
OuterClass.StaticNestedClass sncObj = new OuterClass.StaticNestedClass();

● As simple as creating the normal object. No
added syntax.


Local & Anonymous Inner Classes
● Inner class within 'body' of a method is
known as local inner class.
● Inner class within 'body' of a method
without naming it is known as anonymous
inner class.
● Scope of local inner class is local to
function.
● Scope of anonymous inner class is only to
the point where it's declared.


Example: Local Inner Class

class OuterClass{
private int someVariable;
public OuterClass(){
//Local inner classes don't specify access modifiers
class LocalInnerClass{
public void myInnerMethod(){
//implicit reference available to access members of outer class...
int count = OuterClass.this.someVariable;
}
}
LocalInnerClass lic = new LocalInnerClass();
lic.myInnerMethod();
}
}


Example: Anonymous Inner Class

public void someFunction(){ class RunnableThread implements Runnable{
new Thread(new Runnable(){ RunnableThread(){
@Override //do something in constructor
public void run(){ }
//do something here... public void run(){
} //do something here...
}).start(); }
} }
.
.
//To access it
RunnableThread myThread = new RunnableThread();
new Thread(myThread).start();

● Left (Anonymous) Vs Right (Normal)
● No clutter in coding


Why Use Nested Classes
● Logically grouping classes together.
● Increase encapsulation.
● Clean coding.


Important
● Java don't have anything exactly similar to
Objective-C or .Net delegates, the closest
thing is anonymous inner class which are
used instead of delegates.
● The main trick is to create an interface
with a single function and then implement
it via anonymous inner class.


Inheritance
● When you want to create a new class and there is
already a class that includes some of the code that you
want, you can derive your new class from the existing
class.
● A class that is derived from another class is called sub-
class, inherited class (derived, extended, child etc.)
● Java does support multi-level inheritance.
● There is no support for multiple inheritance in Java
and every class can extend up to one class at a time.
● Lets go through examples in next slides.


//A bicycle class : Example taken from Oracle Docs...
public class Bicycle {
public int cadence; public int gear; public int speed;
public Bicycle(int startCadence, int startSpeed, int startGear) {
gear = startGear;
cadence = startCadence;
speed = startSpeed;
}
public void setCadence(int newValue) {
cadence = newValue;
}
public void setGear(int newValue) {
gear = newValue;
}
public void applyBrake(int decrement) {
speed -= decrement;
}
public void speedUp(int increment) {
speed += increment;
}
}


public class MountainBike extends Bicycle {
// the MountainBike subclass adds
// one field
public int seatHeight;

// the MountainBike subclass has one
// constructor
public MountainBike(int startHeight,
int startCadence,
int startSpeed,
int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}

// the MountainBike subclass adds
// one method
public void setHeight(int newValue) {
seatHeight = newValue;
}
}


Method Overriding & Dynamic Polymorphism

● Redefining superclass method in subclass.
● An instance method in subclass with the same signature
(name, number, type of params & return type) as instance
method in superclass overrides the superclass's method.
● We may access the functionality of methods and members
of super class via 'super' keyword.
● In case reference variable is calling an overridden method
the method to be invoked is determined by the object, your
reference variable is pointing to. (dynamic polymorphism).
● Examples to follow in coming slides.


//Class professional //Calling all
class Professional { Professional p = new Professional();
public String name;
public Professional(){
Programmer prog = new Programmer();
}
public boolean isDisciplined(){
//professional level implementations p.isDisciplined();//Normal call
}
} //First professional is called, then
//programmer's isDisciplined is called.
//Class programmer prog.isDisciplined();
class Programmer extends Professional{
public Programmer(){
//without super.isDisciplined() statement
}
@Override //calling prog.isDisciplined(); will only call
public boolean isDisciplined(){ //programmer's isDisciplined() method.
//professional rules also apply
super.isDisciplined(); //dynamic polymorphism
//programmer level implementations Professional pr = new Programmer();
}
pr.isDisciplined();
}


Abstraction
● An abstract class cannot be instantiated.
● Abstract class can be subclassed.
● An abstract method, only has signatures.
● If any class has abstract methods it must be declared
abstract itself.
● Subclass must implement all the abstract methods of
abstract class otherwise it must be declared abstract
as well.
● Abstract class may also contain abstract methods.
● Examples in next slides.


//Abstract class example //Implementation
abstract class GraphicObject { class Circle extends GraphicObject {
int x; void draw() {
int y;
//circle specific implementation
void moveTo(int newX, int newY) {
//some implementation
}
} void resize() {
abstract void draw(); //circle specific resize
abstract void resize(); }
} }
class Rectangle extends GraphicObject {
void draw() {
//rectangle specific implementation
}
void resize() {
//rectangle specific resizing
}
}


Interfaces
● Interfaces are implemented by other classes
and extended by other interfaces.
● Unlike class inheritance an interface can
extend multiple interfaces.
● Interface body contains signatures only.
● All methods in an interface are implicitly
public.
● Example to follow.


//Interface example //Implementation
public Interface GraphicInterface { class Circle implements GraphicInterface {
void draw(); void draw() {
void resize();
//circle specific implementation
}
}
void resize() {
//circle specific resize
}
}
class Rectangle extends GraphicInterface {
void draw() {
//rectangle specific implementation
}
void resize() {
//rectangle specific resizing
}
}


Abstract Class Vs Interface
● Abstract class can contain fields that are
not static & final.
● Similarly abstract class can contain
implementations, while interface is
signature only.
● One class can implement multiple
interfaces. While the same class cannot
extend multiple abstract classes.


Packages
● Grouping similar classes together is called
package.
● It's similar to that of namespace in .Net
● An example would be custom controls
related classes are in controls package, or
graphics related classes in graphics package
etc.
● import statement is used to include
packages.
● Examples to follow.

//Package example
//Sample package
package net.thepaksoft.appname; //current package

//all graphics related customized classes
import net.thepaksoft.appname.graphics.*;

//ListView class
import net.thepaksoft.appname.controls.ListView;


Annotations & Javadocs
● Annotation provide data about code, they
don't have direct impact over it.
● Annotations are mostly used for:
○ Information for compiler. //Suppress warnings etc.
○ Compile time & deploy time processing.//Code generation.
○ Runtime processing.//Examination at runtime
● Annotations are used in comments for
Javadocs to generate automatic
documentation against code.
● Examples to follow.


// Javadoc comment follows
/**
* @deprecated
* explanation of why it
* was deprecated
*/
@Deprecated
static void deprecatedMethod() { }
}

// mark method as a superclass method
// that has been overridden
@Override
int overriddenMethod() { }
// use a deprecated method and tell
// compiler not to generate a warning
@SuppressWarnings("deprecation")
void useDeprecatedMethod() {
// deprecation warning
// - suppressed
objectOne.deprecatedMethod();
}


Design Patterns
● They're used to solve the common problems.
● Classical design patterns include 3 categories and 23
patterns:
○ Creational - Deals with creation of object.
○ Structural - Deals with structure of object/class.
○ Behavioral - Communication between objects
● Bad patterns or approaches are known as anti-
patterns as well.
● There are 100s of other patterns.
● We'll study the most relevant and commonly used
under android.


Context Pattern in Android
● Interface to global information about application
environment.
● It maintains current state of application/object.
● Mostly used to get information about other part of
program.
● Used to access standard common resources.
● Used to access components implicitly.
● Implemented by Android System to provide access to
application specific resources and classes.


Context Pattern in Android
● We may get context by invoking any of these:
○ getApplicationContext()
○ getContext()
○ getBaseContext()
○ this (Current activity)
● And use above like:
○ ListAdapter adapter = new SimpleCursorAdapter(getApplicationContext(),...);
○ getApplicationContext().getSharedPreference(name,mode);


Adapter Pattern in Android
● Aimed at binding view with data.
● When your data changes your view changes as well.
● No need to add/update data one by one into the view.
● Android have following implementations for Adapter:
○ BaseAdapter inherits Adapter implements
ListAdapter, SpinnerAdapter
○ ArrayAdatper
○ ResrouceCursorAdapter


Adapter Pattern Android (Code)

ArrayList<HashMap> myList = new ArrayList<HashMap>();
String[] data = new String[] { "line1","line2" } ;
int[] idList = new int[] { R.id.text1, R.id.text2 } ;
SimpleAdapter dataToView = new SimpleAdapter(this,
myList, R.layout.two_lines, data, idList);
setListAdapter( dataToView );


Separation of Concerns
● Appropriate layered approach
● Separate Presentation, Business Logic, from
Design
● Partial classes, under Smalltalk, .Net &
Ruby
● MVC, MVP, MVVM etc. Patterns


MVC - Model-View-Controller
● UI Presentation pattern
● Separates View (UI) from Model (Business
Logic)
● Separation of Concerns:
○ View is responsible for rendering UI.
○ Model is responsible for business behavior.
○ Controller is responsible for responding to UI
Actions & communication between Model & View.
● All 3 can directly communicate with each
other.


MVC - Model-View-Controller
● Implementations as discussed in previous
slides exist in many web frameworks like
Rails & Yii etc.
● Implementation varies in some frameworks
like Cocoa Touch, where:
○ Controller is used as communication bridge
between Model & Views, as mentioned previously
but Models & Views cannot communicate directly.
○ Views don't have knowledge of Model.
○ Models have no knowledge of Views.


MVC in Android
● MVC is kind of built into Android
● You may create as many 'Model' classes you
like to represent the business data.
● 'Views' are there in form of XML Layouts.
● 'Controllers' are there in form of Activity
classes.


That's All for Today
● Have great vacations & Eid Mubarak!


Coming Up Next Week
● Dive into Android.
○ Hello World
○ SDK
○ File Organization
○ AVD
○ DDMS
○ LogCat
○ Debugging
○ Manifest
○ And Much more...
● Totally interactive class.


Developing Applications for Android - Lecture#2

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Similar to Developing Applications for Android - Lecture#2

Similar to Developing Applications for Android - Lecture#2 (20)

Recently uploaded

Recently uploaded (20)

Developing Applications for Android - Lecture#2