Continuing Studies in Java Development

course content details

	Java editions

This unit introduces the various Java 2 platform editions, including J2SE, J2EE, and J2ME. It examines the features of each and identifies the resulting technologies of each. After completing this unit, you should be able to:

	introduce the three Java 2 Platform editions
	compare and contrast features of J2SE, J2EE and J2ME
	describe the resulting technologies of each edition

	Coding best practices

This unit describes various programming best practices that Java developers need to be aware of. The proper use of constructors, overridden methods and coding structures will all be explored. After completing this unit, you should be able to:

	describe coding conventions
	discuss rebinding parameters in Java
	describe Java Big 4
	discuss immutable and thread safe objects
	describe the proper use of constructors and conditional code blocks

	Networking with sockets

This unit looks at the use of protocols, sockets, and URLs to make network connections to remote JVM implementations in a client server environment. After completing this unit, you should be able to:

	define and use protocols
	define and use sockets
	define and use Uniform Resource Locators (URL)

	Serialization

This unit introduces the topic of representing objects outside of the Java virtual machine. Serialization is Java’s solution for producing a complete object’s state which can be recovered at a later time, and be used in streaming. After completing this unit, you should be able to:

	describe serialization
	describe externalization
	compare and contrast serialization and externalization
	describe the process of versioning a class

	Distributed objects (part 1)

This unit introduces Remote Method Invocation (RMI) as a solution for enabling communication among objects that are developed with the Java language. The differences and advantages of using RMI over Socket communication will also be explored. After completing this unit, you should be able to:

	describe RMI
	discuss the responsibilities of the RMIClassLoader
	describe of dynamic code loading
	explain garbage collection in RMI
	describe the role of the rmiregistry
	describe the different RMI configuration models
	describe the process to customize a distributed RMI application to use dynamic class loading

	Design patterns (part 2)

This unit describes additional design patterns that are commonly used in Java development including Factory, Singleton, State, Bridge and Flyweight. After completing this unit, you should be able to:

describe and compare the Factory, Singleton, State, Bridge and Flyweight design patterns

	Distributed objects (part 2)

This unit looks at other options when dealing with remote objects, specifically the Java Interface Definition Language (Java IDL) and Remote Method Invocation using the Internet Inter-Orb Protocol (RMI-IIOP). RMI, RMI-IIOP and Java IDL will be compared and contrasted to understand which technology should be used for any specific type of application. After completing this unit, you should be able to:

	describe the role that Java IDL plays in Java application development
	explain the major IDL components and their function
	understand the relationship between Java IDL and the Common Object Request Broker Architecture (CORBA)
	describe an Object Request Broker (ORB)
	describe the Internet Inter-ORB Protocol (IIOP)
	describe RMI-IIOP
	compare and contrast Java IDL, RMI, and RMI-IIOP

	Java Naming and Directory Interface (JNDI)

This unit describes the directory and naming services that can be used in application programming. The JNDI is introduced and its API is explored. After completing this unit, you should be able to:

	describe directory and naming services
	explain the usefulness of the Lightweight Directory Access Protocol (LDAP)
	describe the use of JNDI to provide an interface to different directory service vendors

	Exception handling

This unit describes various exception handling techniques and introduces the theory behind proper exception handling. After completing this unit, you should be able to:

describe and understand exception handling concerns

	Java for databases

This unit explores various database manipulation techniques, including JDBC and SQL for Java (SQLJ) support in Java. Datasources and connection pooling are introduced as a way to customize the database connection.

	write basic JDBC Java code to query an SQL database
	explain the functions of Driver, Connection, Statement, and ResultSet
	explain the use of connection pooling and datasources
	describe SQLJ technology

	Java for messaging systems

This unit describes two different ways that Java applications can interoperate with external messaging systems: message queuing support through Java Message Service (JMS) and e-mail support through JavaMail. After completing this unit, you should be able to:

	define basic messaging concepts
	describe the parts of a message from a Java perspective
	describe JMS support
	describe JavaMail support
	introduce the JavaMail API
	describe the JavaBeans Activation Framework

	Java resource loading

This unit describes the process of loading application-dependent resources in Java. Class loaders and their responsibilities in this will be explored. Java’s file compression utility Java Archive (JAR) files will introduced to help aid in the loading of resources. After completing this unit, you should be able to:

	describe resources
	explain class loader responsibilities
	describe the java.lang.Class class
	explain the loading of resources in Java
	define the term Java Archive (JAR) and its use

	Internationalization

This unit introduces internationalization in Java. Displaying output in a Locale-dependent format along with the use of resource bundles are explored. Formatting and parsing dates, times, numbers,and messages according to Locale will also be discussed. After completing this unit, you should be able to:

	define and compare globalization, internationalization, and localization
	define and use Java Locale class
	isolate Locale-specific information using resource bundles
	format and parse dates, times, numbers and messages

	Security

This unit describes some security concepts that are commonly used in the design of a Java program and what allows Java to be a strong security minded programming language. After completing this unit, you should be able to:

	describe the Java Security Model
	describe general security concepts
	describe Java-related security
	understand keys and certificates
	explain Java security policies and their creation

	Server application construction

This unit presents some considerations in improving the performance and functional scalability of a server. After completing this unit, you should be able to:

	discuss how caching helps with server performance scalability
	discuss some considerations in building a cache in the server
	describe how using a Visitor design pattern helps with server function scalability
	use the Visitor design pattern to increase server malleability

	JUnit testing

This unit describes performing JUnit testing to aid in building quality software by enabling the incremental testing of the software. After completing this unit, you should be able to:

	describe JUnit
	list the advantages that incremental testing provides

	Performance

This unit describes various performance considerations for all Java programs, including API selection, optimization, Just In Time compiling, and Java HotSpot technology. Some common coding considerations will also be explored. After completing this unit, you should be able to:

	code a Java program to take advantage of better performing code
	describe the optimization process
	explain how a Just in Time (JIT) compiler works
	explain how Java HotSpot performance engine works