Apprentice Developer to Journeyman Developer

This 12-video course explores Java, the general-purpose programming language, among the most popular languages used to create Web applications and platforms. Designed to allow developers to write code that would run on any machine, Java is an easy-to-use object-oriented model with platform independence and robustness. Course participants will learn how to install Java on both Windows and Macintosh-based systems and observe how developers use Java Development Kit (JDK) to build applications and components. The course examines Java bytecode and how it instructs the JVM (Java Virtual Machine). You will explore the Java sandbox environment and the JRE (Java Runtime Environment). The course also demonstrates how to configure two of the most popular Java IDEs (Integrated Development Environment): Eclipse, the most popular open-source IDE, which runs under Windows, Linux, and Mac OS; and IntelliJ which analyzes code and looks for connections between symbols across all project files and languages and provides intelligent coding assistance for a large variety of other languages such as SQL, JPQL, and Javascript.

This 11-video course explores Java, a program used in real-world commercial situations such as e-commerce websites, android apps and even the game Minecraft. Particpants will learn the eight primitive data types in Java and how to use them-Boolean, byte, char, short, int, long, float, and double-the most basic data types available within Java. The course examines how they serve as the building blocks of data manipulation in Java. First, learn about the types, including Object types, Strings, and Arrays, which are inherited from the java.lang.Object base class. Then learn how to create arrays, which are containers that store a fixed-size sequential collection of elements of the same type. You will learn that arrays can be both primitive and object types. Learn to print their contents, and access individual elements. The course also examines how to create enumerated types, commonly known as enums, which are a special Java type used to define collections of constants and learn how to use these types of variables.

This 9-video course explores the semantics of the logical and arithmetic operators in Java and how they are used to manipulate operands. The course demonstrates how a small change in an expression can lead to profound changes in output. A recommended prerequisite for this course is a knowledge of primitive data and object types in Java. In this course, you will learn the importance of developing an expression to meet project applications since, in Java, false is the default value. The logical operators are boolean operators, comparison operators, and the use of parentheses. Participants will see examples of boolean logical operators and comparison operators, and arithmetic operators. You will learn to use Java's built-in short-circuit addition and subtraction operators to perform mathematic operations, and how parentheses are used to alter arithmetic expressions. The course also covers use of a unary operator to take a single operand/argument and perform an operation. Finally, the course demonstrates the application of pre- and post-increment and decrement when using a unary operator.

This 11-video course focuses on string objects in Java. Participants will learn the basics of string objects, which encapsulate an array of characters used to compose words, sentences, or any other data one wants. The course demonstrates how to initial string objects and shows how the process of initialization influences comparisons of strings. Begin by initializing strings with StringBuilder and StringBuffer objects, which can be used to efficiently alter and construct strings. Then see how Java initializes the StringBuffer to have a certain initial capacity, and learn how to allocate additional capacity as needed. This course features an in-depth study of the difference between the double equal to operator and the .equals method, when comparing object types that include strings. You will also learn how null is a reserved keyword for literal values. Participants will learn how to encapsulate the eight primitive types of variables into objects with the built-in wrapper classes, by using Java's eight wrapper types.

This 12-video course addresses the conditional control structures available in Java by examining the three types of control structures in Java: if/else/else if, ternary operator, and switch. In this course, participants will examine how to use loops to iterate through multiple values/objects and repeatedly run specific code blocks. First, you will learn simple if constructs, which evaluate a condition to determine the flow of program control. You will then study how if-else statements provide a ladder to complex nested conditions and how an if-else statement can lead to bugs. Next, learn what makes the switch construct an easy way to dispatch execution to different parts of code based on the value by byte, short, char, and int primitive data types. Learn how to use a switch station for branching program control based on different values of a single variable, and how to pick a switch statement to avoid bugs. Finally, participants will learn to identify situations in which multiple variables need to be taken into consideration, and how to deploy nested if-else control structures.

