Java Programming: Become a Professional Java Engineer!

In this lesson we will be covering why we selected to learn Java, while also covering the big ideas that are important to the creation of Java programs and how they differ from other languages. We will also discuss the history of the language.

In this lesson we will discuss the purpose of an IDE in general and why we selected to use Eclipse as opposed to other IDEs that are present on the market. We will also cover the hassles that not using an IDE will introduce to our learning.

In this lesson we will be covering how the compilation and interpretation of Java is preformed in your computer and how it differs system to system. We will also be covering why Java is considered an interpreted language, and the pros and cons of this type of language. Essential to those who want to have a full understanding of how their programs work.

In this lesson we will be covering how to build our first program in Eclipse. We will be covering how to go from start to finish with the creation of a class file, compilation, and running of the program. We will also be testing our understanding of concepts up till now, and introducing strings.

In this lesson we will be covering how to create variables in Java. We will compare and contrast Java variables with math variables. At the end you will have a basic understanding of variables and how to use them effectively in your programs. 

In this lesson we will be covering how to use the scanner class to take input from the user for values. By the end of the lesson we will know how to use different types of import statements and how to take numeric/textual input and how to assign those to the appropriate variables.

In this lesson we will be covering the various error types and how to classify them when talking to other programmers. By the end of the lesson we will know how to classify all types of errors into general groups, and have strategies to prevent and fix these errors in our code.

In this lesson we will be breaking down the System.out command and how to leverage it. We will explain the difference between the println and print methods. By the end of the lesson you will not only be able to output, but be able to have a general understanding of how it works in the backend.

In this lesson we will be learning about the various types of numeric variables in Java. We will be learning the various ways they are stored in a computer, and how decimal numbers differ from integer numbers. By the end of this lesson you will know how and when to use each of the 6 numeric variable types in Java. Essential for future lessons.

In this lesson we will be exploring the different operators that can be used with numbers in Java. We will be contrasting them with how they differ in math. After this lesson we will be able to understand the way that the major operators work in Java, while also understanding the difference between their usage in Java and math.

In this lesson we will be learning about the increment and decrement operators. By the end we will understand the usage of the increment and decrement while also understanding the importance of where they are placed and the limitations placed on the operator.

In this lesson we will be understanding the purpose of the final keyword. We will be learning about reserved words and why we might need to use a final variable. By the end you will understand how to name and use final variables.

In this lesson we will explore the order in which the operators we have learned about are evaluated. We will then be able to form a "Order of Operations" similar to mathematics that we can use to find out what order an expression will be evaluated in. We will also cover the naming conventions for the data types we have so far discussed.

In this lesson we will be learning about the random class which can be used to generate random values. We will learn about the various methods that are used to create each random value, and how we can call them and use them in our programs. By the end of the lesson we will be able to import the random class to create random values in our programs.

In this lesson we will be practicing our first case study in which we will practice everything we have covered until now by building a program that models a group of employees. This will be a good check to make sure we have understood every topic until now.

In this lesson we will be getting more practice with a real life example of modeling a rectangle. We will be practicing the random class to generate the width and height. We will then use operators to preform calculations with the rectangle.

In this lesson we will be exploring the decimal format class which is used to create formatting rules for numeric variables. By the end of the lesson we will be able to specify various rounding and levels of precision using the correct syntax.

In this lesson we will be learning about casting. We will learn when we have to explicitly cast vs implicit casting and the risks that are associated with casting without the proper checks. In addition we will explain why we even need to cast at all. By the end you will know how and when to cast from one data type to another.

In this lesson we will start to learn about the various types of variables; starting with the Boolean. We will learn why it is so simple, and why java even supports such a value. We also will discuss possible use cases that become frequent later on.

In this lesson we will explore the Char type and how we can use it to store single characters. We will discuss how they are different to strings and how they are stored differently. By the end of this lesson we will be able to understand what a char is and when to use one. We will also understand the difference between reference and primitive data types in Java.

In this lesson we will be exploring the details of strings. Even though we have used them extensively up till now, we will explore the ways in which they are stored and processed in Java. We will also have an introduction into how Strings are a somewhat odd version of objects. By the end of the lesson we will have a solid understanding of Strings.

