Core_java_ppt.ppt

Programming Language – JAVA

 BY
 Prof. Shibdas Dutta

road map today
Brief intro to Java
Develop and compile environment
A simple example
Intro to object/class
Java basics
Differences from C

Intro to Java
 Java programming language
The one we use to write our program
Compiled to byte code of JVM
 Java virtual machine (JVM)
Java interpreter – interpret the compiled byte code
Software simulated CPU architecture
Cross-platform: support Linux, Windows, PalmOS…etc.
 Java runtime environment (JRE)
Predefined set of java classes available to use
Core Java APIs – basic utilities, I/O, graphics, network…

Java is portable,
As long as there is a JVM compiled for
that particular processor and OS
Typical program, like C or C++, is
compiled for a particular processor
architecture and OS.
“Write once, run everywhere!”
Sun’s motto for Java

Java
Java is an object-oriented language, with a
syntax similar to C
Structured around objects and methods
A method is an action or something you do with
the object
Avoid those overly complicated features of
C++:
Operator overloading, pointer, templates, friend
class, etc.

Getting and using java
 J2SDK freely download from http://java.sun.com
 “Your first cup of Java”:
 detailed instructions to help you run your first program
 http://java.sun.com/docs/books/tutorial/getStarted/cupojava/in
dex.html
 All text editors support java
 Vi/vim, emacs, notepad, wordpad
 Just save to .java file
 Have IDEs that comparable to Visual Studio
 JCreator (simple)
 Eclipse (more complicated)

Compile and run an application
Write java class Foo containing a main()
method and save in file “Foo.java”
The file name MUST be the same as class
name
Compile with: javac Foo.java
Creates compiled .class file: Foo.class
Run the program: java Foo
Notice: use the class name directly, no .class!

Hello World!
/* Our first Java program – Hello.java */
public class Hello {
//main()
public static void main ( String[] args ) {
System.out.println( "hello world!" );
}
}
File name: Hello.java
Command line
arguments
Standard output, print with new line

About class
Fundamental unit of Java program
All java programs are classes
Each class define a unique kind of object
( a new data type)
Each class defines a set of fields, methods
or other classes
public: modifier. This class is publicly
available and anyone can use it.

Things to notice
Java is case sensitive
whitespace doesn’t matter for compilation
File name must be the same as one of the
class names, including capitalization!
At most one public class per file
If there is one public class in the file, the
filename must be the same as it
Generally one class per file

What is an object?
Object is a thing
An object has state, behavior and identity
Internal variable: store state
Method: produce behavior
Unique address in memory: identity
An object is a manifestation of a class

What is class?
Class introduces a new data type
A class describes a set of objects that
have identical characteristics (data
elements) and behaviors (methods).
Existing classes provided by JRE
User defined classes
Once a class is established, you can make
as many objects of it as you like, or none.

Simple example: class Person
A Person has some attributes
The class defines these properties for all
people
Each person gets his own copy of the
fields
Attributes = properties = fields

Class Person: definition
class Person {
String name;
int height; //in inches
int weight; //in pounds
public void printInfo(){
System.out.println(name+" with height="+height+", weight="+weight);
}
}
class ClassName{ /* class body goes here */ }
class: keyword

Class Person: usage
Person ke; //declaration
ke = new Person(); //create an object of Person
ke.name= “Ke Wang”; //access its field
Person sal = new Person();
sal.name=“Salvatore J. Stolfo”;
ke.printInfo();
Sal.printInfo(); // error here??

Reference
Person ke; //only created the reference, not an object.
It points to nothing now (null).
ke = new Person(); //create the object (allocate storage
in memory), and ke is initialized.
ke.name=“Ke Wang”; //access the object through
the reference

Java Basics: primitive types
One group of types get special treatment
in Java
Variable is not created by “new”, not a
reference
Variable holds the value directly

Primitive types
Primitive type Size Minimum Maximum Wrapper type
boolean 1-bit — — Boolean
char 16-bit Unicode 0 Unicode 216- 1 Character
byte 8-bit -128 +127 Byte
short 16-bit -215 +215-1 Short
int 32-bit -231 +231-1 Integer
long 64-bit -263 +263-1 Long
float 32-bit IEEE754 IEEE754 Float
double 64-bit IEEE754 IEEE754 Double