This 11-video course examines the use of loops in Java, where iterative control structures are named for-loops, while loops, and do-while loops. This course opens by studying simple for-loops and introduces the concepts of the check expression, the loop variable, and the UPDATE statement. You will learn how to use enhanced for-loops, popular for iterating over arrays and collections. Participants then explore how to short-circuit a loop by using the break statement, and how to short-circuit the current iteration by using continue. Once a break statement is encountered in a loop, it is automatically terminated and the program control resumes at the next statement following the loop. The course then demonstrates how to do this in the context of for-loops, while loops, and do-while loops. You will learn to identify situations where for-loops are preferable to while loops. Finally, examine the dangers of infinite looping in the context of while looping, and learn to identify common pitfalls that lead to infinite looping and how to avoid these pitfalls.

What makes the programming language Java so useful is that can run on multiple platforms. In this course, you will examine Java and its support for object-oriented programming. This course uses real-world entities to demonstrate how member variables represent the state of those entities, and how member functions represent the behavior of those entities. Participants study the various basic types of variables in Java and distinctions between eight primitive types and strings, which are a type of object. You will learn that all basic building blocks of all operations are these basic types of variables. As a practical exercise, create a project in Java with Java's two basic building blocks, the twin concepts of classes and objects. Next, learn to create classes and instantiate objects of these classes. You will discover that all objects in Java come with certain built-in capabilities, because they all inherit from a common ancestor base class. Finally, participants learn how to use constructors, getter methods, and setter methods to configure and initialize Java objects.

The instantiation of objects in Java is the subject of this 9-video course, in which learners explore how each class has one or more constructor methods. This course examines the default, no-argument constructor provided by Java for each class and shows how constructors initialize member variables to a sensible initial state. Each learner will create his or her own defined class, instantiate that class, and use different types of constructors. You will learn to define your own parameterized constructor and will see that Java automatically removes the default no-argument constructor. Then explore how to implement correct getter and setter methods and to use the getter and setter methods to access member variables from outside a class, along with the use of the private access modifier to regulate such access. This course shows different overloaded methods in the context of constructors. Finally, you will learn that Java allows overloading constructors in a class, and how this ability allows one to create objects by using different methods.

This course explores member functions and their invocation in Java. learners begin by studying object references and learning the subtleties and nuances of how these references sometimes lead to unexpected results in a program. Learn to use a copy constructor to break references that existed from rectangle objects to the point objects and how they become self-sufficient. Next, you will see that the classes you created often have multiple overloaded methods, which can lead to code duplication. You will learn how to correctly chain the implementations of overloaded constructors and other overload methods. You will also begin to understand the reference variable, 'this' keyword, to avoid naming conflicts in constructor chaining. You will see how to create variables or methods that ought to be one per class, rather than one per instance using the static keyword. Finally, you will become familiar with the different rules that govern how static members and methods are accessed, and how some forms of access that are allowed by the Java compiler are not considered a best practice.

This course examines Java's support for exceptions and covers three specific topics: initialized blocks, the details of pass-by-value and pass-by-reference semantics, and the two types of nested classes. You will work in Java with initialization blocks on both static member values to construct static elements in your class and on non-static member variables as an alternative to constructors. This course uses examples of pass-by-value and pass-by-reference code to demonstrate how variables behave when they are passed from one function to another in arrays and strings. Next, learners explore the semantics of argument passing for primitive types, strings, and for objects. You will experiment with arrays and learn to use the Arrays.toString helper method. You will learn the rules and conventions that govern the two types of nested classes: static classes and inner classes. Finally, learn how a static class is created or nested inside a class, and how inner classes can logically group classes and interfaces in one place.