In this lesson we will be exploring the methods that can be enacted on various strings. Since Strings are objects, they have methods that can be used on each instance and can be leveraged to process individual strings. We will also have an introduction into instance vs static methods.

In this lesson we will be practicing how to use the scanner class to take input for strings and characters. We will also be exploring the big problem with taking input for a numeric type after taking input for a string due to the way the Scanner class works. By the end of the lesson we will be able to take input for all primitive types and Strings without errors.

In this lesson we will be practicing all that we have learned with strings and chars by creating a program that can analyze a given user string. We will be using the instance methods on each string to provide back useful information to the user. This will be a good way to solidify your knowledge of the topics discussed up till now.

In this lesson we will be having a theoretical overview of the ensuing lessons about control statements. We will be talking about what the various control statements can do, and why we need them. In addition we will discover why the Boolean becomes invaluable now.

In this lesson we will be learning about the new operators that are required for us to properly use control statements. These statements will be considered Boolean operators and will result in Boolean values that we can use in our control statements.

In this lesson we will be learning about the most fundamental type of control statement: the if statement. These statements are essential to making programs that have branching logic and will be using Boolean logic statements to decide which path is executed. Essential for rest of course.

In this lesson we will be using the Else and Else if statements to expand our branching programs. They will be dependent on an already existing if statement. By the end of this lesson we will be able to use the major control statement types in Java in the appropriate manner, and understand the logic behind their operation.

In this case study we will be building a program that will determine the grade of a student based on their test score. This will require the use of if, else if, and else statements. We will see how the else if is not always required and how to make our programs as optimized as possible.

In this lesson we will be practicing control statements with a program that will provide the user an addition problem and tell them if they got the correct result. We will be able to use a control statement in addition to a normal program to build our most complicated program yet.

In this lesson we will be learning about nesting with control statements. We will learn the order in which the nesting is preformed and why we might need to have it. We will also be able to try replacing the else if statement in some cases. By the end of this lesson we will be able to use nested control statements confidently and correctly.

In this lesson we will be exploring the switch statement and when it should be used. We will be exploring it through a real life example and practicing the rather complicated syntax of the statement. We will also be learning some rules on when to use a switch statement vs the normal control statements..

In this lesson we will be exploring the math class and how to use it in our programs. We will also be receiving our first experience with static methods and how they should be used. Finally, we will discuss how to use the math class to cut down on the work that we have to do. By the end of this lesson we will know when and how to use the Math class methods.

This lesson will cover the major pitfalls that people run into when they start to use control statements. We will see why they tend to occur and how to prevent them from happening in the first place. We will also cover how to debug your programs efficiently and how to fix the errors once detected. After this lesson we will be able to use all control statements with minimal errors in the correct places.

In this lesson we will discuss how to cut down on the amount of code we need by using extended assignment operators. These are used to override the old value of a variable with a new value based on the old one. By the end of the lesson we will be able to use extended assignment operators freely.

In this lesson we will be building a program that will be able to see if a string matches the key. We will be using the string instance methods and be able to provide a variety of outputs depending on the situation. By the end of the lesson we will be proficient in using the string methods provided to us in Java.

In this lesson we will be closing up our discussion of control statements with a program that will be able to detect if a given year is a leap year. We will be using all of the operators we discussed in conjunction to the various controls statements. A very effective way to see if you understand all of the concepts discussed.

In this lesson we will get a theoretical overview of loops. We will discuss when we need a loop and how we can use them to fundamentally change the way our programs work. By the end of the lesson we will be ready to actually code these loops.

In this lesson we will explore the first and simplest type of pretest loop. We will learn about the syntax and how to combine what we learned from control statements with these loops. We will also expand on the difference between pretest loops and post-test loops.

In this lesson we will be exploring the first and only post test loop supported by default in Java. We will explain how they will differ from While loops despite the similar name, and how to leverage them so that you don't waste resources or hurt readability. We will also cover how to make a program repeat using Do-While loops.

In this lesson we will cover the final type of loop, the for loop. We will expand on why for loops are the most common type of loop. We will cover the new syntax that is required, and some of the problems with this syntax. We will also cover how to transform this loop into a while loop.

