Java Fundamentals: The Java Language

Course Overview
Hi everyone. My name is Jim Wilson. Welcome to my course, Java Fundamentals: The Java Language. I'm president of JW Hedgehog, Inc., and I've had the good fortune to have been a professional software developer now for more than 30 years. Did you know that Java is the most sought after programming language skill among software developers? Java is supported on everything from smartphones to servers to many of the special purpose devices that make up the Internet of Things. In addition to being important to software developers, a recent survey listed Java as one of the five most important skills for data scientists, those folks who work their way through all of that big data. In this course, we're going to teach you everything you need to know to get started working in the Java programming language. So the major topics we cover include setting up your Java development environment, language constructs and control flow; classes, class inheritance, and interfaces; exceptions and error handling; creating and using Java packages. By the end of this course, you'll be ready to begin working in any of the many environments that rely on the Java programming language. This is a beginner course and therefore makes no assumptions on prior programming experience. I hope you'll join me as we learn Java programming with the course, Java Fundamentals: The Java Language, at Pluralsight.

Introduction and Setting up Your Environment
Welcome to the Pluralsight course Java Fundamentals: The Java Language. This is our first module, Introduction and Setting Up Your Environment. My name is Jim Wilson.

Creating a Simple App
Welcome to this module on creating a simple app. My name is Jim Wilson. In this module, first we're going to look at creating your very first IntelliJ project. In other words, how do we create a simple application using IntelliJ? We'll then look at running our Java programs from the command line. We'll take a look at the syntax of Java statements and comments. We'll introduce the concept of Java packages. And then we'll walk through creating and running a project using the NetBeans IDE.

Variables, Data Types, and Math Operators
Welcome to this module on variables, data types, and math operators. My name is Jim Wilson. In this module, we'll first look at how to name and use variables. We'll then look at the primitive data types in Java and their behavior. We'll go through the arithmetic operators and the order of precedence. And then finally, type conversions, both implicit and explicit type conversions.

Conditional Logic, Looping, and Arrays
Welcome to the next module in our Java Fundamentals course on the Java language. In this module, we're going to take a look at conditional logic, looping, and arrays. My name is Jim Wilson. We've got a jam-packed module here. We're going to talk about a lot of great stuff. We're going to start out looking at the various aspects of conditional logic in Java. Then we're going to look at the basic looping capabilities. We'll take a look at arrays, something called the for-each loop, and then we'll finish up with the switch statement.

Representing Complex Types with Classes
Welcome to the next module of our Java Fundamentals course on the Java language. In this module, we look at how we represent complex types using classes. My name is Jim Wilson. In this module, we start digging into the object-oriented aspects of Java. So we'll first look at classes, how we create them and how we use them. We'll then look at the concept of classes being reference types and how that makes them behave differently than primitive types. We'll look at the idea of encapsulation, in other words, how do we keep the details of our classes inside of our classes and not the concern of those using the classes. We'll look at the basic behavior and creation of methods in Java. And then we'll look at how do we control interaction with the data in our classes using field accessors and mutators.

Class Initializers and Constructors
Welcome to the next module in our Java Fundamentals course on the Java language. In this module, we're going to look at class initializers and constructors. My name is Jim Wilson. In this module, we're going to first look at the idea of establishing the initial state of our objects. We'll look at how we can set the value of class fields as part of the class declarations. We touched on constructors in the last module. I want to look a lot more at how we work with constructors and the idea of having multiple constructors. We'll then look at how we can chain multiple constructors together and even use constructor visibility to control how and where our class instances are created. We'll talk about a way to share code across constructors called initialization blocks. And with all these different ways to construct and initialize our objects, we'll talk about how the order of those things occur.

A Closer Look at Parameters
Welcome to the next module of our Java Fundamentals course on the Java language. In this module, we take a closer look at parameters. My name is Jim Wilson. In this module, we'll first look at the idea of parameter immutability, the idea that changes made to a parameter in a method are not reflected once we exit the method. But members of a class can be affected inside of a method. Then we'll look at the idea of constructor and method overloading, the idea of having a constructor or method with differing parameters. And then finally, the idea of supporting a variable number of parameters.

Class Inheritance
Welcome to the next module of the Pluralsight Java Fundamentals course on the Java language. In this module, we discuss class inheritance. My name is Jim Wilson. We have a lot of great content to talk about in this module. We're first going to take a look at the basics of class inheritance in Java; the idea of member hiding and member overriding; the object class, the base class of all classes in Java; object equality, what happens when you compare two objects to see if they're equal, and what does equal actually mean? We'll look at the super keyword, a useful tool for accessing base class behaviors in a derived class. We'll look at how to control class inheritance and member overriding behavior using final and abstract. And then finally, we'll look at how constructors work when inheriting one class from another.

More About Data Types
Welcome to the next module of the Pluralsight Java Fundamentals course on the Java language. In this module, we talk more about data types. My name is Jim Wilson. As we go through this module, we'll first look at the String class and how to work with string values. We'll then look at how we can work with strings and manipulate strings more efficiently using the StringBuilder class. We'll see how we can bring the capability of classes to primitive values using the primitive wrapper classes. We'll see how to create fields that can't be changed once set using final fields. Then we'll finish up with enumeration types, which allow us to define types that can only hold a finite list of values.

Exceptions and Error Handling
Welcome to the next module of the Pluralsight Java Fundamentals course on the Java language. In this module, we cover exceptions and error handling. My name is Jim Wilson. In this module, we cover a number of things related to exceptions. We'll first take a look at the role of exceptions. Then we'll talk about the try/catch/finally statement that allows us to handle exceptions. We'll talk about our responsibilities when we have exceptions that cross method boundaries, look at how to throw exceptions, and finally, how to create our own custom exception types.

Working with Packages
Welcome to the next module in the Pluralsight Java Fundamentals course in the Java language. In this module, we're going to cover working with packages. My name is Jim Wilson. So as we go through this module, the first thing we'll look at is what exactly is a package in Java, and we'll look at a lot of the capabilities of packages and the benefits they provide, such as packages acting as a name space. What does it mean to import a package? How do we use packages to limit access to content so we can have types and capabilities that are visible inside of a package but not outside of a package? And then this idea of distributing packages and working with Java Archive files or otherwise known as JAR files.

Creating Abstract Relationships with Interfaces
Welcome to the next module of the Pluralsight Java Fundamentals course in the Java language. In this module, we're going to take a look at creating abstract relationships with interfaces. My name is Jim Wilson. Throughout this module, we'll look at a number of issues related to interfaces. We'll start by just defining what an interface is. We'll then look at implementing an interface, and we'll do that by taking a look at some of the interfaces that are provided by Java. We'll then look at how we can have a single class that implements multiple interfaces. We'll then take a look at declaring our own interface, and we'll do that by adding some features to our CalcEngine app that we've been working on throughout the course.

Static Members, Nested Types, and Anonymous Classes
Welcome to the final module of the Pluralsight Java Fundamentals course on the Java language. In this module, we're going to look at static members, nested types, and anonymous classes. My name is Jim Wilson. So as we go through this module, we're going to touch on a number of things. First of all, the idea of static members having static methods and fields, and then we'll look at something called static initialization blocks, the ability to do one-time type initialization. Then we'll look at nested types and then a very particular type of nested type called inner classes where we actually can have the nested class's instance automatically associated with an instance of its enclosing class. And then finally, we'll talk about anonymous classes, the ability to declare and create a class all at one time.