Java Fundamentals: The Core Platform

Course Overview
Hi everyone, my name is Jim Wilson. Welcome to my course, Java Fundamentals: The Core Platform. I'm president of JW Hedgehog Inc. , and I've had the good fortune to have been a professional software developer now for over 30 years. Did you know that Java is the most in-demand programming skill amongst software developers? In addition, a recent survey also listed Java as one of the five most important skills for big data specialists. Java is supported on everything from smart phones, to severs, to many of the special purpose devices that make up the internet of things. Although some Java environments may offer specialized features and capabilities, virtually all Java environments rely on the features and capabilities of the core Java platform known as the Java Runtime Environment or JRE. In this course, we're going to teach you everything you need to know to get started working in this core Java platform known as the Java Runtime Environment. So the major topics we cover include working with collections, streams, files, and the file system, configuring application execution in an environment, multithreading and concurrency, runtime type information and reflection. By the end of this course, you'll be ready to begin working in any of the many environments that rely on Java. To get the most out of this course, you should already be familiar with the basics of the Java programming language. I hope you'll join me as we learn the Java Runtime Environment with the course, Java Fundamentals: The Core Platform at Pluralsight.

Introduction
Welcome to the introductory module, the Pluralsight course, Java Fundamentals: The Core Platform. My name is Jim Wilson. In this module, we're going to take a look at a few key points. First of all, we're going to look at this idea of Java having dual identities, of it being both a language and an environment. We'll then take a look at the idea of Java having a core environment, and how that relates to other Java environments.

Input and Output with Streams and Files
Welcome to the next module, the Java Fundamentals course: The Core Platform. In this module, we look at Input and Output with Streams and Files. My name is Jim Wilson. In this module, we're first going to take a look at working with streams, then we're going to look at how we deal with stream errors and cleaning up streams, we're going to look at how we can make streams work together by chaining streams, we'll look at a number of specialized stream classes including the file and buffer streams, then we're going to look at the package java. nio. file, which gives us just a number of classes for working with files, performing file operations, and those sort of things, we'll take a look at the idea of working with file systems and different types of file systems, and then we'll finish up by taking a look at working with ZIP file system.

String Formatting and Regular Expressions
Welcome to the next module of the Pluralsight Java Fundamentals: The Core Platform course. This module covers String Formatting and Regular Expressions. My name is Jim Wilson. In this module, we'll start out by looking at the need to move beyond simple string concatenation to build strings, we'll then look at how we can easily combine sequences of values using the StringJoiner class, we'll then look at the power of creating strings using format specifiers, we'll look at how we can use format specifiers to write formatted content directly to streams, we'll then talk about using regular expressions for pattern matching, we'll look at the regular expression capabilities of the String class, and then we'll finish up by looking at those classes that are dedicated to regular expressions.

Working with Collections
Welcome to the next module of the Pluralsight course, Java Fundamentals: The Core Platform. In this module, we're going to talk about Working with Collections. My name is Jim Wilson. Now in this module we got a lot of great stuff to cover. We'll first take a look at the role of collections in our applications, we'll talk about the issue of collections and ensuring type safety, we'll look at some of the most commonly used collection methods, we'll take a look at how the issue of equality of the entries in a collection is handled, we'll take a look at some of the features that were added to collections as part of Java 8, we'll look at how we can convert between collections and arrays, we'll look at some of the most commonly used collection interfaces and classes, we'll then look at how certain collections deal with sorting behavior, and then finally we'll wrap up by talking about map collections, also known as dictionaries. Okay, so let's get started.

Controlling App Execution and Environment
Welcome to the next module of the Pluralsight course, Java Fundamentals: The Core Platform. In this module, we're going to talk about Controlling App Execution and the App Environment. My name is Jim Wilson. So as we go through this module, there's just a number of things we're going to look at that allow us to affect the execution of an application. First thing we'll look at is command-line arguments, how do we pass information into the application from the command-line, managing app and user properties, in other words tracking simple aspects of state for the application and user selections, how do we persist and restore those properties between application runs, then we'll look at deploying property defaults in a package. What we mean by that is actually setting up our application so as part of the package all of the initial default values for our properties are established and loaded directly from the package, but then easily updated and changed based on application behavior or user selections. We'll then look at default class loading behavior, in other words, what's the default behavior of a Java environment in terms of locating and loading classes that we use. Working with class paths, so we can use that to actually tell Java where we want it to find the classes we'd like to use. And then we'll finish up with how to access execution environment information.