In this lesson we will cover the way that nesting loops is similar to nesting with control statements. We will cover the order in which the iterations will be covered, and how to structure your loops appropriately. We will also cover how they can quickly become too big to handle, and the exponential growth of system resource consumption.

In this lesson we will be demonstrating the appropriate type of loop to use based on the circumstance. We will be covering scenarios where each type of loop is appropriate, somewhat appropriate, and completely inappropriate. This will be essential to cut down on unnecessary code and improve readability while not compromising functionality.

Due to how system resource intensive loops are, in this lesson we will be exploring the scenarios in which a loop is not even needed for the functionality of the program. We will be discussing how to weight simplicity and readability, while also discussing scenarios where each type of loop should be avoided due to its constraints.

In this lesson we will be practicing everything we have learned about loops with a program that will find the number of even numbers that have occurred in a user's inputs. We will be practicing how to build a program using a sentinel that will not stop until the user wants us too, while combining our knowledge of loops with control statements.

In this case study we will be practicing loop by building a program that will determine if a number is prime. We will be building all aspects of this program, while also allowing the user to keep the program running while they want. We will also discuss the running time efficiency of the program. By the end of this program we will be able to use loops in combination with a complex real life problem.

In this case study we will be practicing rebuilding our old program of repeated addition to run using loops. We will provide some general guidelines on how to rebuild an old program and add loops and when loops add functionality to a program which relies on the user's inputs.

In this lesson we will be exploring how where we create our variables affects the scope of the variables. We will see how this impacts our program, and how they are relevant to system resource usage. We will also explain how scope affects the variables in the backend of Java.

In this lesson we will be exploring how the limitations of strings affect what characters we can use by default in strings. We will then learn how to get around this by using escape sequences. We will learn the syntax and how to make it look neatly formatted into our strings.

In this lesson we will learn about sentinel controlled input and how it differs from the previous types of programs we discussed. We also will learn about when to use a sentinel and how it adds functionality to our programs.

In this lesson we will be discussing the theoretical reasons behind methods existing. We will go over the methods that we have already used, and what each method should do compared to a normal program. We will also touch on how methods work in the back-end of Java.

In this lesson we will be learning about the basics of how to create our own methods. We will be discussing the strict rules on the syntax of a method and how each one has limitations that help the readability of our programs. We also will break down what most of the main method's syntax means.

In this lesson we will practice what we learned about how to make a method with a method that can calculate the GCD of two numbers that it is provided. We will learn about why we should use a method to calculate the GCD of these numbers. We will also get to practice providing arguments to our own methods.

In this lesson we will go over how to call methods. We will see how the types of variables you can pass to a method are limited, and what information you need to use a method successfully. By the end of this lesson we will have a basic understanding of how to use methods.

In this lesson we will be going over how to overload a method. Overloading is one of the most powerful tools we have, and can add functionality without us needing to change many of our original methods. However, we will also go over the hit in readability that overloading causes. By the end of this lesson we will know what overloading is and when to use it.

In this case study we will be practicing overloading with normal method creation and usage. We will be creating a program that will use multiple methods to model a fraction, and always return the simplest form back to the user. This program is a very applicable way of making sure you understand methods.

In this lesson we will learn how to take input from not just the console, but also from text files. We will learn how to do so using both the command line and Eclipse. We will also learn how to output back to another file at the same time. We will also cover the disadvantages and use cases for input and output redirection.

In this lesson we will be covering how to convert one of our old programs into a properly built program with methods. We will be rebuilding our addition program and making use of method calls to create a more versatile program. We will also be practicing the use of overloaded methods to provide the most appropriate answer.

In this lesson we will be practicing error checking as it will require many different methods to be effective. We will discuss why we couldn't tackle error checking until now, and how there are multiple ways to build your error checking into a program. By the end of this lesson we will be able to error check our program effectively.

In this lesson we will be covering some general guidelines that we should follow when making programs that have methods. We will cover the common pitfalls and how to get around them. We will also discuss why we don't always need multiple methods, and conventions to make your code readable and professional.

In this lesson we will be learning about how to properly structure our test data to make sure we can cover the entire program and all possibilities, without having to waste our time trying all possible inputs. We will cover how to break each type of test data into groups, and how to achieve all lines of the program are a

