Arrays

Objectives

 Declare and create arrays of primitive, class

or array types
 How to initialize the elements of an array
 No of elements in the array
 Create a multi-dimensional array
 Write code to copy array values from one
array type to another
 Declaring Arrays

 Group data Objects of the same type

 Declare arrays of primitive or class types
char s[];
Point p[]; //Where point is a class

char[] s;
Point[] p;
 Create space for a reference
 An array is an object; it is created with new
 Creating Arrays

 Use the new Keyword to create an array object

 Example
Execution Stack
public char[] createArray(){ Heap Memory
char[] a;
char
a = new char[26]; A
for(int i =0;i<26;i++){ B
a C
a[i]=‘A’+i; createArray this
} main Z
return a;
}
 Creating Arrays

 Object Array
public Point[] createArray(){
Point[] p; Execution Stack
p = new Point[10]; Heap Memory
for(int i =0;i<26;i++){
p[i]=new Point(I,I+1); Point[] Point
x
} y
return p; p x
createArray this y
}
main x
y
 Initialize Arrays

String names[]; String names[]={

names=new String[3]; “George”,”Jen”,”Simon”
names[0]=“George”; };
names[1]=“Jen”;
names[2]=“Simon”;

MyDate date[]; MyDate dates[]={

dates=new MyDate[2]; new MyDate(22,7,1976),
dates[0]=new new MyDate(22,12,1974)
MyDate(22,7,1976); };
dates[1]=new
MyDate(22,12,1974);
 Multi-Dimensional Arrays

 Arrays of arrays
int twoDim[][] = new int[4][];
twoDim[0]=new int[5];
twoDim[1]=new int[5];

int twoDim[][]=new int[][4]; //illegal

 Multi-Dimensional Arrays

 Non-rectangular array of arrays

twoDim[0] =new int[2];
twoDim[1]=new int[4];
twoDim[2]=new int[6];
twoDim[3]=new int[8];
 Shorthand to create 2 Dimensional arrays
int twoDim[] = new int[4][5];
 Array Bounds

 All array subscripts begin at 0

int list[]=new int[10];
for(int i = 0;i<list.length;i++){
System.out.println(list[i]);
}
 Array Resizing

 Cannot Resize an Array

 Can use the same reference variable to refer
to an entirely new array
int elements[] = new int[6];
elements = new int[10];
 In this case, the first array is effectively lost unless

another reference to it is retained elsewhere.

 Copying Arrays

 The System.arrayCopy() method

//original Copy
int elements[]={1,2,3,4,5,6};
//new larger array
int hold[]={10,9,8,7,6,5,4,3,2,1};
//Copy all of the elements array to the
//hold array starting at 0 th index
System.arrayCopy(elements,0,hold,0,elements.length);
Inheritance
 The is a Relationship

 The Employee Class

public class Employee{
Employee public String name=“”;
public double salary;
+name: String=“”
public Date birthDate;
+salary:double
+birthDate:Date public String getDetails(){
----
+getDetails():String }
}
 The is a Relationship

 The Manager Class

public class Manager{
Manager public String name=“”;

+name: String=“” public double salary;

+salary:double public Date birthDate;
+birthDate:Date public String department;
+department:String
public String getDetails(){
+getDetails():String ----
}
}
 The is a Relationship
Employee public class Employee{
public String name=“”;
+name: String=“” public double salary;
+salary:double public Date birthDate;
+birthDate:Date
public String getDetails(){---}
}
+getDetails():String

public class Manager extends Employee{

Employee
public String department=“”;
+department:String=“”
}
 Single Inheritance

 When a class inherits from only one class, it

is called single inheritance
 Single Inheritance makes code more reliable
 Interfaces provide the benefits of multiple
inheritance without drawbacks
 Constructors are not inherited

 A subclass inherits all methods and variables

from the super class (parent class)
 A subclass does not inherit the constructor
from the super class
 Note-
 A Parent constructor is always called in addition
to a child Constructor
 Polymorphism

 Polymorphism is the ability to have different forms.

 An object has only one form
 A reference variable can refer to objects of different
forms
Employee emp1=new Manager();

//Illegal attempt to assign Manager attribute

Emp1.department=“Sales”
 Heterogeneous Collections

 Collection of objects of the same class type are called

