what is exact syllabus of core java?

Discussion in 'Java Career Helpline' started by surveysendil, Dec 7, 2010.

  1. surveysendil

    surveysendil New Member

    i got the following will be syllabus of java.is thaT correct and any thing else remaining?
    Introduction to Java technology
    - Setting Up Your Computer
    - Java programming basics
    - JVM, JRE, JDK
    - Java Data Types and Primitive Types
    - Control Structure
    - Java Arrays
    - Built-in Java Classes
    - Creating own Classes
    - Packages and Java class path
    - JavaBeans
    - Inheritance
    - Abstract class and Java Interface
    - Polymorphism
    - Inner class
    - Exception handling
    - Java Collections framework
    - GUI programming with AWT and Swing
    - Java Applets
    - Stream I/O and Serialization
    - Java Networking API
    - Java Multi-Threading
    - JDBC (Java Database Connectivity)
    Is servlets part of core java?

    Programming language Types and Paradigms.
    Computer Programming Hierarchy.
    How Computer Architecture Affects a Language ?
    Why Java ?
    Flavors of Java.
    Java Designing Goal.
    Role of Java Programmer in Industry.
    Features of Java Language.
    JVM –The heart of Java
    Java’s Magic Bytecode
    Language Fundamentals
    The Java Environment:
    Installing Java.
    Java Program Development
    Java Source File Structure
    Basic Language Elements:
    Lexical Tokens,Identifiers
    Keywords,Literals, Comments
    Primitive Datatypes,Operators
    Object Oriented Programming
    Class Fundamentals.
    Object & Object reference.
    Object Life time & Garbage Collection.
    Creating and Operating Objects.
    Constructor & initialization code block.
    Access Control, Modifiers, methods
    Nested , Inner Class &Anonymous Classes
    Abstract Class & Interfaces
    Defining Methods, Argument Passing Mechanism
    Method Overloading, Recursion.
    Dealing with Static Members. Finalize() Method.
    Native Method. Use of “this “ reference.
    Use of Modifiers with Classes & Methods.
    Design of Accessors and Mutator Methods
    Cloning Objects, shallow and deep cloning
    Generic Class Types
    Extending Classes and Inheritance
    Use and Benefits of Inheritance in OOP
    Types of Inheritance in Java
    Inheriting Data Members and Methods
    Role of Constructors in inheritance
    Overriding Super Class Methods.
    Use of “super”.
    Polymorphism in inheritance.
    Type Compatibility and Conversion
    Implementing interfaces.
    Organizing Classes and Interfaces in Packages.
    Package as Access Protection
    Defining Package.
    CLASSPATH Setting for Packages.
    Making JAR Files for Library Packages
    Import and Static Import
    Naming Convention For Packages
    Exception Handling:
    The Idea behind Exception
    Exceptions & Errors
    Types of Exception
    Control Flow In Exceptions
    JVM reaction to Exceptions
    Use of try, catch, finally, throw, throws in Exception Handling.
    In-built and User Defined Exceptions
    Checked and Un-Checked Exceptions
    Array & String :
    Defining an Array
    Initializing & Accessing Array
    Multi –Dimensional Array
    Operation on String
    Mutable & Immutable String
    Using Collection Bases Loop for String
    Tokenizing a String
    Creating Strings using StringBuffer
    Thread :
    Understanding Threads
    Needs of Multi-Threaded Programming.
    Thread Life-Cycle
    Thread Priorities
    Synchronizing Threads
    Inter Communication of Threads
    Critical Factor in Thread -DeadLock
    Applet & Application
    Applet Architecture.
    Parameters to Applet
    Embedding Applets in Web page.
    Applet Security Policies
    A Collection of Useful Classes
    Utility Methods for Arrays
    Observable and Observer Objects
    Date & Times
    Using Scanner
    Regular Expression
    Input/Output Operation in Java(java.io Package)
    Streams and the new I/O Capabilities
    Understanding Streams
    The Classes for Input and Output
    The Standard Streams
    Working with File Object
    File I/O Basics
    Reading and Writing to Files
    Buffer and Buffer Management
    Read/Write Operations with File Channel
    Serializing Objects
    GUI Programming
    Designing Graphical User Interfaces in Java
    Components and Containers
    Basics of Components
    Using Containers
    Layout Managers
    AWT Componets
    Adding a Menu to Window
    Extending GUI Features Using Swing Components
    Java Utilities (java.util Package)
    The Collection Framework :
    Collections of Objects
    Collection Types
    Understanding Hashing
    Use of ArrayList & Vector
    Event Handling
    Event-Driven Programming in Java
    Event- Handling Process
    Event-Handling Mechanism
    The Delegation Model of Event Handling
    Event Classes
    Event Sources
    Event Listeners
    Adapter Classes as Helper Classes in Event Handling
    Anonymous Inner classes a Short –cut to Event Handling
    Avoiding Deadlocks in GUI Code
    Event Types & Classes
    Networking Programming
    Networking Basics
    Client-Server Architecture
    Socket Overview
    Networking Classes and Interfaces
    Network Protocols
    Developing Networking Applications in Java
    DataBase Programming using JDBC
    Introduction to JDBC
    JDBC Drivers & Architecture
    CURD operation Using JDBC
    Connecting to non-conventional Databases



    What is Java?

    How to Get Java

    A First Java Program

    Compiling and Interpreting Applications

    The JDK Directory Structure

    Data types and Variables

    Primitive Datatypes ,Declarations

    Variable Names

    Numeric Literals,Character Literals

    String,String Literals

    Arrays,Non-Primitive Datatypes,The Dot Operator

    Operators and Expressions


    Assignment Operator

    Arithmetic Operators

    Relational Operators

    Logical Operators

    Increment and Decrement Operators

    Operate-Assign Operators (+=, etc.)

    The Conditional Operator

    Operator Precedence

    Implicit Type Conversions

    The Cast Operator

    Control Flow Statements


    Conditional (if) Statements

    Data types and Variables 3

    Adding an else if

    Conditional (switch) Statements

    while and do-while Loops

    for Loops

    A for Loop Diagram

    Enhanced for Loop

    The continue Statement

    The break Statement



    Calling Methods

    Defining Methods

    Method Parameters


    Method Parameters

    So, Why All the static?

    Object-Oriented Programming

    Introduction to Object-Oriented Programming

    Classes and Objects

    Fields and Methods


    Access Control



    Objects and Classes

    Defining a Class

    Creating an Object

    Instance Data and Class Data



    Access Modifiers


    Using Java Objects

    Printing to the Console

    printf Format Strings

    StringBuilder and StringBuffer

    Methods and Messages


    Parameter Passing

    Comparing and Identifying Objects, Destroying Objects

    Inheritance in Java


    Inheritance in Java


    Method Overriding



    The Object Class


    The import Statement

    Static Imports


    CLASSPATH and Import

    Defining Packages

    Package Scope

    Exception Handling

    Exceptions Overview

    Catching Exceptions

    The finally Block

    Exception Methods

    Declaring Exceptions

    Defining and Throwing Exceptions

    Errors and RuntimeExceptions


    Input/Output Streams

    Overview of Streams

    Bytes vs. Characters

    Converting Byte Streams to Character Streams

    File Object

    Binary Input and Output

    PrintWriter Class

    Reading and Writing Objects

    Basic and Filtered Streams

    Collection Framework

    The Collections Framework

    The Set Interface

    Set Implementation Classes

    The List Interface

    List Implementation Classes

    The Map Interface

    Map Implementation Classes

    Inner Classes

    Inner Classes

    Member Classes

    Local Classes

    Anonymous Classes

    Instance Initializers

    Static Nested Classes

    Introduction to Threads

    Non-Threaded Applications

    Threaded Applications

    Creating Threads

    Thread States

    Runnable Threads

    Coordinating Threads

    Interrupting Threads

    Runnable Interface ,ThreadGroups

    Interfaces and Abstract Classes

    Separating Interface and Implementation

    UML Interfaces and Realization

    Defining Interfaces

    Implementing and Extending Interfaces

    Runnable Threads

    Abstract Classes


    Object Serialization

    Serializable Interface

    Serialization API

    ObjectInputStream and ObjectOutputStream

    The Serialization Engine

    Transient Fields

    readObject and writeObject

    Externalizable Interface


    Using Generics

    Type Erasure

    Type Boundaries

    Wildcards , Generic Methods

    Strengths and Weaknesses of Generics

    Legacy Code and Generics


    Uses for Meta-Data

    The Annotations Model

    Annotation Types and Annotations

    Built-In Annotations

    Annotations vs. Descriptors (XML)


Share This Page