Core Java Language

About Core Java Programming Language

Sun Microsystems has developed a programming language known as Java Programming Language. A platform to implement creative thinking. Java is object oriented, platform independent, simple, secure, architectural–neutral, portable, robust, multi threaded, high performance, distributed and dynamic. It is useful aspect to develop software and also applets. A java program can run on various operating systems without rewriting the code as java’s run-time environment which tells the OS what to do by interpreting the java code.

If you have chosen to be part of this creative world then you are on right track but a right track is not enough, ultimate thing is reaching to your destination of success so here we are The “Matrix Computers” a best institute nearby you for Java. We are proud to share that we are producing the best students who has gained more than sufficient knowledge by taking just one step towards us. We are making the best competitor for tomorrow’s IT sector. A institute for the good who can be the best by coming to us. “Reach us soon so that market can reach you soon”

Why this course is required

Java is a perfect step to be taken to learn Object Oriented Programming(oops) concepts. In today’s time where practical approach is must we the Matrix Computers can understand the need of practical that is why we emphasis on the providing the best and point to point knowledge to the student so that they can live up to the market expectation. We have expertise faculties who deliver you the training with practical real time awareness. At Matrix Computers students are guided through training in such a way that they can develop a standalone application using swings by the end of core java training course in jaipur.

Pre-requisites for Java Programming

Next Course Recommended

