INTRODUCTION TO JAVA

History of Java

 Java, having been developed in  1991, is a relatively new

programming language.   At that time, James Gosling from
Sun Microsystems and his team began designing the first
version of Java aimed at programming home appliances which
are controlled by a wide variety of computer processors.
     Gosling's new language needed to be accessible by a variety
of computer processors.  In 1994, he realized that such a
language would be ideal for use with web browsers and Java's
connection to the internet began.  In 1995, Netscape
Incorporated released its latest version of the Netscape
browser which was capable of running Java programs.
 Object-Oriented

OO is ubiquitous!
 Lots of commercially produced code in C++ (and Java,
Smalltalk, etc.)
Focus on data, not procedures
Encapsulates data and functions
More “natural”
Exploits inheritance
(Almost) Everything in Java is an object!
 First Java Program: Hello, World!

// This is a comment
// The file is named HelloWorld.java
public class HelloWorld {
public static void main(String args[]) {
System.out.println(“Hello World!”);
}
}
Note: If the class is public, the name of the class
(i.e., HelloWorld) must be the same as the name of
the file plus the .java extension (i.e.,
HelloWorld.java)
 println explained

What exactly is System.out.println(“...”)?

System is a class.
It has a class variable named out.
out refers to an object of type PrintStream.
PrintStream objects have an instance method
named println.
Java: The Programming Language
 How to Compile and Run

Compile a source code file by typing

javac <filename>.java (e.g., javac HelloWorld.java)

 If no compile-time error appears, a .class file is produced.

Run an application by typing

java <class name> (e.g., java HelloWorld)

Not java HelloWorld.class

 Features Similar to C/C++’s

Same comment styles

 new: /** to be processed by javadoc … */
Same literals and data types
 new: true and false for the boolean data type
 new: strings not null terminated, not mutable
 new: numeric sizes and their machine independence
Same operators
Same control structures
 Java’s Basic Constructs

Comments
 // comment on one line
 /* comment on one or more lines */
 /** documenting comments */
Statements
 int x; // statement ends with a semicolon (;)
 x = 1 + 2;
 Primitive Data Types

There are 8 primitive data types in Java

 All the numeric types (integer and floating point types) are
signed (meaning they can be positive or negative). No
unsigned numeric types in Java (unlike C/C++).
Three categories of data types:
 Primitive data types
 Class data types (coming later)
 Interface data types (coming later)
 Basic Data Types

Integers Floats

 byte (8 bits)
 float (32 bits)
 short (16 bits)
 double (64 bits)
Boolean
 int (32 bits)
 long (64 bits)  boolean (1 bit)
Characters
 char (16 bits Unicode) Strings
 String (an example of class
data type)
Primitive data types
capital case (because it is a class, not a primitive)
 Identifiers and Literals

Identifiers
 case sensitive
 have no maximum length
 start with a letter, underscore, or dollar sign
 e.g., user_name, _file, $money
Literals
 numeric: 2 (int), 3L (long), 2.0f (float) 3.14 (double), 077
(octal), 0xDC (hex)
 character: ‘a’, ‘t’
 boolean: true, false
 string: “hello”

Watch out for these!

 Booleans

Has value true or false (different from numeric type)

Returned by relational operators
Required for conditional statements
E.g.,
 // if x is an int
 C/C++: if (x) { ...} // OK in C/C++, not OK in Java
 Java: if (x == 1) { ...}
 Strings

String is a “built-in” class provided by Java

 e.g., String s1 = “Hi there!”;
The ‘+’ operator is used for String concatenation
 e.g., String s1 = “abc”;
 String s2 = s1 + “ ” + s1;
String objects represent constant strings (content
cannot be altered)
Many methods supported in the String class.
 Operators

Partial list (in order of precedence):

 ++, -- ++ (Preincrement, Postincrement) // increments a variable by 1
e.g., x = 1; System.out.println(x++); // displays 1
 !, (type) System.out.println(x); // displays 2
e.g., x = 1; System.out.println(++x); // displays 2
 *, /, % System.out.println(x); // displays 2