In this we will be covering how to build the theoretical base for classes. We will cover what classes and objects are, and when to use a class. We will also start to talk about the classes are a good way to represent a real life object. Finally, we will give real life comparisons for classes.

In this lesson we will be going over some of the classes we have already been using as an introduction into classes. We will cover why we used them and how they cover many of the general conventions that we will have to follow when we build our own classes.

In this lesson we will cover how to make our own classes. We will cover the big terminology that is required for discussing classes. We will cover how they differ from the class files we have been creating until now, and how to structure them in a readable format. By the end of the lesson we will be able to make our own accessory classes.

In this lesson we will be instantiating our classes by use the New operator. We will cover how to create them in a driver class and how to follow the appropriate naming conventions. We will also try to use the methods in the object that we created.

In this lesson we will be covering the differences between objects and methods. We will go over the scenarios in which we should always use objects vs methods, and how this affects the logic of our program. We will be also be covering how they are treated differently in the back-end.

In this lesson we will be covering what constructors are and how to make them. We will cover the general rules that govern constructors and the common mistakes that are made with constructors.

In this lesson we will be starting our case study of the student class. We will be creating the student class that will have common values and calculations that students have, and will be practicing all of the ideas we have discussed about making our own classes. 

In this class we will be creating the driver program that will be testing the Student class we made in the last lesson. We will be trying all of the methods and using the static and instance variables. We will also be able to see the disadvantage of having non-private variables.

In this case study we will be practicing what we learned about classes with building a program that will model a fruit. We will be creating multiple classes and seeing how this will affect us using them all inside of a single class. We will also see how the objects affect the logic of our program.

In this lesson we will be updating our knowledge of scope with regards to classes and methods. We will discuss how this impacts the scope, and how it will decide where we instantiate vs declare the variables we make.

In this lesson we will go over the theoretical overview of what an array is. We will discuss how they will work in the back-end and some common situations in which we will need to use one. We will also cover why an array is a data structure that is required for the operation of many programs.

In this lesson we will cover when an array will be necessary before we get too in-depth with arrays. We will cover what situations can use multiple variables vs an array. We will also cover the situations where an array becomes inferior to other collections data types like ArrayLists.

In this lesson we will cover the basics of when we need to use an array. We will also learn about the syntax of the multiple ways that an array is created. We will cover how Java processes arrays, and how they differ from normal primitive data types. By the end of the lesson you will have a very solid understanding of arrays.

In this lesson we will cover the major errors that occur when dealing with arrays. Due to their complicated structure there are a variety of very common mistakes that occur when we are creating arrays. We will also learn about the error messages that will result and how to process these. Finally, we will cover how to eliminate these errors from occurring.

In this lesson we will go over the ways that we can create an array with various sets of data. We will summarize how they can be created with random values and user inputs.

In this lesson we will summarize how to output an array. We will be using a for loop and will learn how to use the counter variable to run through a complete array. By the end of this lesson we will be able to both create and process an array with user values.

In this lesson we will be learning how to copy an entire array. Since arrays are objects we will be covering why a simple surface copy cannot be done, unlike with primitive data types. We will then show how to manipulate the two arrays with a for loop to completely create 2 independent copies.

In this lesson we will be learning about a variation on the for loop that allows us to traverse an entire array much more simply. We will talk about the unique syntax and the scenarios in which in can be used. After that we will cover why they aren't used too often and the disadvantage of using them regularly.

In this lesson we will learn how to use what we learned from for each loops and apply it to a different type of method. We will go over the syntax and rules of var-args methods and cover when they are appropriate. We will then cover the problems that are present with them and why they hurt readability significantly, even though they increase functionality.

In this lesson we will cover how to build programs that have arrays as parameters, results, or both. We will cover how them being considered objects starts to impact the way we deal with an array, and why the previous discussion of pass-by-value no longer applies once we are dealing with arrays.

In this lesson we will learn about parallel arrays. We will cover how unlike the other types of variables we have discussed parallel arrays are a programmer designation. We will cover how to recognize them, and how to leverage them into our programs. We will also cover how they differ from other types of arrays.

In this lesson we will cover how 2 dimensional arrays are created and used. We will explain the new syntax and how they work from Java's perspective and how this differs from other languages. We will cover how to process the data inside of a 2 dimensional array using nested loops and populate the array with random values.