homogeneous Collection
MyDate[] dates=new MyDate[2];
dates[0]=new MyDate(22,12,1976);
dates[1]=new MyDate(22,7,1974);
 Collection of objects with different class types are called
heterogeneous collections
Employee[] staff = new Employee[1024];
Staff[0]=new Manager();
Staff[1]=new Employee();
Staff[2]=new Engineer();
 Polymorphic Arguments

 Because a manager is an Employee

//in the Employee class
public TaxRate findTaxRate(Employee e){
--
}
//elsewhere in the application class
Manager m = new Manager();
:
TaxRate t = findTaxRate(m);
 The instanceof Operator
public class Employee extends Object
public class Manager extends Employee
public class Engineer extends Employee
---------------------------------------
public void doSomething(Employee e){
if(e instanceof Manager){
//Process a Manager
}
else if(e instanceof Engineer){
//Process an Engineer
}
else{
//Process other type of Employee
}
}
 Casting Objects

 Use instanceof to test the type of an object

 Restore full functionality of an Object casting
 Check for proper casting using the following
guidelines
 Casts up hierarchy are done implicitly
 Downward casts must be to sub class and checked by the
compiler
 The object type is checked at runtime when runtime
errors can occur
 The has a Relationship

public class Vehicle{

private Engine theEngine;
Truck 1 Engine public Engine getEngine(){
return theEngine;
}
}
 Access Control

 Variables and Methods can be at one of four access

levels; public, protected, default or private.
 Classes can be public or default

Modifier Same Class Same Pkg Subclass Universe

public Yes Yes Yes Yes
protected Yes Yes Yes
default Yes Yes
private Yes
Protected access is provided to subclasses in different Packages
 Overloading Method Names

 Example
public void println(int i);
public void println(float f);
public void println(String s);

 Argument lists must differ

 Return types can be different
 Overloading Constructors

 As with methods constructors can be

overloaded
 Example
public Employee(String name, double salary, Date dob)
public Employee(String name, double salary)
public Employee(String name, Date dob)
 Argument list must differ
 The this reference can be used at the first line of a constructor to call
another constructor
 Overriding Methods

 A subclass can modify behavior inherited

from a parent class
 A subclass can create a method with different
functionality than the parent’s method with
the same
 Name
 Return Type
 Argument List
 Overriding Methods

 Virtual method invocation

Employee e = new Manager();
e.getDetails();
 Compile-time type and runtime type
 Rules about Overridden Methods

 Must have a return type that is identical to

the method it overrides
 Cannot be less accessible than the method it
overrides
 The super Keyword

 super is used in a class to refer to its

superclass
 super is used to refer to the members of
superclass, both data attributes and methods
 Behavior invoked does not have to be in the
superclass, it can be further up in the
hierarchy
 Invoking Parent Class Constructors

 To invoke a parent constructor you must place a

call to super in the first line of the Constructor
 You can call a specific parent constructor by the
arguments that you use in the call to super
 If no this or super call is used in a constructor, then
an implicit call to super() is added by the compiler
 If the parent class does not supply a non-private
“default” constructor, then a compiler warning will be
issued
 Constructing and Initializing
Objects
 Memory is allocated and default initialization
occurs
 Instance variable initialization uses these steps
recursively
1. Bind Constructor parameters
2. If explicit this(), call recursively and skip to step 5
3. Call recursively the implicit or explicit super call,
except for Object
4. Execute explicit instance variable initializes
5. Execute the body of the current Constructor
 The Object class

 The Object class is the root of all classes in

Java
 A class declaration with no extends clause,
implicitly uses “extends Object”
 The == Operator Vs equals
Method
 The = = operator determines is two references are
identical to each other
 The equals method determines if objects are
equal.
 User classes can override the equals method to
implement a domain-specific test for equality
 Note: You should override the hashcode method, if
you override the equals method
 toString Method

 Converts an Object to a String

 Used during string concatenation
 Override this method to provide information about
a user-defined object in readable format
 Primitive types are converted to a String using
the wrapper class’s toString static method
 Wrapper Classes

Primitive Wrapper Class

boolean Boolean
byte Byte
char Character
short Short
int Integer
long Long
float Float
double Double