This course explores Exception Handling in Java and provides users with a strong conceptual and theoretical foundation and examines practical code-based scenarios. Begin by examining what exceptions are in Java and how Java's class hierarchy addresses errors, runtime exceptions, and checked exceptions. An exception is an event that disrupts the normal flow when executing a program, and you will learn here how to differentiate between exceptions and errors. Participants will learn to use Java's catch-or-specify requirement on code that throws specific types of exceptions. You will also learn that an exception handler is code which deals with a particular exception, both its type and location, in the program. Next, learn the sequence of method calls or function calls which culminated in the exception being thrown. The course will then explore the common runtime exceptions, and see how input-output (IO)-related code often poses special challenges in exception handling. Finally, you will be shown how exception handling is tied to the try-catch keywords.

This course covers the bedrock of Exception Handling in Java, the try-catch-finally code structure. Participants will cover the class hierarchies in exception handling; the stream and file processing; and how Java's support for exceptions and streams is built around complex class structures. You will learn how code might result in exceptions that are enclosed within a try block. Because this code structure could result in a signal to Java that normal programming might be disrupted and will cause the code evaluation to be short-circuited, the course explores details of catch blocks, including the use of multiple catch blocks; the use of the pipe operator ( - operator) to chain different exceptions within the same catch block; and how catch blocks must be arranged for related exceptions. The last part of exception handling is the 'finally block.' This keyword (finally) is used to ensure the correct release of resources, such as file handles, no matter what handled or unhandled exceptions might arise within the try block.

In this course, you will learn about the correct use of the throws clause, Java's relatively new try-with-resources construct, and the use of custom exceptions. Explore how to correctly use the throws clause while defining method signatures and implementing exception handling in a chain of methods that sequentially call each other. You will learn to ensure that resources are automatically closed, relying on language support, using the try-with-resources construct; and recognize the precise semantics of this construct in Java. This leads to throwing an object of a built-in exception type to respond to an unexpected situation in a program, and differentiating between the semantics of throwing runtime exceptions versus checked exceptions. The correct way to invoke a method that throws an exception of a checked exception type will be examined, along with how to correctly declare or handle exceptions in a chain of functions, each of which throws different types of exceptions. Finally, participants will explore the use of custom exceptions, defining their own exception classes, and then throwing exceptions that belong to those classes.

In this series of video tutorials, you will learn about file and stream handling in Java with a strong conceptual foundation, before moving onto practical scenarios. Begin by learning how to navigate Java's complicated hierarchy of classes for dealing with byte and character streams. You will then learn how to apply the skip and available methods of FileInputStream objects and identify when the end of a byte stream has been reached. You will be able to write a byte stream by using the OutputStream and FileOutputStream classes, and then examine how to copy any file as a byte sequence using the FileInputStream and FileOutputSream classes. Move on to learning how to read a character stream using the FileReader and FileWriter classes. You will then copy a character file as a sequence of characters using the FileReader and FileWriter classes. At the end of the course, participants will be able to summarize the key concepts covered.

In this nine-video course, you will be focusing on Java's parallel class hierarchies for working with byte and character data and the various variants available to you. To begin, participants will learn how buffered stream handling saves on unnecessary inout-output (IO). Learn how to use the BufferedInputStream and BufferedOuputStream classes to interact efficiently with byte streams, and then to use the BufferedReader and BufferedWriter classes to interact efficiently with character streams. As you progress, you will explore how to use the DataOutputStream class to write primitive types and strings to byte strings, and the DataInputStream class to read primitive types and strings from byte streams. This leads participants to utilize the ObjectOutputStream class to write objects of any type to byte streams and the ObjectInputStream class to read objects of any type from byte streams. Finally, you will implement the Serializable interface in user-defined classes so that they can be written to and read from using ObjectOutputStream and ObjectInputStream objects.

In this course, participants learn more about Java's application programming interface (API) for working with files and directories. You will begin with the Path interface and the Paths.get methods to work with files and directories, which form the foundation of the modern java.nio APIs. You will then discover how to use the methods of the Path interface to normalize, parse, and resolve paths. Next, you will briefly detour into creating files using both the legacy java.io as well as the modern java.nio namespaces. Perform operations such as copying files, checking for their existence, and deleting files using the Files class in the java.nio namespace. Participants will also copy and create directories by using the Files class in the java.nio namespace. You will explore how to get and set file attributes (including both platform-agnostic as well as Portable Operating System Interface attributes), and query file stores for total and free space. Finally, learn how to create directories and iterate over their contents, including via the use of glob specifiers to filter directory contents.