In this lesson we will cover how to use conditional statements as a way to shorten up our programs in some circumstances. We will cover the syntax of the statement, and how to make a conditional statement in our own programs. We will also cover why we don't see them too often in code.

In this lesson we will break down the main method into what each part of it means. We will also cover how due to the parameters we can use a string array for input. We will then cover how to provide this input in both the command line and in eclipse.

In this lesson we will be covering why we need to use ragged arrays. We will specify the situation in which we can have a ragged array and why they can exist in Java. We will then cover how to create them and why we used certain techniques when we started working with arrays that help us now. By the end of the lesson we will be able to process ragged arrays in a simple manner.

In this lesson we will learn how to create an array with more then 2 dimensions. We will discuss why they are not used very often and how they can help make our programs more complicated. We will cover some general rules and the syntax of creating and processing them. By the end of this lesson we will be able to create and process almost any type of array.

In this lesson we will be covering how to eliminate some of the work with processing arrays by importing and using the Arrays class. We will be covering how to use the methods to speed up the processing of our arrays and add functionality to our programs. By the end of this lesson we will be proficient in using the Arrays class with arrays.

In this lesson we will be covering the Array List data type. We will learn how it being a generic impacts the functionality and its big advantage over Arrays. We will also be discussing why it is more system resource intensive the normal arrays.

In this lesson we will be practicing using parallel arrays with a case study of creating a class to model cards. We will be creating multiple methods that will be working with an array, and demonstrating the good practices we have discussed in the previous lessons.

In this lesson we will be building a program that will be randomizing an array. We will be having multiple shuffles to try and increase the chance of every value being in a different location. We will also be practicing using loops to manipulate the array we are provided.

In this lesson we will be starting to work with our biggest case study yet. We will be building our own implementation of binary search, which requires us to first sort the array. The sorting will be done using insertion sort, and we will be explaining how to sort the array in the fastest way. We will also be discussing the increase in running time based on the number of values in the array.

In this lesson since we have created a class to sort the array, we can now implement binary search. We will be demonstrating how to use binary search without having too many repetitive variables, and will be discussing the running time of the programs. When we finish this lesson we will be able to search through our array using the binary search algorithm.

In this lesson we will be learning what Object Oriented Programing(OOP) is. We will be comparing OOP to functional programming, and explaining the point of this set of principles. We will also cover the big vocabulary for OOP.

In this lesson we will be covering the first big idea in OOP, encapsulation. We will be explaining how we have been silently practicing encapsulation already when we built our objects. We will also explaining information hiding which is also closely related to how we have already been building our programs. By the end of this program we will know how to build programs that follow 1 of the 3 big OOP principles.

In this lesson we will be covering the second big idea in OOP, inheritance. We will learn about how inheritance can help us drastically cut down on the amount of code we have. It can also help us define how two items are related by having one inherit the other. We will also explain the limitations of inheritance and how to code inheritance into our programs.

In this lesson we will be covering how to override one of the methods that is included with every object. We will see how a superclass defining a method can make our programs simpler. We will also be seeing how an object method being overridden is the preferred way to define some methods. Finally we will actually implement the toString method in one of our classes.

In this lesson we will go over the InstanceOf operator. Similar to the mathematical operators, the instanceOf requires two values to be operated on. However, we will learn how the instanceOf can be used to check if one class inherits another one. By the end of this lesson we will be able to successfully use the instanceOf operator.

In this lesson we will learn about the way the JVM will dynamically decide which method to run when a subclass. We will see how Java will work based on either the actual or declared type to decide the version of the overridden method to run. By the end of this lesson we will be able to know which method an object will call even if the method is overridden.

In this lesson we will be covering the final major idea in OOP, polymorphism. We will learn what polymorphism is and how despite the complex name, the actual implementation is fairly simple. We will see how it can add great power to our programs and make them more efficient. By the end of the lesson we will be able to practice all major OOP principles in our programs.

In this lesson we will be learning how to understand the relationship between different types of objects in real life. We will then apply this logic to our programs in Java in a variety of ways, either multiple objects, inheritance, or no relationship at all.