Primitive types
All numerical types are signed!
No unsigned keyword in Java
The “wrapper” class allow you to make a
non-primitive object to represent the
primitive one
char c =‘a’;
Character C = new Character(c);
Character C = new Character(‘a’);

Primitive types - boolean
boolean can never convert to or from other
data type, not like C or C++
boolean is not a integer
if(0) doesn’t work in java
Have to explicitly state the comparison
if( x ==0) {

Arrays in Java
 An ordered collection of something, addressed
by integer index
Something can be primitive values, objects, or even
other arrays. But all the values in an array must be of
the same type.
Only int or char as index
long values not allowed as array index
 0 based
Value indexes for array “a” with length 10
a[0] – a[9];
 a.length==10
Note: length is an attribute, not method

Arrays in Java: declaration
Declaration
int[] arr;
Person[] persons;
Also support: int arr[]; Person persons[];
(confusing, should be avoided)
Creation
int[] arr = new int[1024];
int [][] arr = { {1,2,3}, {4,5,6} };
Person[] persons = new Person[50];

Arrays in Java: safety
Cannot be accessed outside of its range
ArrayIndexOutOfBoundsException
Guaranteed to be initialized
Array of primitive type will be initialized to their
default value
Zeroes the memory for the array
Array of objects: actually it’s creating an array
of references, and each of them is initialized to
null.

Arrays in Java:
second kind of reference types in Java
int[] arr = new int [5];
arr
int[][] arr = new int [2][5];
arr[0]
arr[1]
arr

Reference vs. primitive
 Java handle objects and arrays always by
reference.
classes and arrays are known as reference types.
Class and array are composite type, don’t have
standard size
 Java always handle values of the primitive types
directly
Primitive types have standard size, can be stored in a
fixed amount of memory
 Because of how the primitive types and objects
are handles, they behave different in two areas:
copy value and compare for equality

Scope of objects
When you create an object using new, the
object hangs around past the end of the
scope, although the reference vanishes.
{
String s = new String("abc");
}
Reference s vanishes, but the String
object still in memory
Solution: Garbage Collector!

Garbage collector
In C++, you have to make sure that you
destroy the objects when you are done
with them.
Otherwise, memory leak.
In Java, garbage collector do it for you.
It looks at all the objects created by new and
figure out which ones are no longer being
referenced. Then it release the memory for
those objects.

Importing library
If you need any routines that defined by
java package
import java.util.*;
import java.io.*;
Put at the very beginning of the java file
java.lang.* already been imported.
Check javadoc for the classes

Static keyword
 Want to have only one piece of storage for a
data, regardless how many objects are created,
or even no objects created
 Need a method that isn’t associated with any
particular object of this class
 static keyword apply to both fields and methods
 Can be called directly by class name
Example: java.lang.Math
 Non-static fields/methods must be called through
an instance

main()
class Hello{
int num;
public static void main(String[] args) {
num = 10;
}
}
>javac Hello.java
Hello.java:4: non-static variable num cannot be referenced
from a static context
num = 10;
^
1 error

Main() doesn’t belong in a class
 Always static
Because program need a place to start, before any
object been created.
 Poor design decision
 If you need access non-static variable of class
Hello, you need to create object Hello, even if
main() is in class Hello!
class Hello{
int num;
public static void main(String[] args){
Hello h = new Hello();
h.num = 10;
}
}

Difference between C and Java
 No pointers
 No global variable across classes
 Variable declaration anywhere
 Forward reference
Method can be invoked before defined
 Method overloading
As long as the methods have different parameter lists
 No struct, union, enum type
 No variable-length argument list

Basic exception
readLine() throws IOException
Required to enclose within try/catch block
More on exception later

Core_java_ppt.ppt

More Related Content

Similar to Core_java_ppt.ppt (20)

Recently uploaded (20)

Core_java_ppt.ppt