-- (Predecrement, Postdecrement) // decrements a variable by 1
 +, - e.g., x = 1; System.out.println(x--); // displays 1
System.out.println(x); // displays 0
 <, >, <=, >=, instanceof e.g., x = 1; System.out.println(--x); // displays 0
System.out.println(x); // displays 0
 ==, != (equal to and not equal to operators, respectively)
 && (this is the logical AND operator)
 || (this is the logical OR operator)
 =, *=, /=, +=, ...
 Looping Structures
Syntax (for):

for (initial expr; boolean expr; update expr) {

  
statements;
}

Example:
for (int k = 0; k < 10; k++)
{
System.out.println(k);
}
 Arrays

 Arrays are objects

 Like C/C++, subscripts start from 0
 No pointers in Java => no pointer arithmetic
 To create an array,
 use “new”
 e.g., int a[] = new int[5]; // creates an array of 5 ints
 same as: int [] a = new int[5];
 or array initializer
 int a[] = {1, 2, 3, 4, 5};
 To access an array element, use a[i] where 0 <= i <
arraySize
 Array boundaries are checked at runtime
 Arrays (cont’d)

The following will throw an exception (can be

caught and handled)
 e.g., int a[] = new int[5];

a[5] = 123; // array out of bound exception

Can use length to determine array size
 e.g., public void doSomething ( int a[] ) {

for (int i = 0; i < a.length; i++)

a[i] = 0;
}
Passing an int array into a method
Object-Oriented Programming
with Java
 Classes

A class is a template (i.e., blueprint) for creating

objects
A class extends another class (inheritance
relationship)
 e.g., public class className extends superclassName {
...
}
By default, all classes are derived from a single root
class called Object
All classes except Object have one immediate
superclass
 Classes (2)

// Student.java
public class Student {
private String name; // name is a field, attribute, or an instance variable
public Student(String n) { // This is a constructor. Note that it has the
name = n; // same name as the class name. More on this later.
}
public void setName (String n) {
name = n; The getter and setter methods. Typically, get
} and set methods are defined for each field.
public String getName () { If a field is named, say, workAddr, then a get
return name; method named getWorkAddr() and a set method
} named setWorkAddr(…) are created.
public void print () {
System.out.println(“Name is “+name);
}
}
 Classes (3)

// TestStudent.java (a dummy class to test the functionality of the Student

class)
public class TestStudent {
public static void main (String argv[]) {
Student s1 = new Student("Lee");
Student s2 = new Student("John");
s2.setName("John Jr.");
s1.print();
System.out.println(s2.getName()); // can also use print() here
}
}

 Note: The Student and TestStudent classes need to be in the same

directory for the above to work properly.
 Objects

Objects/instances of classes are created using “new”

 e.g., Student s = new Student(“John”);
A variable of non-primitive type actually holds
“handle” for the actual object. It is called an object
reference.
Assigning objects copies the handle, not the object.
 Objects (3)

Example:
Student s1; // s1 has the value null
s1 = new Student(“A”); s1
s1 = new Student(“B”); A

s1
A
A will be garbage collected

s1 = null; // what is the effect of this?

 Methods

Methods
 defined the behaviors of a class (called member
functions in C++)
 can only be implemented in classes (no standalone
code)
 must have a return type unless they are constructors
(which have no return type)
 must have a comma separated list of pairs of parameter
types and names (if takes no parameter, the list is
empty)
 Method Definition

Syntax: optional
[accessType] [modifier(s)] returnType methodName (parameter list) {
… // method body
}
Examples:
public static void main(String[] args) {
…
}
private int myMethod(int j, String s) {
…
}
String myMethod2( ) {
…
}
 Constructors

Special methods that have the same names as their

classes
Are invoked during the creation of an object by “new”
Constructors do not have a return type
Constructors (and methods in general) can be
overloaded by varying the number of types of
parameters
 Constructors (2)

Default constructor
 A default constructor is automatically provided for you in every
class
 Format: public MyClass() { // assume class name is MyClass
}
 Allows you to do:
MyClass mc = new MyClass( );
 Will be invalidated if you add a constructor declaration with
arguments
 Access Specifiers

As with C++, components of classes can have

associated access specifiers
 public Accessible by all
 protected Only accessible from this class, its
subclasses, and package.
 private Only accessible from this class
 “friendly” Accessible from the package; Default
access (no specific declaration)
 Access Specifiers (2)

Accessibility Criteria

Modifier Same Class Same Package Subclass All

public Yes Yes Yes Yes
protected Yes Yes Yes
Default Yes Yes
private Yes
 Access Specifiers (3)

Examine the classes Employee.java and

TestAccess.java in your source disk.
Compile the class TestAccess.java and observe the
output. (Should see an error message.)
Now change the name and salary fields to public
and re-compile and run TestAccess.java.
Lesson: Keep instance variables/fields private!
 Access Specifiers (3)

Examine the classes Employee.java and

TestAccess.java in your source disk.
Compile the class TestAccess.java and observe the
output. (Should see an error message.)
Now change the name and salary fields to public
and re-compile and run TestAccess.java.
Lesson: Keep instance variables/fields private!
 Inheritance (1)

Fields: Methods:
Superclass All the fields and
f1, f2, and f3 m1,m2, m3, m4, m5, and m6 methods are inherited
by the subclass

Fields: Methods: A subclass may add

additional fields (f4-
f4 and f5 Subclass m6,m7, m8, and m9 f5) and/or methods
(m7-m9) and/or
override an existing
one (m6)

An object of Superclass: An object of Subclass:

Has 3 “slots” and understand Has 5 “slots” and understand

messages m1-m6 messages m1-m5, m6 (as defined
in the subclass) and m7-m9
 Inheritance (2)

// Person.java // Student2.java
public class Person { public class Student2 extends Person {
private String name; private float gpa;
public Person (String n) { public Student2 (String n, float g) {
name = n; super (n); // calls superclass constructor
} gpa = g;
public void setName (String n) { }
name = n; public void setGpa (float g) {
} gpa = g;
public String getName () { }
return name; public float getGpa () {
} return gpa;
}
public void print () {
public void print () { // overriding
System.out.println(“Name is super.print(); // calls superclass print()
“+name); System.out.println("gpa is” +gpa);
} }
} }
 Overriding vs. Overloading

Overriding
 Subclass can specialize the methods of the superclass by changing
the operation of a method declared by the superclass without
changing the interface.
 Overridden method can be invoked using super
 Same method name, same parameter list, same return type,
different body
Overloading
 A class can enhance its functionality by providing a means for the
user to call a method with a different number of arguments or type.
 Same method name, same or different return type, different
parameter list, different body
 Overloading: Example

class Person { public class TestPerson {

private String name;
public static void main (String argv[]) {
// overloaded constructor with no
parameter Person p1 = new Person();
public Person () { p1.print();
name = “ ”; Person p2 = new Person(“John”);
}
p2.print();
// overloaded constructor with 1
parameter }
public Person (String n) { }
name = n;
}
public void setName (String n) { … }
public String getName () { … }
public void print () { … }
}
 Polymorphism

In Greek it means “many forms”

In OO/Java it means
 “one interface, multiple implementations” (e.g., a print
interface with multiple implementations from the Person
and Student classes)
 “One object reference, possibly referring multiple forms of
objects” (e.g., Person x; Here x can be a Person, Student,
etc.)
 Note: an object has only one form but an object reference can be of
multiple forms (we say the object reference variable is
polymorphic).
 Interfaces

 Definition (of an interface):

 a collection of method signatures (without implementations, always
public and abstract) and/or constants (always public, static, and final)
that can be added to a class to provide additional behaviors not defined in the
class itself or inherited from its superclasses
 Syntax:
 // To create an interface:
public interface MyInterface [extends Interface1, Interface2, ...] {
// all methods here are defaulted to public and abstract.
// all variables here are defaulted to final, static, and public.
}
 // To use an interface:
public class MyClass implements MyInterface {
// must implements all the methods specified in the interface MyInterface
}