Core Java Training

Java Training 

Interdiction of java
The History
Java’s Lineage
The Birth of Modern Programming: C
C++: The Next Step
The Stage Is Set for Java
The Creation of Java
The C# Connection
How Java Changed the Internet
Java Applets
Security
Portability
Java’s Magic: The Bytecode
Servlets: Java on the Server Side
The Java Buzzwords
Simple
Object-Oriented
Robust
Multithreaded
Architecture-Neutral
Interpreted and High Performance
Distributed
Dynamic
The Evolution of Java
Java SE 6
A Culture of Innovation

Java features
An Overview of Java
Object-Oriented Programming
Abstraction
The Three OOP Principles
A First Simple Program
Entering the Program
Compiling the Program
A Closer Look at the First Sample Program
A Second Short Program
Two Control Statements
The if Statement
The for Loop
Using Blocks of Code
Identifiers
Literals
Comments
The Java Keywords
The Java Class Libraries

Data Types
Data Types, Variables, and Arrays
Java Is a Strongly Typed Language
The Primitive Types
Integers
byte
short
int
long
Floating-Point Types
float
double
Characters
Booleans

Operators
Arithmetic Operators
The Basic Arithmetic Operators
The Modulus Operator
Arithmetic Compound Assignment Operators
Increment and Decrement
The Bitwise Operators
The Bitwise Logical Operators
The Left Shift
The Right Shift
The Unsigned Right Shift
Bitwise Operator Compound Assignments
Relational Operators
Boolean Logical Operators
Short-Circuit Logical Operators
The Assignment Operator

Control Statements
Java’s Selection Statements
if
switch
Iteration Statements
while
do-while
for
The For-Each Version of the for Loop
Nested Loops
Jump Statements
Using break
Using continue
return

Class and object
Introducing Classes
Class Fundamentals
The General Form of a Class
A Simple Class
Declaring Objects
A Closer Look at new
Assigning Object Reference Variables
Introducing Methods
Adding a Method to the Box Class
Returning a Value
Adding a Method That Takes Parameters

Constructors
Parameterized Constructors
The this Keyword
Instance Variable Hiding
Garbage Collection
The finalize( ) Method
A Stack Class

Overloading Methods
Overloading Constructors
Using Objects as Parameters
A Closer Look at Argument Passing
Returning Objects
Recursion
Introducing Access Control
Understanding static
Introducing final

Inheritance
Inheritance Basics
Member Access and Inheritance
A More Practical Example
A Superclass Variable Can Reference a Subclass Object
Using super
Using super to Call Superclass Constructors
A Second Use for super
Creating a Multilevel Hierarchy
When Constructors Are Called
Method Overriding
Dynamic Method Dispatch
Why Overridden Methods?
Applying Method Overriding
Using Abstract Classes
Using final with Inheritance
Using final to Prevent Overriding
Using final to Prevent Inheritance
The Object Class

Packages and Interfaces
Packages
Defining a Package
Finding Packages and CLASSPATH
Importing Packages
Interfaces
Defining an Interface
Implementing Interfaces
Nested Interfaces
Applying Interfaces
Variables in Interfaces
Interfaces Can Be Extended

Exception Handling
Exception-Handling Fundamentals
Exception Types
Uncaught Exceptions
Using try and catch
Displaying a Description of an Exception
Multiple catch Clauses
Nested try Statements
throw
throws
finally
Java’s Built-in Exceptions
Creating Your Own Exception Subclasses
Using Exceptions

Multithreaded Programming
The Java Thread Model
Thread Priorities
Synchronization
Messaging
The Thread Class and the Runnable Interface
The Main Thread
Creating a Thread
Implementing Runnable
Extending Thread
Choosing an Approach
Creating Multiple Threads
Using isAlive( ) and join( )
Thread Priorities
Synchronization
Using Synchronized Methods
The synchronized Statement
Interthread Communication
Deadlock
Suspending, Resuming, and Stopping Threads
Suspending, Resuming, and Stopping Threads
Using Java 11 and Earlier
The Modern Way of Suspending, Resuming,
and Stopping Threads
Using Multithreading

Enumerations, Autoboxing, and Annotations (Metadata)
Enumerations
Enumeration Fundamentals
The values( ) and valueOf( ) Methods
Java Enumerations Are Class Types
Enumerations Inherit Enum
Another Enumeration Example
Type Wrappers
Autoboxing
Autoboxing and Methods
Autoboxing/Unboxing Occurs in Expressions
Autoboxing/Unboxing Boolean and Character Values
Autoboxing/Unboxing Helps Prevent Errors
AWord of Warning
Annotations (Metadata)
Annotation Basics
Specifying a Retention Policy
Obtaining Annotations at Run Time by Use of Reflection
The AnnotatedElement Interface
Using Default Values
Marker Annotations
Single-Member Annotations
The Built-In Annotations
Some Restrictions

String Handling
The String Constructors
String Length
Special String Operations
String Literals
String Concatenation
String Concatenation with Other Data Types
String Conversion and toString( )
Character Extraction
charAt( )
getChars( )
getBytes( )
toCharArray( )
String Comparison
equals( ) and equalsIgnoreCase( )
regionMatches( )
startsWith( ) and endsWith( )
equals( ) Versus ==
compareTo( )
Searching Strings
Modifying a String
substring( )
concat( )
replace( )
trim( )
Data Conversion Using valueOf( )
Changing the Case of Characters Within a String
Additional String Methods
StringBuffer
StringBuffer Constructors
length( ) and capacity( )
ensureCapacity( )
setLength( )
charAt( ) and setCharAt( )
getChars( )
append( )
insert( )
reverse( )
delete( ) and deleteCharAt( )
replace( )
substring( )
Additional StringBuffer Methods
StringBuilder

Input/Output: Exploring javaio
The Java I/O Classes and Interfaces
File
Directories
Using FilenameFilter
The listFiles( ) Alternative
Creating Directories
The Closeable and Flushable Interfaces
The Stream Classes
The Byte Streams
InputStream
OutputStream
FileInputStream
FileOutputStream
ByteArrayInputStream
ByteArrayOutputStream
Filtered Byte Streams
Buffered Byte Streams
SequenceInputStream
PrintStream
DataOutputStream and DataInputStream
RandomAccessFile
The Character Streams
Reader
Writer
FileReader
FileWriter
Javautil Part 1: The Collections Framework
Collections Overview
Recent Changes to Collections
Generics Fundamentally Change the Collections
Framework
Autoboxing Facilitates the Use of Primitive Types
For-Each Style for Loop
Collection Interfaces
Collection Interface
List Interface
Set Interface
SortedSet Interface
NavigableSet Interface
Queue Interface
Deque Interface
Collection Classes
ArrayList Class
LinkedList Class
HashSet Class
LinkedHashSet Class
TreeSet Class
PriorityQueue Class
ArrayDeque Class
EnumSet Class
Accessing a Collection via an Iterator
Using an Iterator
The For-Each Alternative to Iterators
Storing User-Defined Classes in Collections
The RandomAccess Interface
Working with Maps
The Map Interfaces
The NavigableMap Interface
The Map Classes
Comparators
Using a Comparator
The Collection Algorithms
Arrays
Why Generic Collections?
The Legacy Classes and Interfaces
The Enumeration Interface
Vector
Stack
Dictionary
Hashtable
Properties
Using store( ) and load( )
Parting Thoughts on Collections