Capturing Application Activity with the Java Log System
Well welcome to the next module of the Pluralsight course, Java Fundamentals: The Core Platform. In this module, we'll talk about Capturing Application Activity with the Java Log System. My name is Jim Wilson. As we go through this module, we're going to look at a number of topics. We'll start out by looking at log system management, we'll then look at making individual log calls, we'll look at indicating the relative importance of each log message using log levels, we'll look at the variety of log methods available to us, we'll then dig in a little deeper into the log system, and realize that the log system is not one component, but actually a series of components, so we'll talk about how to create and add those components, we'll then take a closer look at some of the build-in handlers and formatters that are available to us, we'll then move over from doing all of our set up in application code to using the log configuration files, and then we finish up specifically talking about logger naming and the hierarchy. But what that does for us is actually really shows us how to pull together everything else we've talked about throughout this module, and it shows us how to really make the most out of the log system.

Multithreading and Concurrency
Welcome to the next module of the Pluralsight course, Java Fundamentals: The Core Platform. In this module, we'll talk about working with Multithreading and Concurrency. My name is Jim Wilson. In this module, we'll start by looking at the issue of single threading versus multithreading, we'll then look at some of the foundational types that Java provides for working with threading, we'll look at working with thread pools, then we'll dig into some of the issues that come as we run code in concurrent environments, we'll see the facilities that Java provides for simplifying the idea of coordinating method access across threads, we'll look at how to manually manage thread synchronization for those scenarios where we need to do so, and then we'll wrap up our discussion by looking at some of the packages and some of the other types that Java provides for managing concurrency inside of our applications. When we talk about a topic like threading and concurrency, there's two kind of broad categories of viewers that watch a subject like this. There are those who are new to threading, so as they're learning the language like in this case Java, they're also learning about threading at the same time. There are also there are also those other developers who may be very experienced in dealing with threading in a different environment, and now want to understand how to do that same thing inside of Java. The structure of this module addresses both of those needs. If you're someone whose entirely new to threading, so you're learning threading as you're learning Java, you'll find that this module provides the building blocks that you'll need to begin building that understanding of threading and concurrency, so you can start using it in your applications as you go forward. If you're experienced with threading already, you'll find that this module provides the understanding that you need to take that threading knowledge that you already have, and apply that into your Java applications. So whether you're a beginner or you're experienced with threading, let's start looking at how threading works in Java, and we'll do that in our next clip.

Runtime Type Information and Reflection
Welcome to the next module of the Pluralsight course, Java Fundamentals: The Core Platform. In this module, we talk about working with Runtime Type Information and Reflection. My name is Jim Wilson. So throughout this module, we'll talk about the importance of type information and the role reflection plays in giving us access to and using that type information. We'll start out of a discussion of just in general what is reflection, and what is the role it plays, and why is it important as developers. We'll take a look at how Java actually represents information regarding types. We'll then see how we get access to the information on any given type reference, and the importance a class named class plays in that process. We'll then see how we can get more detailed information about a type, things like its base class, what interfaces it implements, is it a public class, is it a final class. We'll then see how we get information on the members of a type, what fields does a type have, what methods does it have, what are the parameters on those methods. We'll then see how we can actually interact with types using reflections, so that allows us to actually make method calls on a given object instance, even though we may not have a reference of the appropriate type to access that object. We'll then look at using reflection to create object instances, and as part of that, we'll talk about dynamic type loading. This allows us to have our programs create instances of types that we may not even have known about at the time we wrote our programs. Okay, so let's get started.

Adding Type Metadata with Annotations
Welcome to the next module, the Pluralsight course, Java Fundamentals, the Core Platform. In this module, we talk about adding type metadata with annotations. My name is Jim Wilson. In this module, the first thing we're going to take a look at is the idea of the need for having metadata inside of our types. We'll then see how we can use annotations to add metadata. We'll then see how we can declare custom annotations. And this is really important, because first it shows us how to actually declare our own annotations, but also helps in understanding how annotations work even where we're using the built-in annotations. We'll then see how we can get access to annotations, and the information contained within them from within our code. We'll talk about annotation target and retention, specifying what annotation, or what a particular annotation can be used with, and how accessible that annotation should be. We'll then look at the idea of simplifying the process of setting the values of elements within an annotation. We'll then look at the valid types for use with annotations. And then we'll finish up with this discussion of class-cross referencing. Other words, using metadata to create relationships between one class and another.

Persisting Objects with Serialization
Welcome to the next module of the Pluralsight course, Java Fundamentals: the Core Platform. In this module we talk about Persisting objects with Serialization. My name is Jim Wilson. Now throughout this module we're going to look at the aspects and issues involved in Java Serialization. We'll first take a look at the purpose and capabilities of Java Serialization. We'll then see what's involved in making a type support Serialization. We'll then see exactly how we serialize an object out to a Serialization stream and then restore that object information back from that Serialization stream. We'll then look at how we create class version compatibility. And what we mean by that is that how do we maintain compatibility with a type that may have been serialized when it had a type definition with one set of fields and then later is deserialized back into that type. That type has now added or removed fields. We'll then look at the process of customizing the Serialization process. We'll then look at the issue of transient fields. In other words the issue of having a type that supports Serialization, but that type has specific fields that we want to exclude from Serialization. Okay so let's get started.