In your experience
I was going to post a link here but then I would advertising and that is not my idea, so I decided to just post the content of the course.
In your experience would you say that this is a good course for me to start with:? I do not have any back ground in programming but I am king to learn.
In total this is a 5 day course based in London.
Course Content
Module 1 - Getting Started
Origins of the language and its key features
Describing the Java Runtime Environment and the components of the Java 2 Standard Edition (J2SE)
Comparing local and distributed Java applications and associated security features
Writing, compiling and running a simple Java application
Using documentation for the J2SE class libraries
Module 2 - Object-Oriented Programming
Defining classes, objects, variables and methods
Building an object and understanding object references and garbage collection
Using constructor methods to initialise objects
Using package and import statements to access the J2SE class libraries
Applying access modifiers to object members
Module 3 - Keywords and primitive types
Recognizing Java Keywords
Listing the eight primitive types
Understanding conversion and casting of primitive types
Recognizing and using Java operators
Module 4 - Flow Control
Iteration using for loops, while loops and do-while loops
Building nested loops, and breaking out of a loop
Using labels and the continue keyword
Building alternative execution paths with a switch block
Module 5 - Arrays
Declaring, creating and initialising arrays of primitive types
Building arrays of objects
Building multi dimensional arrays
Passing arguments into the main method of a command line application
Building an application that uses arrays, method calls and iterative loops
Module 6 - Object-Oriented design
Describing the three pillars of object-oriented design (Inheritance, Polymorphism and Encapsulation)
Inheritance and building a derived class
Understanding a class hierarchy and the methods of the Object class
Describing polymorphism and building an overriding method
Enforcing polymorphism with interfaces and abstract classes
Encapsulation and its advantages in producing maintainable code
Module 7 - Further Class Features
Building overloaded methods and constructors
Declaring and using static variables and methods
Declaring and using final classes, variables and methods
Module 8 - Exceptions
Defining exceptions and building code to handle a runtime exception
Explaining the Exception class hierarchy and categories of exceptions
Declaring methods that may throw exceptions
Using the throw keyword forward an exception
Building a user-defined Exception class
Module 9 - Collections
Categorising collections classes by the interfaces that they implement
Using Sets, Lists and Maps to store collections of objects at runtime
Building an iterator to access the objects in a Set
Adding key - value pairs to a HashMap
Using object reference casting when assigning references from a collection
Module 10 - Building a Graphical User Interface (GUI)
Describing the Swing package and its components
Building an application window and adding components to the Content Pane
Explaining layout managers and the rules by which they position components on a window
Using BorderLayout, FlowLayout, GridLayout and GridBagLayout managers
Building inner classes to handle events in a GUI , such as a menu selection
Adding a user interface to the command line application built during previous modules
Module 11 - Applets
Comparing GUI applications to applets
Explaining applet methods that are called by the browser
Writing HTML code to display an applet within a web page
Executing a Java 2 applet on any browser by automatically downloading the Java Runtime Environment
Using the paint method to draw an image on a component
Module 12 - Threads
Creating threads to enable concurrent execution of multiple tasks
Declaring synchronized code to prevent simultaneous access to a method by more than one thread
Moving threads between states using the wait and notify methods
Using a shared object to communicate between threads
Module 13 - I/O Streams
Interrogating the local file system
Using Character Streams to read and write to a text file
Understanding processing streams and linking them to sink streams
Building byte streams to send and receive binary data
Using object serialization to give persistence to objects
Module 14 - Networking
Distinguishing between Transmission Control Protocol (TCP) and User Datagram Protocol (UDP)
Translating between character streams and byte streams
Building a Server application that listens on a specified port
Building a Client application that establishes a connection with the Server and sends some text
Following by the second part :
Course Content
Module 1 - Java Database Connectivity (JDBC)
Describing the JDBC architecture
JDBC driver categories, including the JDBC-ODBC bridge and Type 4 drivers
Establishing a database connection
Creating and updating a database table
Using batch updates and prepared statements
Querying a database and extracting metadata
Using record locking and committing or rolling back a transaction
Handling SQL exceptions and obtaining the SQL state for single and chained exceptions
Module 2- The Java API for XML Processing (JAXP)
Explaining XML Document structure, namespaces and Document Type Definitions
Parsing XML data with the Simple API for XML Parsing (SAX)
Parsing XML data with the Document Object Model (DOM) and navigating through the DOM
Writing code to read an XML file into a database table
Reading a ResultSet from an SQL query into an XML DOM
Transforming an XML document using an XSL stylesheet
Module 3- Adding a Swing User Interface to the database application
Defining Model-View-Controller architecture
Using UML class diagrams to describe the types of objects in an application and their static relationships
Building a GUI using ?drag and drop? and understanding the underlying code
Using a TableModel object to parse and display XML data in a JTable
Building a client-side Controller object to interact with the database
Displaying input dialogs and message dialogs
Module 4- Remote Method Invocation
Describing the RMI architecture and the alternatives to RMI
Listing the steps involved in developing applications using RMI
Defining and implementing a remote interface
Generating stubs, starting the registry and registering objects
Looking up a remote object using the RMI protocol
Dynamically loading and instantiating class files from a web server
Implementing security with a policy file
Creating worker threads for time-consuming tasks
Module 5- Servlets and Web containers
Explaining the purpose and structure of a Servlet, and deploying a Servlet in a Web Container
Writing a Servlet that will return XML data from an SQL query sent over HTTP from a Web client.
Adding code to enable the Servlet to be accessed from the Swing application client built during previous modules
[ Note that, while Servlets are part of the Java 2 Enterprise Edition, this module may be useful to delegates who intend to deploy Java applications in a Web Container provided by their Internet Service Provider ]
Many thanks for any comment reagarding my query.
Kind Regards,
