KEMBAR78
Corejava Training in Bangalore Tutorial | PPT
www.traininginbangalore.com
CORE JAVA
Core Java Syllabus
A First Look
A Simple Java Class
Java’s “Hello World” Program
Java Basics
Language and Platform Features
Program Life Cycle
The Java SE Development Kit (JDK)
Class and Object Basics
The Object Model and Object-Oriented Programming
Classes, References, and Instantiation
Adding Data to a Class Definition
Adding Methods (Behavior)
More on Classes and Objects
Accessing data, the “this” variable
Encapsulation and Access Control, public and private
Access
Constructors and Initialization
static Members of a Class
Scopes, Blocks, References to Objects
Flow of Control[briefly due to attendee
experience]
Branching: if, if-else, switch
Iteration: while, do-while, for, break, continue
Strings and Arrays
String, StringBuffer, StringBuilder
Arrays, Primitive Arrays, Arrays of Reference Types
varargs
Packages
Package Overview – Using Packages to Organize Code
import statements
Creating Packages, package Statement, Required
Directory Structure
Finding Classes, Packages and Classpath
Composition and Inheritance
Using Composition to Deal With Complexity
Composition/HAS-A, Delegation
Using Inheritance and Polymorphism to share commonality
IS-A, extends, Inheriting Features, Overriding Methods,
Using Polymorphism
Class Object
Abstract Classes
Advanced Stream Techniques
Buffering
Data Streams
Push-Back Parsing
Byte-Array Streams and String Readers and Writers
Java Serialization
The Challenge of Object Serialization
Serialization API, Serializable Interface
ObjectInputStream and ObjectOutputStream
The Serialization Engine
Transient Fields
readObject and writeObject
Externalizable Interface
Interfaces
Using Interfaces to Define Types
Interfaces and Abstract Classes
Exceptions
Exceptions and the Exception Hierarchy
try and catch
Handling Exceptions
Program Flow with Exceptions
Finally
Java Collections and Generics
The Collections Framework and its API
Collections and Java Generics
Collection, Set, List, Map, Iterator
Autoboxing
Collections of Object (non-generic)
Using ArrayList, HashSet, and HashMap
for-each Loop
Processing Items With an Iterator
More About Generics
The Java Streams Model
Delegation-Based Stream Model
InputStream and OutputStream
Media-Based Streams
Filtering Streams
Readers and Writers
Working with Files
File Class
Modeling Files and Directories
File Streams
Random-Access Files
Comments are almost like C++
• The javadoc program generates HTML API
documentation from the “javadoc” style comments in
your code.
/* This kind comment can span multiple lines */
// This kind is of to the end of the line
/* This kind of comment is a special
* ‘javadoc’ style comment
*/
JAVA Classes
• The class is the fundamental concept in JAVA (and other
OOPLs)
A class describes some data object(s), and the
operations (or methods) that can be applied to those
objects
Every object and method in Java belongs to a class
Classes have data (fields) and code (methods) and
classes (member classes or inner classes)
Static methods and fields belong to the class itself Others
belong to instances
•
•
•
•
•
An example of a class
class Person {
String name;
int age;
Variable
Method
void birthday ( )
{
age++;
System.out.println (name + '
is now ' + age);
}
}
Scoping
As in C/C++, scope is determined by the placement of curly braces {}.
A variable defined within a scope is available only to the end of that scope.
{ int x = 12;
/* only x available */
{ int q = 96;
/* both x and q available */
}
/* only x available */
/* q “out of scope” */
}
{ int x = 12;
{ int x = 96; /* illegal */
}
}
This is ok in C/C++ but not in Java.
Scope of Objects
• Java objects don’t have the same lifetimes as
primitives.
• When you create a Java object using new, it
hangs around past the end of the scope.
• Here, the scope of name s is delimited by the {}s
but the String object hangs around until GC’d
{
String s = new String("a string");
} /* end of scope */
The static
keyword•
•
•
Java methods and variables can be declared static
These exist independent of any object
This means that a Class’s
–static methods can be called even if no objects of that
class have been created and
–static data is “shared” by all instances (i.e., one rvalue
per class instead of one per instance
class StaticTest {static int i = 47;} StaticTest st1 = new StaticTest();
StaticTest st2 = new StaticTest();
// st1.i == st2.I == 47
StaticTest.i++; st2.I+
+
// st1.i == st2.I == 48
// or st1.I++ or
Example
public class Circle {
// A class field
public static final double
PI= 3.14159; constant
// A class method: just
compute a value
// A useful
based on thearguments
public static double
radiansToDegrees(double rads) { return rads *
180 / PI;
}// An instance field
public double r;
circle
// Two methodswhich
an object
// The radius of the
operate on
{
the instance
// Compute
fields of
the area of
public double
the circle
return PI *
area()
r * r;}
public
double
circumference() { // Compute the
circumference of the circle
return 2 * PI * r;
}
}
Array Operations
• Subscripts always start at 0 as in C
• Subscript checking is done automatically
• Certain operations are defined on arrays
of objects, as for other classes
– e.g. myArray.length == 5
An array is an object
NSIT ,Jetalpur
• Person mary = new Person ( );
• int
• int
myArray[
myArray[
] = new
] = {1, 4, 9,
16,
int[5];
25};
• String languages [ ] = {"Prolog", "Java"};
•
•
Since arrays are objects they are allocated dynamically
Arrays, like all objects, are subject to garbage collection
when no more references remain
– so fewer memory leaks
– Java doesn’t have pointers!
Example
Programs
Echo.java
•
•
•
•
•
•
•
•
•
C:UMBC331java>type echo.java
// This is the Echo example from the Sun
tutorial class echo {
public static void main(String args[]) { for (int i=0;
i < args.length; i++) { System.out.println( args[i] );
}
}
}
• C:UMBC331java>javac echo.java
•
•
•
•
•
C:UMBC331java>java echo this is pretty silly
this
is pretty
silly
Factorial Example
/* This program computes the factorial of a number
*/
public class Factorial {
public static void
main(String[] args) { here
int input =
Integer.parseInt(args[0]); input
double result =
factorial(input); factorial
System.out.println(result); result
}
ends here
// Define a class
// The program
starts
// Get the user's
// Compute the
// Print out the
// The main() method
public static double
computes x!
if (x <
0) return 0.0;
double fact =
1.0; initial value
factorial(int x) { // This method
// Check for bad input
// if bad,
return 0
// Begin with an
while(x > 1)
{ fact = fact *
x;
each time
// Loop until
// multiply
x equals
by x
// and then
Constructors
• Classes should define one or more methods to create
or construct instances of the class
• Their name is the same as the class name
– note deviation from convention that methods begin with
lower case
• Constructors are differentiated by the number and
types of their arguments
– An example of overloading
• If you don’t define a constructor, a default one will be
created.
• Constructors automatically invoke the zero argument
constructor of their superclass when they begin (note
that this yields a recursive process!)
Methods, arguments and
return values
Java methods are like C/C++ functions.
General case:
returnType methodName ( arg1, arg2, … argN)
{
methodBody
}
•
The return keyword exits a method optionally with a value
int storage(String s) {return s.length() * 2;}
boolean flag() { return true; }
float naturalLogBase() { return
2.718f; } void nothing() {
return; }
void nothing2() {}
Corejava Training in Bangalore Tutorial

Corejava Training in Bangalore Tutorial

  • 1.
  • 2.
    Core Java Syllabus AFirst Look A Simple Java Class Java’s “Hello World” Program Java Basics Language and Platform Features Program Life Cycle The Java SE Development Kit (JDK)
  • 3.
    Class and ObjectBasics The Object Model and Object-Oriented Programming Classes, References, and Instantiation Adding Data to a Class Definition Adding Methods (Behavior) More on Classes and Objects Accessing data, the “this” variable Encapsulation and Access Control, public and private Access Constructors and Initialization static Members of a Class Scopes, Blocks, References to Objects
  • 4.
    Flow of Control[brieflydue to attendee experience] Branching: if, if-else, switch Iteration: while, do-while, for, break, continue Strings and Arrays String, StringBuffer, StringBuilder Arrays, Primitive Arrays, Arrays of Reference Types varargs
  • 5.
    Packages Package Overview –Using Packages to Organize Code import statements Creating Packages, package Statement, Required Directory Structure Finding Classes, Packages and Classpath Composition and Inheritance Using Composition to Deal With Complexity Composition/HAS-A, Delegation Using Inheritance and Polymorphism to share commonality IS-A, extends, Inheriting Features, Overriding Methods, Using Polymorphism Class Object Abstract Classes
  • 6.
    Advanced Stream Techniques Buffering DataStreams Push-Back Parsing Byte-Array Streams and String Readers and Writers Java Serialization The Challenge of Object Serialization Serialization API, Serializable Interface ObjectInputStream and ObjectOutputStream The Serialization Engine Transient Fields readObject and writeObject Externalizable Interface
  • 7.
    Interfaces Using Interfaces toDefine Types Interfaces and Abstract Classes Exceptions Exceptions and the Exception Hierarchy try and catch Handling Exceptions Program Flow with Exceptions Finally
  • 8.
    Java Collections andGenerics The Collections Framework and its API Collections and Java Generics Collection, Set, List, Map, Iterator Autoboxing Collections of Object (non-generic) Using ArrayList, HashSet, and HashMap for-each Loop Processing Items With an Iterator More About Generics
  • 9.
    The Java StreamsModel Delegation-Based Stream Model InputStream and OutputStream Media-Based Streams Filtering Streams Readers and Writers Working with Files File Class Modeling Files and Directories File Streams Random-Access Files
  • 10.
    Comments are almostlike C++ • The javadoc program generates HTML API documentation from the “javadoc” style comments in your code. /* This kind comment can span multiple lines */ // This kind is of to the end of the line /* This kind of comment is a special * ‘javadoc’ style comment */
  • 11.
    JAVA Classes • Theclass is the fundamental concept in JAVA (and other OOPLs) A class describes some data object(s), and the operations (or methods) that can be applied to those objects Every object and method in Java belongs to a class Classes have data (fields) and code (methods) and classes (member classes or inner classes) Static methods and fields belong to the class itself Others belong to instances • • • • •
  • 12.
    An example ofa class class Person { String name; int age; Variable Method void birthday ( ) { age++; System.out.println (name + ' is now ' + age); } }
  • 13.
    Scoping As in C/C++,scope is determined by the placement of curly braces {}. A variable defined within a scope is available only to the end of that scope. { int x = 12; /* only x available */ { int q = 96; /* both x and q available */ } /* only x available */ /* q “out of scope” */ } { int x = 12; { int x = 96; /* illegal */ } } This is ok in C/C++ but not in Java.
  • 14.
    Scope of Objects •Java objects don’t have the same lifetimes as primitives. • When you create a Java object using new, it hangs around past the end of the scope. • Here, the scope of name s is delimited by the {}s but the String object hangs around until GC’d { String s = new String("a string"); } /* end of scope */
  • 15.
    The static keyword• • • Java methodsand variables can be declared static These exist independent of any object This means that a Class’s –static methods can be called even if no objects of that class have been created and –static data is “shared” by all instances (i.e., one rvalue per class instead of one per instance class StaticTest {static int i = 47;} StaticTest st1 = new StaticTest(); StaticTest st2 = new StaticTest(); // st1.i == st2.I == 47 StaticTest.i++; st2.I+ + // st1.i == st2.I == 48 // or st1.I++ or
  • 16.
    Example public class Circle{ // A class field public static final double PI= 3.14159; constant // A class method: just compute a value // A useful based on thearguments public static double radiansToDegrees(double rads) { return rads * 180 / PI; }// An instance field public double r; circle // Two methodswhich an object // The radius of the operate on { the instance // Compute fields of the area of public double the circle return PI * area() r * r;} public double circumference() { // Compute the circumference of the circle return 2 * PI * r; } }
  • 17.
    Array Operations • Subscriptsalways start at 0 as in C • Subscript checking is done automatically • Certain operations are defined on arrays of objects, as for other classes – e.g. myArray.length == 5
  • 18.
    An array isan object NSIT ,Jetalpur • Person mary = new Person ( ); • int • int myArray[ myArray[ ] = new ] = {1, 4, 9, 16, int[5]; 25}; • String languages [ ] = {"Prolog", "Java"}; • • Since arrays are objects they are allocated dynamically Arrays, like all objects, are subject to garbage collection when no more references remain – so fewer memory leaks – Java doesn’t have pointers!
  • 19.
  • 20.
    Echo.java • • • • • • • • • C:UMBC331java>type echo.java // Thisis the Echo example from the Sun tutorial class echo { public static void main(String args[]) { for (int i=0; i < args.length; i++) { System.out.println( args[i] ); } } } • C:UMBC331java>javac echo.java • • • • • C:UMBC331java>java echo this is pretty silly this is pretty silly
  • 21.
    Factorial Example /* Thisprogram computes the factorial of a number */ public class Factorial { public static void main(String[] args) { here int input = Integer.parseInt(args[0]); input double result = factorial(input); factorial System.out.println(result); result } ends here // Define a class // The program starts // Get the user's // Compute the // Print out the // The main() method public static double computes x! if (x < 0) return 0.0; double fact = 1.0; initial value factorial(int x) { // This method // Check for bad input // if bad, return 0 // Begin with an while(x > 1) { fact = fact * x; each time // Loop until // multiply x equals by x // and then
  • 22.
    Constructors • Classes shoulddefine one or more methods to create or construct instances of the class • Their name is the same as the class name – note deviation from convention that methods begin with lower case • Constructors are differentiated by the number and types of their arguments – An example of overloading • If you don’t define a constructor, a default one will be created. • Constructors automatically invoke the zero argument constructor of their superclass when they begin (note that this yields a recursive process!)
  • 23.
    Methods, arguments and returnvalues Java methods are like C/C++ functions. General case: returnType methodName ( arg1, arg2, … argN) { methodBody } • The return keyword exits a method optionally with a value int storage(String s) {return s.length() * 2;} boolean flag() { return true; } float naturalLogBase() { return 2.718f; } void nothing() { return; } void nothing2() {}