Final Exam: Apprentice Developer will test your knowledge and application of the topics presented throughout the Apprentice Developer track of the Skillsoft Aspire Apprentice Developer to Journeyman Developer Journey.

In this course, you will explore the basics of inheritance and run-time polymorphism in Java, and how these concepts can be used to model Is-A relationships. Begin with an introduction to inheritance, and how to identify its advantages and applications. You will then apply inheritance to model real-world entities. Next, learn the concepts of polymorphism, its advantages and applications. Then move on to recognizing how the methods derived from java.lang.Object work, and also how all built-in Java classes possess the methods derived from java.lang.Object. You will examine how objects of derived classes have independent copies of member variables, even from the derived class. Following an introduction to the Is-A relationship, you will learn how to recognize, in single inheritance, that every object of the derived class is an object of the base class, but not every object of the base class is an object of the derived class. Explore how to upcast and downcast, and learn how downcasting can sometimes be dangerous. Finally, learn how one base class can be created with multiple derived classes.

In this course, you will learn the role of constructors and how to use the super keyword in architecting inheritance hierarchies in Java. You will begin by identifying the role of access modifiers and recognizing the basics of superclass constructors. When you add your own constructor, you will see that Java takes away the default no-argument constructor it had provided. You will learn how to apply the two ways of initializing derived classes: implement an explicit no argument constructor in the base class or use the super keyword and have only parameterized constructors in both the base and derived classes. You will recognize that a base class's constructor is invoked when a derived class object is instantiated and identify what happens when there is a base and derived class that have many different constructors. You will be able to initialize member variables: add a member variable into a derived class and ensure it is correctly initialized, even in addition to any invocations of the base class constructor.

In this course, learners will focus on creation of multilevel inheritance in Java and how such hierarchies include child and grand-child classes that all inherit from a common ancestor base class. Begin with an introduction to multilevel inheritance, and how you can access multiple derived classes by using a base class in multilevel inheritance. Explore use of the instanceof operator, where you can check that an object is an instance of every class in its inheritance hierarchy. Concerning the Is-A Relationship, you will learn how to apply multilevel inheritance when every object of the derived class is an object of the base class, but not every object of the base class is an object of the derived class. Examine downcasting; see how to upcast multiple levels; learn why downcasting is very dangerous; and perform various upcasting operations. After moving on to multilevel inheritance hierarchies, you will construct two parallel base classes and derived classes for each of those base classes. Finally, explore use of the extends keyword, recognizing situations where multiple inheritance is allowed.

In this 9-video course, you will learn about specific contrasts between run-time, compile-time polymorphism, and inheritance hierarchy in Java, including use of the Override annotation and type promotions in method overloading. Beginning with an introduction to polymorphism, you will examine run-time and compile-time polymorphism and recognize how run-time polymorphism works. In other tutorials, participants will look at the use of the @Override annotation, then look at how polymorphism works in the presence of a multilevel inheritance hierarchy, which leads on to discovering how easy it is to add a class into an inheritance hierarchy. You will then be introduced to the use of compile-time polymorphism and method overriding. To understand type promotion, you will begin to use compile-time polymorphism, including type promotions. In addition, you will learn how to recognize that compile-time polymorphism does not include type demotions. As the course concludes, you will learn how to use a combination of run-time and compile-time polymorphism.