In this lesson we will be exploring how to convert a normal primitive data type into the class version of data type. We will go over the advantages of conversion and how in some cases Java can by default convert to the class form and vice versa. By the end of this lesson, we will be able to easily convert a primitive data type into its wrapper version and utilize the advantages that this provides us.

In this lesson we will be going over what it means to declare a class final and how this will affect our code. We will also discuss when we might want to do this.

In this lesson we will be using what we've learned about wrapper classes to modify our calculator program to take input from the command line. We will be going over general rules to convert a program into a command line program, and how to use the wrapper classes to convert from a string to a primitive data type easily.

In this lesson we will be learning what an abstract class is. We will discuss the situations in which we will need to use an abstract class, and the syntax of creating one. We will also be learning the limitations that are present in all abstract classes. By the end of this lesson we will be able to create abstract classes mixed with normal classes.

In this lesson we will be exploring how to add abstract methods into abstract classes. We will see how every abstract method needs to be in an abstract class but not every abstract class has abstract methods. We will also see the limitations on abstract methods. By the end of this lesson we will be able to make abstract classes with abstract methods.

In this lesson we will go over where to use abstract methods, abstract classes, or neither with normal inheritance. By the end of this lesson we will be able to make abstract classes and methods in the correct locations.

In this lesson we will be learning about one of the major structures in Java the interface. We will see how interfaces have a variety of limitations on them, and how we can use them to provide structure to our programs. We will also be able to see how to make them in Eclipse, and leverage all of their features.

In this lesson we will be learning how to implement a default interface into our programs. We will see how the interface indicates traits to the JVM and how we can then implement methods from the Object class. We will also see the major disadvantage with Cloneable and why it is not frequently used.

In this lesson we will go over how to implement the Comparable interface. We will see how it does not have the problems that Cloneable had, and how we must override one of the abstract methods defined inside of the interface. We will also see how the interface can be used inside of certain operators. By the end of the lesson we will have a complete understanding of how to manipulate the comparable interface in our programs.

In this lesson we will exploring when to use the various forms of relationships that we have learned so far. We will have a variety of scenarios in which we can see which type of Java relationship should be implemented. We will also be able to see how fluid most of the definitions of these relationships are. By the end of the lesson, we will be able to create the proper relationship in the correct situation for our programs.

In this lesson we will start our case study of using inheritance, interfaces, abstract classes, and normal instantiation in our programs. We will be creating a program to model the real world on a small scale and will be practicing all of the concepts discussed so far.

In this lesson we will be implementing the driver class of the little world program. This will allow us to demonstrate all of the ideas we have gone over so far. By the end of this lesson we will be able to create complex programs with interfaces, inheritance, multiple classes, and abstract methods/classes.

In this lesson we will be going over the BigInteger and BigDecimal classes and how we can use them in our programs. We will touch on the limitations of the normal primitive data types. We will then demonstrate the functionality of both class, but will also discuss the problems with both classes. By the end of the lesson we will be able to build complex programs with big numbers using the BigInteger and BigDecimal classes.

In this lesson we will be going over the Date class and how it can be used to store dates. We will explain all of the instance and static methods, and how we can incorporate these into our own programs. We will also explain how to use them to create various different objects and compare their dates.

In this lesson we will go over the PrintWriter and associated File class. We will see how to build a new file and add text to that file all inside of a Java program. We will be expressing each file with a path, then creating PrintWriter objects and calling their methods to write to the file. By the end of this lesson we will know how to write to a file without having to resort to output redirection.

In this lesson we will go over the URL class and how to use it to get information from websites. We will discuss how to read through the site and get information from it, and also how to get system level information from the website. By the end of the lesson we will be able to manipulate websites inside of our programs.

In this lesson we will go over the basics of how to create a program that must deal with exceptions. We will go over the problem with not handling exceptions and what this causes. We will then go over how to handle an exception using a try catch block. We will go over the syntax and the types of exceptions in Java. By the end of the lesson we will have a basic understanding of how to manipulate the exceptions.

In this lesson we will be finishing our discussion on exceptions. We will discuss how to create our own exceptions and how to have a method throw an exception to its calling method. We will then discuss how this works in the backend and how this affects our code. By the end of this lesson, we will be able to process all exceptions thrown by our programs and how to make our own exceptions.