Confidently follow learning paths that help you develop the right skills in the right order to achieve your goals.
Java is a programming language used for both client-server programs, web applications and Android development. It is one of the most popular programming languages and runs on all platforms via the Java Virtual Machine (JVM). Java’s syntax was originally derived from C and C++ and was created by Sun Microsystems between 1991 and 1995. While it is mostly considered to be an object-oriented language, it is really more of a multi-paradigm language due to the inclusion of imperative and generic paradigms. It is a statically typed language and has various type-safety features built right in.Get Started
Java Developer, Back-end Developer, Software Engineer, Object Oriented with Java, JSP, Spring
No previous experience is required, and all necessary tools and concepts will be introduced throughout the path.
These introductory Java courses will teach you the basics of the language and how to effectively work with Java in the EE context. Some of the concepts you will master in this section include control flow in Java, object orientation, exception handling and even generics. By the end of these Java courses you will have the skillset to work on your own Java application.
This course provides complete coverage of the Java programming language giving you the strong language foundation required for any Java-based development environment. Whether targeting a client-based, server-side, or Android environment, this course provides you with everything you need to quickly ramp up and become an effective Java programmer.
Java’s powerful generics has been available to developers for ten years now and is extensively used throughout both core and third party libraries. Unfortunately, it's not as well understood as it could be. This course is here to help. We’ll both shine a light on the common use cases of generics on classes, methods, or interfaces and also peer into some of the darker corners such as type bounds and wildcards.
This course introduces web developers (with or without Java EE experience) to Java EE development leveraging WebSphere® Application Server. You will first be guided through installing and configuring WebSphere® Application Server, as well as integrating Eclipse. With everything set up, you will be taken through configuring a data source and developing an entire enterprise application from backend, to web front end, to web services.
This section of Java tutorials goes further in depth with the language, giving you additional tools for your Java toolbelt. Now that you know a little about Java, you’ll be ready for the next level of understanding as you dive into memory management, reflection and even useful frameworks like Spring.
Java is built around classes; these classes have to be loaded into memory and loading that is the responsibility of class loaders. The first part of this course will look at this class loading mechanism and how to write class loaders. Once you understand this, several scenarios become available, such as hot deployment of classes and the side-by-side loading of classes. Java has a rich type system and rich metadata. Reflection is the mechanism by which you can examine that metadata at runtime, and use that information to build rich applications. In the second part of this course, we will see how to use reflection to both examine this metadata at runtime and use it within our applications.
Garbage Collection (GC) is a fundamental part of Java. Understanding how GC works is core to understanding how the Java Virtual Machine (JVM) works and will help you write better applications and to improve the performance of those applications. This course will look at all aspects of garbage collection, including looking at what 'young' and 'old' generations are, how the JVM moves objects between eden and survivor spaces, how memory is promoted into the 'old' generation, how different garbage collectors work, and how they affect the running of your application. We will also look at 'card tables' and how they help manage memory in the old generation. We will examine each of the garbage collectors including the serial and parallel collectors; the CMS collector and the G1 collector. We cover the tools you can use to monitor GC including jstat and VisualVM. Finally we look at ways you interact with the GC through classes Such as Soft, Weak, and PhantomReference and their associated helpers ReferenceQueue and WeakHashMap.
Java security is built around the idea of permissions and policy. Code is granted permissions based on the currently in-force policy. In this course, we look at how the security manager and access controller work hand-in-hand to provide this security. The course covers how to set a security manager and how to set up and edit a policy file to grant the levels of permissions that code needs. Permissions are typically based on where code is loaded from but we also look at how to sign code, so that permissions can be based on who created a library. The course also looks at how the AccessController walk the call stack to check that a permission can be granted. While the JRE comes with a set of permissions, these are not always enough so the class covers creating and using your own permissions. Finally we cover the idea of 'privileged scope' which allows code to be granted some permission even when code around them should cause the grant to fail.
This course covers all of the fundamentals of Spring. It covers Java Configuration, XML Configuration, Annotation based Configuration, Beans and their Scopes, and Properties.
This final section is designed for the Java developer with a little experience under their belt. This sections of advanced Java tutorials dives deep into areas that every Java pro will want to ace before they call themselves a master. Topics such as patterns, best practices and testable code are fully covered in this section.
This course introduces why you want to write automated tests for your code and how to implement this in Java, covering fundamentals of how to write simple tests using JUnit and Hamcrest, through Test Driven Development (TDD) and then explains how to structure your code and design in order to make testing easier.
This course covers Test-Driven Development (TDD) practices and tools supporting TDD on the Java Platform. This includes information on JUnit, Mockito, PowerMock, and DBUnit.
This course is part of a three-part series covering design patterns using Java. This part covers structural design patterns such as Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy as defined by the Gang of Four. We look at examples in the Java API and code examples of each pattern.
This course is part of a 3 part series covering design patterns using Java. This part covers the creational design patterns, Singleton, Builder, Prototype, Factory, and AbstractFactory as defined by the Gang of Four. We look at examples in the Java API and code examples of each pattern.