In this course, you will learn about method overriding, including the use of the super keyword from contexts other than within constructions, and also examine the behavior of static methods. To start, participants learn how to apply method overriding and recognize the concept of hiding, and use the super keyword inside any method invocation in the derived class. This follows on to the use of advanced forms of overriding, combining method overriding with complex inheritance hierarchies. Study static methods and static binding, recognizing that static methods do not support run-time polymorphism. Examine pitfalls to avoid with static methods by learning to recognize how static methods are bound using compile-time rather than run-time binding. Learn how to correctly override the method .toString, which is inherited from java.lang.Object, and describe how the .equals method and the == operator are related. Explore how to correctly override the .hashCode method and write the code to correctly override the .equals method, inherited from java.lang.Object. Finally, after studying the link between equals and hashCode, discover how to implement the .hashCode contract.

In this course, participants learn about two specific and important aspects of Java-the final and abstract keywords. The final keyword can be used to mark member variables, member functions, and even entire classes, with different meanings in each context. You will discover how to mark variables as final, and the implications of doing so. Learn how to correctly instantiate final arrays. Remember that arrays are reference types, pointing to a block of memory, and remember that once an array has been marked as final, it can only be initialized once. Discover how to create and use final classes and final methods. Final classes cannot be extended. You will learn to recognize the implications of defining a class as abstract. Also, learn how to extend abstract classes and the implications of doing so. As the course concludes, you will discover that a class can only be instantiated if it has implemented all abstract methods.

In this course, you will learn about access modifiers that can be used to tag member variables and member functions inside Java classes to regulate how these can be accessed from different contexts. Participants begin by examining the properties of public, private, and protected access modifiers. These properties govern how classes, member functions, and member variables can be accessed within the same class, outside the same class but within the same package, and in entirely different packages. This leads into an examination of cross-package access and how access works from one package into another. You will then learn about the semantics of protected members, and the use of the protected access modifier. Next, explore the cross-package access of protected members, which enables you to use the protected keyword across packages. As the course concludes, you will learn about the semantics of using default access modifiers both inside and outside the same package.

In this course, you will focus on one of the most important concepts in all object-oriented programming for Java, the interface. Learners explore how anonymous inner classes provide lightweight instantiations of interfaces, and how interfaces are pure abstract entities. Begin with an introduction into using interfaces and how all their methods are abstract by default. Examine how the instanceof operator works the same way with interfaces as with classes. This leads on to combining the extends and implements keywords: implementing a derived class that can extend a base class and implement an interface. Then learners learn to set up two inheritance hierarchies and combine these into a set of objects that implement both sets of interfaces. Advanced features of interfaces are also examined. Learn how interfaces can support default method implementations. You will set up a class that implements some of the methods of an interface and declares itself abstract. Finally, you will create and define anonymous inner class objects and access outer class variables from your anonymous inner class.

This 6-video course is the first in a 3-course series that explores the concepts of version control systems in general and the popular control system Git, an open-source version-distributed system which tracks changes in source code during software development. The course covers the web-based platform GitHub, which simplifies team collaboration when sharing source code. Participants will examine the features of control systems and learn to use Git repositories to track the desired project source code. Since Git is designed to coordinate work among programmers, this course explores branching and merging the code developed by a team. You will learn how teams can develop code collaboratively when building features for an app, by using branches in Git. This course demonstrates the feature branches used to merge code into the main master branch of a Git repository. Learn to identify merge conflicts. Finally, you will explore GitHub which supports all popular programming languages by demonstrating the features GitHub uses to manage Git repositories, and how GitHub assists in streamlining the iteration process.

This 14-video lab course is the second in a 3-course series on learning how to use Git and GitHub. In this hands-on course on Git, participants will solidify their use of many fundamentals in Git's version control tool. This course demonstrates how the Git ecosystem simplifies setting up source code repositories, and how GitHub makes it easy to use GitHub to collaborate with other developers who use Git. Learn to use the command line to create and manipulate local repositories, while expanding your knowledge of the fundamentals of this version control tool. As you progess, create and initialize your own local Git repository on your workstation and add new files to your project; modify existing sources; and delete content from your local Git repositories. The course will show you how to set up a secure shell (SSH) key to push your code to a remote GitHub repository. Finally, participants will learn to use GitHub's online tools to assist in keeping track of their branches.