Course Contents

  1. The History and Evolution of Java
    • The Creation of Java
    • Security
    • Portability
    • Java’s Magic: The Bytecode
    • The Java Buzzwords
    • Simple
    • Object-Oriented
    • Robust
    • Multithreaded
    • Architecture-Neutral
    • Interpreted and High Performance
    • Distributed
    • Dynamic
  2. An Overview of Java
    • Object-Oriented Programming
    • Two Paradigms
    • 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
    • Lexical Issues
    • Whitespace
    • Identifiers
    • Literals
    • Comments
    • Separators
    • The Java Keywords
    • The Java Class Libraries
  3. 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
    • A Closer Look at Literals
    • Integer Literals
    • Floating-Point Literals
    • Boolean Literals
    • Character Literals
    • String Literals
    • Variables
    • Declaring a Variable
    • Dynamic Initialization
    • The Scope and Lifetime of Variables
    • Type Conversion and Casting
    • Java’s Automatic Conversions
    • Casting Incompatible Types
    • Automatic Type Promotion in Expressions
    • The Type Promotion Rules
    • Arrays
    • One-Dimensional Arrays
    • Multidimensional Arrays
    • Alternative Array Declaration Syntax
    • A Few Words About Strings
    • A Note to C/C++ Programmers About Pointers
  4. 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
    • The ? Operator
    • Operator Precedence
    • Using Parentheses
  5. 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
  6. 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
  7. A Closer Look at Methods and Classes
    • Overloading Methods
    • Overloading Constructors
    • Using Objects as Parameters
    • A Closer Look at Argument Passing
    • Returning Objects
    • Recursion
    • Introducing Access Control
    • Understanding static
    • Introducing final
    • Arrays Revisited
    • Introducing Nested and Inner Classes
    • Exploring the String Class
    • Using Command-Line Arguments
    • Varargs: Variable-Length Arguments
    • Overloading Vararg Methods
    • Varargs and Ambiguity
  8. 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 Executed
    • 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
  9. Packages and Interfaces
    • Packages
    • Defining a Package
    • Finding Packages and CLASSPATH
    • A Short Package Example
    • Access Protection
    • An Access Example
    • Importing Packages
    • Interfaces
    • Defining an Interface
    • Implementing Interfaces
    • Nested Interfaces
    • Applying Interfaces
    • Variables in Interfaces
    • Interfaces Can Be Extended
    • Default Interface Methods
    • Default Method Fundamentals
    • A More Practical Example
    • Multiple Inheritance Issues
    • Use static Methods in an Interface
    • Final Thoughts on Packages and Interfaces
  10. 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
    • Chained Exceptions
    • Three Recently Added Exception Features
    • Using Exceptions
  11. 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
    • Obtaining A Thread’s State
    • Using Multithreading
  12. 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
    • Character
    • Boolean
    • The Numeric Type Wrappers
    • Autoboxing
    • Autoboxing and Methods
    • Autoboxing/Unboxing Occurs in Expressions
    • Autoboxing/Unboxing Boolean and Character Values
    • Autoboxing/Unboxing Helps Prevent Errors
    • A Word 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
    • Type Annotations
    • Repeating Annotations
    • Some Restrictions
  13. I/O, Applets, and Other Topics
    • I/O Basics
    • Streams
    • Byte Streams and Character Streams
    • The Predefined Streams
    • Reading Console Input
    • Reading Characters
    • Reading Strings
    • Writing Console Output
    • The PrintWriter Class
    • Reading and Writing Files
    • Automatically Closing a File
    • Applet Fundamentals
    • The transient and volatile Modifiers
    • Using instanceof
    • strictfp
    • Native Methods
    • Problems with Native Methods
    • Using assert
    • Assertion Enabling and Disabling Options
    • Static Import
    • Invoking Overloaded Constructors Through this( )
  14. Generics
    • What Are Generics?
    • A Simple Generics Example
    • Generics Work Only with Reference Types
    • Generic Types Differ Based on Their Type Arguments
    • How Generics Improve Type Safety
    • A Generic Class with Two Type Parameters
    • The General Form of a Generic Class
    • Bounded Types
    • Using Wildcard Arguments
    • Bounded Wildcards
    • Creating a Generic Method
    • Generic Constructors
    • Generic Interfaces
    • Raw Types and Legacy Code
    • Generic Class Hierarchies
    • Using a Generic Superclass
    • A Generic Subclass
    • Run-Time Type Comparisons Within a Generic Hierarchy
    • Casting
    • Overriding Methods in a Generic Class
    • Type Inference with Generics
    • Erasure
    • Bridge Methods
    • Ambiguity Errors
    • Some Generic Restrictions
    • Type Parameters Can’t Be Instantiated
    • Restrictions on Static Members
    • Generic Array Restrictions
    • Generic Exception Restriction
  15. Lambda Expressions
    • Introducing Lambda Expressions
    • Lambda Expression Fundamentals
    • Functional Interfaces
    • Some Lambda Expression Examples
    • Block Lambda Expressions
    • Generic Functional Interfaces
    • Passing Lambda Expressions as Arguments
    • Lambda Expressions and Exceptions
    • Lambda Expressions and Variable Capture
    • Method References
    • Method References to static Methods
    • Method References to Instance Methods
    • Method References with Generics
    • Constructor References
    • Predefined Functional Interfaces
  16. 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
    • Joining Strings
    • 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
  17. Exploring java.lang
    • Primitive Type Wrappers
    • Number
    • Double and Float
    • Understanding isInfinite( ) and isNaN( )
    • Byte, Short, Integer, and Long
    • Character
    • Additions to Character for Unicode Code Point Support
    • Boolean
    • Void
    • Process Runtime
    • Memory Management
    • Executing Other Programs
    • ProcessBuilder
    • System
    • Using currentTimeMillis( ) to Time Program Execution
    • Using arraycopy( )
    • Environment Properties
    • Object
    • Using clone( ) and the Cloneable Interface
    • Class
    • ClassLoader
    • Math
    • Trigonometric Functions
    • Exponential Functions
    • Rounding Functions
    • Miscellaneous Math Methods
    • StrictMath
    • Compiler
    • Thread, ThreadGroup, and Runnable
    • The Runnable Interface
    • Thread
    • Package
    • RuntimePermission
    • Throwable
    • Enum
    • The CharSequence Interface
    • The Comparable Interface
    • java.lang.reflect
  18. java.util Part 1: The Collections Framework
    • Collections Overview
    • JDK 5 Changed the Collections Framework
    • Generics Fundamentally Changed the Collections Framework
    • Autoboxing Facilitates the Use of Primitive Types
    • The For-Each Style for Loop
    • The Collection Interfaces
    • The Collection Interface
    • The List Interface
    • The Set Interface
    • The SortedSet Interface
    • The NavigableSet Interface
    • The Queue Interface
    • The Deque Interface
    • The Collection Classes
    • The ArrayList Class
    • The LinkedList Class
    • The HashSet Class
    • The LinkedHashSet Class
    • The TreeSet Class
    • The PriorityQueue Class
    • The ArrayDeque Class
    • The EnumSet Class
    • Accessing a Collection via an Iterator
    • Using an Iterator
    • The For-Each Alternative to Iterators
    • Spliterators
    • Storing User-Defined Classes in Collections
    • The RandomAccess Interface
    • Working with Maps
    • The Map Interfaces
    • The Map Classes
    • Comparators
    • Using a Comparator
    • The Collection Algorithms
    • Arrays
    • The Legacy Classes and Interfaces
    • The Enumeration Interface
    • Vector
    • Stack
    • Dictionary
    • Hashtable
    • Properties
    • Using store( ) and load( )
    • Parting Thoughts on Collections
  19. java.util Part 2: More Utility Classes
    • StringTokenizer
    • BitSet
    • Optional, OptionalDouble, OptionalInt, and OptionalLong
    • Date
    • Calendar
    • Random
    • Scanner
    • The Scanner Constructors
    • Scanning Basics
    • Some Scanner Examples
  20. Input/Output: Exploring java.io
    • The I/O Classes and Interfaces
    • File
    • Directories
    • Using FilenameFilter
    • The listFiles( ) Alternative
    • Creating Directories
    • The AutoCloseable, Closeable, and Flushable Interfaces
    • I/O Exceptions
    • Two Ways to Close a Stream
    • 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
    • CharArrayReader
    • CharArrayWriter
    • BufferedReader
    • BufferedWriter
    • PushbackReader
    • PrintWriter
    • The Console Class
    • Serialization
    • Serializable
    • Externalizable
    • ObjectOutput
    • ObjectOutputStream
    • ObjectInput
    • ObjectInputStream
    • A Serialization Example
    • Stream Benefits
  21. Networking
    • Networking Basics
    • The Networking Classes and Interfaces
    • InetAddress
    • Factory Methods
    • Instance Methods
    • Inet4Address and Inet6Address
    • TCP/IP Client Sockets
    • URL
    • URLConnection
    • HttpURLConnection
    • The URI Class
    • Cookies
    • TCP/IP Server Sockets
    • Datagrams
    • DatagramSocket
    • DatagramPacket
    • A Datagram Example
  22. The Applet Class
    • Two Types of Applets
    • Applet Basics
    • The Applet Class
    • Applet Architecture
    • An Applet Skeleton
    • Applet Initialization and Termination
    • Overriding update( )
    • Simple Applet Display Methods
    • Requesting Repainting
    • A Simple Banner Applet
    • Using the Status Window
    • The HTML APPLET Tag
    • Passing Parameters to Applets
    • Improving the Banner Applet
    • getDocumentBase( ) and getCodeBase( )
    • AppletContext and showDocument( )
    • The AudioClip Interface
    • The AppletStub Interface
    • Outputting to the Console
  23. Event Handling
    • Two Event Handling Mechanisms
    • The Delegation Event Model
    • Events
    • Event Sources
    • Event Listeners
    • Event Classes
    • The ActionEvent Class
    • The AdjustmentEvent Class
    • The ComponentEvent Class
    • The ContainerEvent Class
    • The FocusEvent Class
    • The InputEvent Class
    • The ItemEvent Class
    • The KeyEvent Class
    • The MouseEvent Class
    • The MouseWheelEvent Class
    • The TextEvent Class
    • The WindowEvent Class
    • Sources of Events
    • Event Listener Interfaces
    • The ActionListener Interface
    • The AdjustmentListener Interface
    • The ComponentListener Interface
    • The ContainerListener Interface
    • The FocusListener Interface
    • The ItemListener Interface
    • The KeyListener Interface
    • The MouseListener Interface
    • The MouseMotionListener Interface
    • The MouseWheelListener Interface
    • The TextListener Interface
    • The WindowFocusListener Interface
    • The WindowListener Interface
    • Using the Delegation Event Model
    • Handling Mouse Events
    • Handling Keyboard Events
    • Adapter Classes
    • Inner Classes
    • Anonymous Inner Classes
  24. Introducing the AWT: Working with Windows, Graphics, and Text
    • AWT Classes
    • Window Fundamentals
    • Component
    • Container
    • Panel
    • Window
    • Frame
    • Canvas
    • Working with Frame Windows
    • Setting the Window’s Dimensions
    • Hiding and Showing a Window
    • Setting a Window’s Title
    • Closing a Frame Window
    • Creating a Frame Window in an AWT-Based Applet
    • Handling Events in a Frame Window
    • Creating a Windowed Program
    • Displaying Information Within a Window
    • Introducing Graphics
    • Drawing Lines
    • Drawing Rectangles
    • Drawing Ellipses and Circles
    • Drawing Arcs
    • Drawing Polygons
    • Demonstrating the Drawing Methods
    • Sizing Graphics
    • Working with Color
    • Color Methods
    • Setting the Current Graphics Color
    • A Color Demonstration Applet
    • Setting the Paint Mode
    • Working with Fonts
    • Determining the Available Fonts
    • Creating and Selecting a Font
    • Obtaining Font Information
    • Managing Text Output Using FontMetrics
    • Displaying Multiple Lines of Text
    • Centering Text
    • Multiline Text Alignment
  25. Using AWT Controls, Layout Managers, and Menus
    • AWT Control Fundamentals
    • Adding and Removing Controls
    • Responding to Controls
    • The HeadlessException
    • Labels
    • Using Buttons
    • Handling Buttons
    • Applying Check Boxes
    • Handling Check Boxes
    • CheckboxGroup
    • Choice Controls
    • Handling Choice Lists
    • Using Lists
    • Handling Lists
    • Managing Scroll Bars
    • Handling Scroll Bars
    • Using a TextField
    • Handling a TextField
    • Using a TextArea
    • Understanding Layout Managers
    • FlowLayout
    • BorderLayout
    • Using Insets
    • GridLayout
    • CardLayout
    • GridBagLayout
    • Menu Bars and Menus
    • Dialog Boxes
    • FileDialog
    • A Word About Overriding paint( )
  26. Regular Expressions and Other Packages
    • The Core Java API Packages
    • Regular Expression Processing
    • Pattern
    • Matcher
    • Regular Expression Syntax
    • Demonstrating Pattern Matching
    • Two Pattern-Matching Options
    • Exploring Regular Expressions
    • Reflection
    • Remote Method Invocation (RMI)
    • A Simple Client/Server Application Using RMI
    • Formatting Date and Time with java.text
    • DateFormat Class
    • SimpleDateFormat Class
    • The Time and Date API Added by JDK 8
    • Time and Date Fundamentals
    • Formatting Date and Time
    • Parsing Date and Time Strings
    • Other Things to Explore in java.time
  27. Introducing Swing
    • The Origins of Swing
    • Swing Is Built on the AWT
    • Two Key Swing Features
    • Swing Components Are Lightweight
    • Swing Supports a Pluggable Look and Feel
  28. Database Concepts using MySQL
    • DDL Queries
    • DML Queries
    • Data Export/Import
    • Keys
    • SQL Joins
    • MySQL Datatypes
    • Aggregate Functions
    • Null Value
    • Auto Increment
    • Default Values
  29. JDBC Concept
    • Connection interface
    • DriverManager class
    • Statement interface
    • PreparedStatement interface
    • ResultSet interface
    • Type of ResultSet
    • SQL Injection
  30. Projects(Desktop Applications)
    • Notepad Project
    • Calculator Project
    • JAVA IDE Project
    • Game Project like Archery, Ludo, Snake And Ladder, Air Hockey(Any one)
    • Management Project like Chat Server,Hospital Management, Hotel Management (Any one)