Java Programming: The Authoritative Edition
4.7 (38 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
2,748 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Java Programming: The Authoritative Edition to your Wishlist.

Add to Wishlist

Java Programming: The Authoritative Edition

Learn Java from start to finish using an exciting project driven approach
New
4.7 (38 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
2,748 students enrolled
Last updated 8/2017
English
Current price: $12 Original price: $20 Discount: 40% off
4 days left at this price!
30-Day Money-Back Guarantee
Includes:
  • 34 hours on-demand video
  • 4 Articles
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion

Training 5 or more people?

Get your team access to Udemy's top 2,000 courses anytime, anywhere.

Try Udemy for Business
What Will I Learn?
  • Build responsive graphically pleasing programs using simple principles
  • Build programs that reflect the modern principles in Java and program development
  • Create responsive applications that solve real life complex problems
  • Tackle large scale projects in a professional style
  • Become a respected Java engineer using industry standard practices
  • Have a excellent base to go into more specialized topics in Java
View Curriculum
Requirements
  • Have a computer able to install Java
  • An ability to do basic computing tasks (copying, pasting, running programs)
  • A passion to learn!
Description

ON SALE FOR JUST 24 MORE HOURS!

ONE OF THE HIGHEST RATED AND MOST POPULAR COURSES ACROSS UDEMY WITH 35 HOURS OF CONTENT

SEE WHAT OTHERS ARE SAYING:

"Very informational, calm and educational. Direct use of the learned subject allows for easy implementation into the real world application" 5 Stars -Alex Weber

"The instructor is very articulate in explaining difficult concepts...Would recommend to those interested in learning Java in an easy user-friendly manner!" - 5 Stars Bala

"Practical...yet covering advanced concepts...benefits those looking for quick insights and clarifications" 5 Stars Sundar

Would you like to simply drill boring basic concepts with no real life application? If so, this course isn't for you. Or would you rather learn a variety of powerful concepts using modern development techniques while learning each topic with a great deal of depth. If this is you, then together we can discover the power of the Java programming language together. Other courses try to cover a million different topics with little to no depth, or try and spend the entire course on a topic that needs just 20 minutes. In this course we will be covering the most important topics for a Java developer to know. These include, variables, arrays, OOP principles, exception handling, optimization, algorithms, loops, basics of generics, and GUI program design. We will also extensively cover how to design a program and how to make a readable and maintainable program, both essential to building code for either a company or school. Even if you don't have any prior experience with Java or even coding at all, we will be working from the beginning and building our way up. We will explain each topic with increasing complexity so that no matter your programming background, you can extract a benefit from each lesson. We will be using the most popular language in the world and an open source IDE(Integrated Development Environment) that is used by millions of people every day.


Why Java?
Java is the most popular programming language in the world and is used for the smallest embedded computers to room-sized super computers. It is used throughout the world to build Android applications, desktop program, and server side applications. The compile once, run anywhere motto means that we can create our programs on any type of computer and run it on any other computer with no difficulty. Finally, Java is part of the JVM class of languages such as Scala and JRuby.


Format of the Course:

This course can best be defined as a project-driven course. This will mean we will be building projects that will be solving real life problems. Some of the examples we will be doing include a leap-year calculator, a complete graphical version of the game blackjack complete with a computer controlled AI, a normal calculator for operations, a mode finder, and addition problem generator. All of these will be done in the code-along format so we can work together to see how to construct each part of the program. If you run into a problem, you will be able to simply look at the code to find the problem. A quiz will be placed at the end of each chapter along with a detailed description for each lesson. These will allow us to test our understanding of the lessons in addition to the case studies. Detailed lessons with explanations complete with live demonstrations will be there for every topic. Additionally, there will be a big emphasis on not just learning how to code, but also how the code works. We will always go into how your computer will process the code for even the seemingly smallest details. Also, we will emphasize how to build readable and maintainable programs that can be easily edited by possible co-workers. This will allow you to easily transition into a company or school where sharing code is expected. We will also have lessons that are sized in a format that is conducive to viewing on mobile devices.

Topics covered: We will be covering everything up to being a intermediate/experienced level programmer. This will include starting from the basics with variables, print statements, and taking input from the user. After this we will add more complexity with the more difficult control statements(if and else) where we will be using the basics of how to design a readable program. We will then add loops which will require the addition of more complex design patterns, and the construction of algorithms. We will cover all major loop types such as for and while loops. Methods and classes will be next, with in depth breakdowns of the conventions in Java that we must follow to make our program readable. We will the start to work with arrays and then add in how to handle exceptions and useful classes like the Date class. Interfaces and the large tenets of OOP design are going to be another major topic. Finally, we will finish by learning how to build complex GUI programs with the BreezySwing package.


Other Advantages: I will personally provide detailed response to your questions within a day, compare to others who either don't respond at all or fail to actually respond. In addition there is a 30 day risk free trial so there really is no disadvantage to signing up today!!!




Hopefully you'll join all of us on this great journey through one of the greatest programming languages in the world in this authoritative course on Java programming.

Who is the target audience?
  • Anyone who wants to learn how to code
  • Anybody with a willingness to learn Java
  • Anyone who wants to increase their programming skills
  • Anyone looking to learn how to use Java to build programs
  • Those looking to brush up on their Java skills
Compare to Other Java Courses
Curriculum For This Course
135 Lectures
34:23:57
+
Installations of Programs
5 Lectures 20:45
How to install Java(Windows)
07:11

How to install Java(Mac)
02:37

How to install Java(Linux)
06:09

How to install Eclipse(All Operating Systems)
00:16

In this lesson we will be covering the advantages of this course over other courses, and the general format that we will be using in our future lessons. In addition, we will be going over some of the case studies we will preform.

Preview 04:31
+
Introduction into Basic Programming
16 Lectures 04:02:14

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.

Why Java
09:14

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.

Intro into Eclipse IDE
05:03

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.

Java in the Backend
09:26

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.

Hello World(First Program)
20:48

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. 

Introduction to Variables
17:27

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.

Taking Input
17:47

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.

Error Types
13:47

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.

Outputting to the Screen
06:25

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.

Numeric Data Types
22:57

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.

Operators
22:07

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.

Increment and Decrement
09:09

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.

Preview 05:31

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.

Precedence and Naming
25:56

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.

Random Class
19:25

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.

Case Study: Employee Program
27:35

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.

Case Study: Rectangle Program
09:37

This quiz will be used to check to make sure you understood the basics of Java programs.

Chapter Quiz 1
6 questions
+
Java Data Types
8 Lectures 01:57:46

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.

Decimal Format Class
11:25

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.

Casting
09:54

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.

Boolean Basics
06:19

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.

Character Basics
18:50

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.

String
20:00

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.

String Methods
27:54

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.

Taking Input with Strings and Chars
07:42

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.

Case Study: String Analyzer
15:42

This quiz will asses how much you learned from the data types.

Chapter 2 Quiz
5 questions
+
Control Statements
13 Lectures 02:56:50

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.

What are Control Statements
06:22

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.

New Boolean Operators
31:03

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.

If Statements
14:45

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.

Else and Else If
15:09

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.

Case Study: Grader
18:06

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.

Case Study: Addition Program
08:31

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.

Nesting
08:01

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..

Switch Statements
13:18

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.

Math Class
11:51

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.

Common Pitfalls
10:32

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.

Extended Assignment Operators
13:07

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.

Case Study: Similarity Checker
10:58

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.

Preview 15:07

This quiz will be used to check your knowledge of the control statements.

Chapter 3 Quiz
5 questions
+
Loops
13 Lectures 02:35:18

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.

Intorduction into Loops
08:21

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.

While Loops
10:52

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.

Do While Loops
08:38

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.

For Loops
14:31

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.

Nesting with Loops
10:45

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.

Which Type of Loop to Use
10:32

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.

When to use a Loop
09:03

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.

Case Study: Even Number Counter
14:26

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.

Case Study: Primes
25:00

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.

Case Study: Repeated Addition with Loops
19:04

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.

Preview 07:57

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.

Escape Sequences
12:58

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.

Sentinel Controlled Programs
03:11

Loops quiz

Chapter 4 Quiz
5 questions
+
Methods
11 Lectures 02:42:12

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.

What are Methods
11:15

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.

Methods Basics
15:55

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.

Case Study: GCD Calculator
07:51

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.

Calling Methods
09:37

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.

Overloading Methods
10:14

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.

Case Study: Fractions Calculator
27:04

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.

Input and Output Redirection
10:27

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.

Case Study: Addition Program with Methods
30:01

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.

Error Checking with Methods
06:11

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.

Writing Programs with Methods
11:18

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

Test Data
22:19

Methods Quiz

Chapter 5 Quiz
5 questions
+
Classes
10 Lectures 02:51:51

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.

What are Classes
06:50

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.

Classes we have Used
10:47

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.

Creating our own Classes
30:56

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.

Instantiating our own Classes
18:18

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.


Objects vs Methods
06:03

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.

Preview 13:03

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. 

Case Study: Student Class
19:11

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.

Case Study: Student Class Part 2
23:17

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.

Case Study: Fruit Class
30:01

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.

Scope Again
13:25

Classes Quiz

Chapter 6 Quiz
5 questions
+
Arrays
22 Lectures 05:42:23

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.

What is an Array
10:33

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.

When to use an Array
08:42

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.

Array Basics
23:47

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.

Array Errors
13:21

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.

Creating Arrays
07:47

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.

Outputting Arrays
05:33

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.

Copying Arrays
16:16

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.

For Each Loop
11:31

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.

Variable Argument Methods
12:45

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.

Arrays with Methods
14:26

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.

Parallel Arrays
06:50

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.

2 Dimensional Arrays
26:16

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.

Conditional Statements
04:45

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.

Command Line Arguments
12:35

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.

Ragged Arrays
15:47

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.

Multidimensional Arrays
21:15

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.

Arrays Class Methods
26:12

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.

Array List
08:22

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.

Case Study: Cards
22:11

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.

Case Study: Randomizer
26:51

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.

Case Study: Part 1: Building a Sorter
22:52

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.

Case Study: Part 2: Binary Search
23:46

Arrays chapter quiz

Chapter 7 Quiz
5 questions
+
Object oriented programming Principles
20 Lectures 05:19:00

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.

What is Object Oriented Programing
09:02

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.

Encapsulation
11:50

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.

Inheritance
22:28

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.

toString method
13:07

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.

InstanceOf Operator
08:15

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.

Dynamic Binding
13:12

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.

Polymorphism
16:38

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.

Association vs Composition
06:10

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.

Wrapper Classes
12:03

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.

Final Keyword
06:44

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.

Case Study: Calculator with Arguments
11:34

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.

Abstract Classes
25:10

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.

Abstract Methods
12:21

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.

When to use Abstract
12:36

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.

Interfaces
26:22

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.

Cloneable Interfaces
10:56

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.

Compareable Interface
23:04

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.

Abstract vs Interfaces vs Inheritance
12:39

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.

Case Study: Little World Part 1
28:55

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.

Case Study: Little World Part 2
35:54

OOP quiz

Chapter 8 Quiz
5 questions
+
Bonus Lessons
6 Lectures 01:36:45

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.

BigInteger and BigDecimal
16:48

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.

Date Class
13:43

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.

PrintWriter and File Classees
16:00

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.

URL Class
11:57

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.

Exceptions Part 1
20:38

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.

Exceptions Part 2
17:39

Bonus Lessons Quiz

Chapter 9 Quiz
5 questions
1 More Section
About the Instructor
Anirudh Balasubramanian
4.4 Average rating
316 Reviews
12,937 Students
2 Courses
Experienced Java Developer

I have multiple years of developing experience in multiple languages such a Python, HTML, and of course Java. Over the previous years I have implemented the basics to more complex programs, and have acquired a bounty of knowledge that I'd love to share. I spend multiple months preparing my courses and enjoy teaching those new to the Computer Science field as well as those who are more experienced. Hopefully you enjoy my course as much as I enjoyed making it!