GitHub is more than just a repository, as this 16-video course demonstrates. The last of a 3-course series, this course examines the project management features available on GitHub. Participants will continue to use GitHub's suite of tools to manage their source codes in the project you began in the previous course. Such features will help you to keep track of your application source code. When developing code, it is common to work in a team environment, and often there are multiple collaborators on a single code branch; GitHub's many tools and features will assist in managing these multiple branches. First, learn how to add a collaborator to your GitHub project. You will then learn to work with collaborators' pull requests and how to merge branches on GitHub. When branches are merged, conflicts can arise; here you will examine and learn how to manage such conflicts. Finally, GitHub's many tools and features also provide several approaches to gather statistics; Tags to manage releases, as well as issues; milestones; and project boards to track progress.

Final Exam: Senior Developer will test your knowledge and application of the topics presented throughout the Senior Developer track of the Skillsoft Aspire Apprentice Developer to Journeyman Developer Journey.

In this course, you'll be introduced to Java collections and explore the details of how the Lists part of the Collections framework works. You'll start by learning how arrays are a rudimentary form of containers with some similarities to ArrayLists. Next, you'll explore the limitations of arrays, namely their fixed length and limited API support. You'll then move on to ArrayLists and explore how ArrayLists mitigate the weaknesses of arrays while still retaining their advantages. You'll learn how to instantiate an ArrayList and iterate over it using while loops, ordinary for-loops, and enhanced for-loops. Finally, you'll examine how to access and modify specific elements in an ArrayList.

In this course, you'll focus on ArrayLists, which are a specific instantiation of the List interface. You'll learn about the List, Collection, and Iterable interfaces, and how the different list implementations such as ArrayList, Vector, and LinkedList, implement these interfaces. You'll then explore different iteration operations over lists and the ListIterator object. You'll see how to avoid ConcurrentModification exceptions, which can occur if code attempts to simultaneously iterate over a list and modify that list's contents. Next, you'll learn how to perform range-view operations on lists. Finally, you'll examine the shallow-copy nature of range-views, and how, when you modify an element in a range-view, the elements in the underlying list are being modified as well.

In this course, you'll explore the different types of lists available in the Java Collections framework and important algorithmic operations on lists. You'll examine the LinkedList, Vector, and ArrayList classes, and how they all implement the List, Collection, and Iterable Interfaces. You'll see how Vectors are similar to ArrayLists, but are thread-safe and so best-suited for concurrent access and multi-threaded applications. Next, you'll learn how LinkedLists are faster than ArrayLists for list addition and deletion operations, but slower for random access. You'll then explore how to create custom Comparator objects and implement the Comparable interface. Finally, you'll learn how to use different list algorithms, such as sorting, shuffling, copying, and you'll examine the semantics of list equality.

In this course, you'll explore the Set interface and the different Set collections available in Java. You'll learn how the Java Set interface extends Collection, and how it is used to define unordered collections in which duplicates are not allowed. You'll discover common set operations such as union, difference, intersection, and equality, as well as how these are influenced heavily by the implementation of .equals and .hashCode in the objects contained within the set. You'll cover four implementations of the Set interface - HashSet, LinkedHashSet, EnumSet, and TreeSet. Finally, you'll learn the correct implementations of the .hashCode, .equals, and .compareTo methods of user-defined objects that are to be stored in Sets.

In this course, you'll explore the Map interface and the different Map implementations available in Java. You'll learn how the Map is not a collection at all, but how it can be used to associate keys and values, and obtain collection objects that represent those keys and values. You'll see how no duplicates are allowed in keys, which effectively constitute a Set. You'll explore three implementations of the Map interface - HashMap, LinkedHashMap, and TreeMap. Next, you'll learn the finer points of how these map implementations check for duplicates. Finally, you'll examine the correct implementations of the .equals, .hashCode, and .compareTo methods in objects that are to be stored in maps.

In this course, you'll learn about how the Stream APIs provide ways to work with collections as streams of objects. You'll examine how operations such as filter, map, and foreach can be applied to collections by treating them as streams of data elements. Next, you'll learn how to use both anonymous inner class objects and lambda functions with streams, how to define predicates, and how to chain multiple stream operators together into a single pipeline that ends with a terminal operator returning a result. Next, you'll discover the differences between terminal and non-terminal operations, as well as between two different types of terminal operations - reduce and collect operations. Finally, you'll see how collect operations can be used to perform extremely complex operations on collections with minimal code.

In this course, you'll learn how annotations are defined and used in Java. You'll explore three popular built-in annotations, the @Override, @Deprecated, and @SuppressWarnings built-in annotations. Next, you'll examine how the @Override annotation is a valuable aid in detecting and fixing typos in the names of overridden methods, and crucially, helps to detect such issues at compile-time rather than at run-time. Then you'll explore the @Deprecated annotation and see how if you mark a class, method, or variable with the @Deprecated annotation, Java will issue an appropriate warning when you reference that element. You'll also learn about the @SuppressWarnings annotation, which does exactly what its name suggests, and for that reason ought to be used only with extreme caution, if at all. The @SuppressWarnings annotation allows the selective suppression of different types of warnings. You can also entirely eliminate all compiler warnings using @SuppressWarnings annotation with the all input argument, but this is quite dangerous and is an especially egregious programming practice.

In this course, you'll learn about two advanced built-in annotations, @SafeVarargs and @FunctionalInterface, before moving on to defining and using your own custom annotations. You'll begin with @SafeVarargs and see that it is purely indicative and does not imply any added compiler checks, so it is important to not be lulled into a false sense of security about methods that have been decorated with this annotation. Next, you'll move to another built-in annotation, @FunctionalInterface. This is used to decorate interfaces that contain exactly one abstract method. Finally, you'll learn how to define and use custom annotations. This will involve a detailed study of target and retention policies. The retention policy determines whether the annotation will be preserved only in source code, into compiled bytecode, or all the way to runtime. Finally, you'll see how the target policy governs what code elements - fields, methods, constructors, type parameters, and classes - can be decorated with an annotation.

In this course, you'll learn how type parameters can be used to combine type safety and code re-use. You'll see how type parameters can be specified for either for classes or for individual methods of classes. You'll learn that while instantiating objects of those classes, or while invoking those methods, you can pencil in type arguments in place of those type parameters. You'll cover defining type parameters, using classes and methods with type parameters, as well as conventions and rules that apply to such parameters. You'll then explore the raw type that lies beneath any class or method with a type parameter. Java creates just one single copy of such code, and pencils in a type parameter of java.lang.Object. Java also adds various type checks to ensure that the code is used correctly - this is known as type erasure, and forms the basis of the great performance of Java generics. Finally, you'll move on to the use of constraints on type parameters and see how these are achieved using Bounded Type Parameters. Using bounds, it is possible to exercise fine-grained control over the ensure that the type argument - for instance to specify that it must be a numeric type.

In this course, you'll explore how wildcards and type capture work, as well as how type erasure manifests itself in compiled bytecode. You'll start by examining how the wildcard operator, represented in syntax by the ? character, can be used in situations where you don't know up-front what type argument to specify for a particular type parameter. Next, you'll learn the three types of wildcard type parameters. Unbounded wildcards, where you know nothing at all about the type; upper bounded wildcards, which define type parameters that must inherit from a specific base class or interface; and finally lower bounded wildcards, which can be used to specify constraints in the other direction - namely that the type must be a super-class of a specified type. Next, you'll see that capture errors occur when Java is unable to infer the correct type to pencil in as the type argument for a given type parameter. Finally, you'll examine bytecode to see that whenever you create a class or method with a type parameter, Java creates just one single copy of such code, and pencils in a type parameter of java.lang.Object. It also adds various type checks to ensure that the code is used correctly. This is known as type erasure and forms the basis of the great performance of Java generics.

Refine your programming skills by exploring the most commonly-used data structures and algorithms in Java. In this course, you'll learn about the importance of data structures and algorithms in writing efficient and correct code. You'll explore the differences between abstract data types and data structures. You'll then learn how you can use complexity to measure the performance of your code based on running time, space, network usage, and other resources. Next, you'll examine the big-O notation to measure complexity. Finally, you'll learn how to analyze different methods to determine their running time, expressed using the big-O notation.

In Java, a linked list is a sequence of nodes, each node is linked to the previous and next node in the sequence. In this course, you'll learn how to implement the singly linked list and write code to perform a range of operations on the linked list. First, you'll gain a conceptual understanding of how a node in a singly linked list allows you to connect to all other nodes using the Next reference. Then you'll move on to examine how to perform common operations on this linked list, such as inserting a new node, searching for a node, counting nodes, and deleting nodes. For each of these operations, you'll learn to assess the time complexity of the code that you've written.

Discover how to implement the linked list in Java, including the doubly linked list and the circular linked list, and learn how to perform operations on these linked lists. In this course, you'll explore variations on the singly linked list that you covered earlier. You'll see how the doubly linked list holds an additional reference to the previous node in the linked list along with a reference to the next node. This means additional space is required to store each node, but it also makes certain operations faster, such as traversing backwards over the elements in the linked list. You'll also learn about the circular linked list, where the tail of the linked list points back to the head of the linked list.

The stack in Java allows us to access data in a last in, first out manner and in the best case scenario, both of these operations are performed in constant time. In this course, you'll get started by examining the behavior and characteristics of the stack data structure. The stack is often referred to as LIFO - or last in, first out - since the last element that you push on to a stack is the first element that you access. You'll learn how you can implement the stack data structure using arrays and linked lists and how to assess the trade-offs between these two implementations. Lastly, you'll see how to write code to perform common operations on a stack such as push(), pop(), and peek() and how to assess the running time for each of these operations.

In this course, you'll explore a popular data structure, the queue. Queues offer first in, first out access. All additions to the queue are done at one end, which is the rear of the queue, and removals from the queue are done from the front of the queue. You'll learn how to implement a queue using arrays and linked lists and you'll also examine a related data structure, the deque - basically the queue with additional operations. Next, you'll learn about implementations of the stack and queue, which are part of the standard Java library. Finally, you'll see how you can work with the priority queue, which allows you to access elements in the order of priority.

Final Exam: Lead Developer will test your knowledge and application of the topics presented throughout the Lead Developer track of the Skillsoft Aspire Apprentice Developer to Journeyman Developer Journey.

In this purely theoretical course, you'll be introduced to the concepts around building applications for the Android OS. You'll learn about the different pieces that come together to form an Android app, from IDEs to source and static resource files.

The best way to learn Android application development is to get hands-on practice. In this course, you'll learn how to create a simple app and go through all the steps involved to create the project. You'll then examine how to define the appearance and logic of the app, as well as how to deploy and test it on a virtual device emulator.

A good design for the screens in your Android app is crucial for good user experience. In this course, you'll learn about the pieces that go into defining the layouts for your app, how they can be structured, and how common components can be re-used.

In this course, you'll focus on defining the business logic of an Android application using the Kotlin language. You'll learn how to implement inheritance, convey messages between activities, and use imported libraries to retrieve and parse JSON data.

In this course, you'll learn how to introduce authentication and a database into your Android application. You'll discover how to integrate an app with Google's Firebase platform, with focus on its authentication service and real-time database.

In this course, you'll be introduced to testing for an Android app. You'll learn about basic unit testing and functional tests that need to be performed on a virtual device. You'll also examine the role of the Espresso Framework in simplifying the coding of UI tests by recording your actions on an emulator.

Final Exam: Journeyman Developer will test your knowledge and application of the topics presented throughout the Journeyman Developer track of the Skillsoft Aspire Apprentice Developer to Journeyman Developer Journey.