Transcript for:
Overview of Java Video Course Lesson

Hi, welcome to my free Java video course. Lesson One. My name is Marcos B. I'm a software Craftsman with 14 years of experience in Java. My goal is to teach you Java in the easiest possible way. Okay, we will start with a briefing, which is basically a lot of theory in the beginning. Second, we will do a practice session, where we will actually write our first Java program. Finally, we will do a short key briefing, where we will recap what we learned so far, and add some more theory were needed. In this first lesson, I'm going to introduce you to the following 15 Java key words or concepts, which you will need to understand your first coding session later on. Please note, especially if you already know some programming, I really focus on not using any term before I officially introduced it, getting a keyword explained using concepts I don't know, something that always ticks me off in classes, so I aim to do better in this aspect. Therefore, intentionally, I might explain a few things, not 100% academically correct in the beginning. When necessary, I will add the academically correct later on. As stated earlier, my goal is to teach you Java in the easiest possible way. If I can achieve this by looking just a bit stupid, that's fine with me. Last but not least, this is really only a first introduction. It's okay if you don't directly grasp everything. We will go in more detail and recap the important parts later on. A package or better package structure is like the file structure on your computer. It helps to organize the different files of your program. The top root folder of a package structure is usually the organization's domain name in a reverse order. In my case, that would become Marco spiele. For example, if you don't have a domain for the program you're writing, it's okay to invent your own domain name, but make sure it's a unique name. The reason for this is that the name of a program file is actually a combination of its own name, plus the full package structure of the package. It recites and there are millions of other programs out there, and chances are high that someone else has already used exactly the same program file name before you. As Java code is heavily shared worldwide, a strategy was needed to come up with a unique name to prevent name clashes. Each domain names can technically exist only once. Therefore, using a domain name as the prefix for your package name as the default. Think of the package name, like an absolute file name of your program file. Using your package name is optional, but I highly recommend you to do so even for the simplest program. When used, the package must be declared on the first line of your Java program. The package name is starting with a domain name in reverse order. As stated before. The reason for this is that the package name from left to right gets more and more specific. Using lowercase and singular for package names is the recommended default. Last but not least, the package name also serves as a high level description of all the Program Files related to a certain topic. code written for less than one of this Java course would end up in a package called con Marco spiele. java course lesson one for example. Please choose package names for fully. It's not just a stupid name. The package names reflect the internal structure of your entire program. Last but not least, I recommend you to choose package names related to your specific business topic. Rather than just using technical terms. Good names are key. To simplify programming. Every program file will reuse existing code. To do so you have to import the code into your program file. In our program file, the import statement or import statements will follow directly after the package declaration. Here you can also see how the package name must be included in the import statement, as it is actually part of the programs falling. You may import specific files, or all files of a certain package using the star symbol. Besides regular import statements, they are also static imports, which we will cover in detail at a later time. A simple program can easily consist of 1000s if not 10s of 1000s of code lines, it's very easy to get lost in such a big pile of information. Therefore, it's really important to impose a structure on the program code besides using packages, as explained before, in Java, the program code is classified into different units of code. Such a unit we call a class. The programmer is the one who may decide how to name and structure packages, as well as classes. One aspect of Java is to improve cooperation between business clients and programmers. The client is able or should be able to tell what he wants, the program is able or should be able to know how this can be expressed in code. The closer this code is related to the business easier, the cooperation between programmers and business people will be forming a common language related to the business and use throughout the code is therefore of utmost importance. By convention, the name of a class in Java should be a noun, starting with a capital letter. opening curly brace defines the beginning of the definition of the class, where we will later write all our code related to a car. The closing curly brace defines the end of the definition of the class, a class should be focused on only one topic. As a recommendation, keep your classes as small as possible to improve reusability as well as readability. A class usually consists of one or more methods. As the name implies, it defines a method of how to achieve a certain thing, like a method double could be defined to calculate the double amount of an input given methods are sometimes also called functions. For now, one at 100%. Academically correct, it's okay to use the terms interchangeably. By convention, the name of a method should be a verb that best describes the purpose of the method. Methods define the actions you can execute on classes, so they further refine the structure of our program code. methods can do pretty much everything for us. methods can operate not only in numbers, but also on text, colors, sounds, you name it. A book would have chapters, every chapter would have paragraphs and every paragraph would have sentences structuring your Java code in a similar way. Packaging name would be like a chapter, a class would be like a paragraph, and a method would be like a sentence. For example, methods internally can call other methods, which will then form a hierarchy of methods calling each other. As a programmer. It's up to you of how you want to structure your code, how long you want a method to be, which method will use which sub methods. I would recommend however, to always think of the current level of abstraction, just as if you would write a book. For example, a method prepared dinner could internally call a method prepare appetizer, followed by a method called prepare main course, followed again by a method called prepper. Desert. The prepare main course method for instance, could internally call a method called boil water. Mixing the levels of abstraction work for example mean to have a method prepare dinner, internally calling a method prepare appetizer 30 followed by a method called warm water without having a proper main course method surrounding it. Coming up with clean structure is key in programming. Make your Code speak to you. Today with problems of millions of lines of code. The most important part of programming is structure and readability for humans. As soon as you start to lose focus and have difficulties in understanding what a program does, chances are high you will misunderstand some concept of the code. And so you might introduce an error. Keep your methods as short as possible. As a rule of thumb, I would recommend 123 lines with 20 lines as a maximum. The definition of a method follows a similar concept of that of a class. First, we define the name of the method. As stated before, he was a word and start with a lowercase letter. The name of a method is followed by an opening and closing bracket. This is the place where we mainly find the names of zero to an unlimited amount of input fields. When using the method later on, you will need to choose a value for those values. These values are called method parameters. In order to further improve the structure and readability of your code, I recommend you to use as few as possible method parameters, with three to five parameters as a maximum, everything more than that will not be readable. The opening curly brace defines the beginning of the method definition. closing curly brace defines the end of the method definition. Later, we will define the actual code of the method that will go into the space between the curly braces. As the name implies, a variable is a variable value, a placeholder for a value that you can set. The value of a variable may change while the program is running. For example, when the third value is calculated over the lifetime of your program. variables can be used as input or output values of methods. For example, variables can be of different data types, like numbers or text. data types we will cover in detail at a later time. Just for example, possible variable names for a car could be my old car, my pushy, or mom's car. There are different types of variables, like instance variables, static variables, local variables, parameters or arguments, we will cover the differences in a later session. Public is an access modifier that defines that any class from any package may use the class or method with public access modifier. Besides public, there are also other access modifiers like private default or protected. Here we are only skimming a topic. In a later session we are going to cover access modifiers in detail. Here you can see the access modifier public in action. The class as well as the method now posts have public access defined. For every method, you actually have to define our return value. Ironically, even when you don't want to return any value at all. In this case, you will send void as return value of the method to explicitly define that the method will not return a value. Besides void, a method can actually return any kind of data type. Here you can see the void return type in action or drive method suppose to make the car drive which is expected to execute an action but not to return any value to us. As a rule of thumb, it's good design to differentiate between query methods, which will return a value but do not alter the state and command methods which offer the state but do not return a value. In respect to this best practice rule. Drive is a command method and therefore does not return any value. The Add symbol indicates an annotation. We will cover annotations in detail in a later session. Just for now, I want you to know that with ADD test, we indicate that a given method will be used as a test. When a class a variable or method name consists of more than one word In Java, you use an uppercase letter to indicate the beginning of a new word. This is called camel case, as the ups and downs of upper and lowercase letters look like camel humps. In other programming languages, and underscore is used to separate two words from each other inside a variable name. In Java, however, camel case is used instead. To indicate the end of a sentence, we use a thought in English sentences. In Java, however, the DOT has a completely different meaning. The dot between the variable car and the method drive indicates that we want to execute or we will alter. Alternatively, say call the method drive on car. As the.is already used to indicate a method being called a colon is used to indicate the end of a statement in Java. Here we can see an example of a test method that is expected to test that our car drives. The method drive is executed on car with the value of 100. Colin says I want this to be executed period. I talked about classes already. I said that a class is a way of structuring code in Java, a unit of code. This is perfectly true. However, it's only part of the magic. A class is like a template, like a definition of what you want the class to do for you later on when the program is running. The class car for example, defines the behavior of a car. However, when your program is running, we say at runtime, there will usually be a number of cars, each car may have its own unique set of values, one car might leak oil, so the value of oil could drop to zero while the program is running. So our classes like the human DNA, a definition of how something should be created when the program is running. When a Java program is running, it would usually create a certain number of objects that will exist as a set of values in the computer's memory. And those values might change while the program is running. Each program language for certain concept, Java is an object oriented language. Everything is focused around objects in Java. In Java writing classes is a way of defining a model, which focuses on necessary aspects to solve a specific problem. It needs the brain powers of a clever Java programmer to fully understand the problem and to extract a theoretical model from it and transfer this model into classes. The skills of the programmer will have high impact on how precisely a problem is transferred into a class model. Simply speaking, the more accurate this is done, the less code has to be written and maintained. The fossils or program will run, the less errors it will have. The power of Java is to be able to define an execute table model, like a virtual machine on your computer. With concepts and names taken from the real world, which heavily improves the communication of the programmer, and the business client, programmer and business client can both talk of a car. While the one is talking of a real car, and the other of the representation of this car on the computer, they will understand each other. Here we see a simplified definition of a class car. Now imagine a game where each player creates a car when the game starts. The program in this example, might create three different cars at runtime. Now I talked about classes and objects that will be created from those classes. But how will these objects be actually created? We will need a method that will create the objects for us. This is a very special method. It is called on a class and we'll create an object each time we call this method. But as soon as the object exists, we cannot call this method anymore. The special method is called a constructor, as it is used to construct objects from class files to create a new object of time car, you write new car. For example, the constructor in this case, just like a method is given two different numbers, one for the age of the car and one for the maximum speed. In our example, when the program is running and executes this line, a new object will be created in your computer's memory. We will, we talked about variables already. However, before we can use a variable, we need to define it beforehand. Call my Porsche Colin is an example of a variable declaration, we declare the variable which we called my portion of the type car. Now that we have a variable declared, we have to allocate the object we created a variable declaration, object creation, and allocation can all be done in one single line. So this line reads as when the program is running, and when this line of code is executed, create an object of type car with first of all you won, and a second volume of 320. Then create a variable of type car and give it a name my portion. Last but not least, assign the car object to the variable named my portion. After this line, whenever we use my portion, we actually referenced the object created in memory. Also, you might notice when looking at this line of code, we put two values into the constructor of car. But without looking into the code of the class car, we wouldn't even know what their meaning actually is. This is one reason why you should try to limit the number of variables used in a method as well as in a constructor, the less the better. In session, to have this free Java video course, we're going to write our first Java program. When we write code, we actually start by writing a program, which is actually testing the program or class we are going to write. We do this for two reasons. First, the test forces us to properly think our idea through which will improve our code a lot. Second, the main effort in the lifecycle of a program is actually not the first time effort of writing the program code, but to maintain the program, like extending or improving the functionality or fixing arrows called bugs in your code. Whenever you write code, there is a high risk you will introduce defects in your code. When your program is written once with the help of a test, this test will ensure that whatever happens, your program will continue to function as designed initially. To recap, in Lesson One of this free Java video course, I explained the necessary theory to code our first Java program, which we are going to do in a minute, we are going to use these 15 Java keywords and concepts described in detail in the prior session. If you haven't done yet, I would recommend you to start with session one before watching this practice session. Okay, so now I'm in my development environment. I've created a folder structure of calm Marcos build Java course, lesson two in a folder called test and also here source main. Java. com Marcos build Java course lesson two. This is where we will write our tests have already created the fall person test of Java. This here is where later we will have our actual program. But okay, so let's start person test. As described in Lesson One, we have to start with a package declaration. So I write and you see here, I actually get support by my environment, about the development environment. I'll tell you later. For now just see that it actually assists you. Actually, when you start learning to program, I would recommend you to start with a regular text editor because you need to learn all these keywords. And so I guess it's easier in the beginning. I mean not easier, but it helps you to learn the stuff from scratch. If you really have To focus and concentrate, and you don't get assistance. But as soon as you manage all these keywords, as soon as you know all them section environment is really helpful. Okay, so I use package, and then I have to define it. COMM macros, we'll see how it assists me again, it already knows the package, because I have here the folder structure, and the folder structure, and the package declaration in my file actually have to be the same. Otherwise, this would be an error. So actually, I don't even have to write it anymore. I can just follow. Okay, so this is my package. And you see, before we have an underline or red underline, which means something is wrong. Now, oh, editor seems to be fine with what I wrote so far. Okay, here we are. Later, we'll have imports, as described in lesson one. But we will add them later. Normally, you start defining your class first. See, again, I wrote public and see how it's underlined red, so something is missing. So I say class, and now I have to define the class name is a person test. So I call my test person test, it's a test for our first program, which is the class person. Okay, now I have to add the brackets. When I add the first one, my editor already adds the second one. Because for every opening bracket, you always need a closing bracket. Okay, so this is the beginning. And this the end of my person test. Okay, no at the annotation test. So that I define, I want to write a test. And see, magically, the input appeared. Because my environment already knows, I want to write a test. The test also, I mean, it's actually a class. And it even has package. And this is all three unit test. We'll talk much more about j unit in later lessons. But for now, we just know this is a test magically somehow. Okay, and we need to test the method. test method will be public. It won't return any value, so it will be void. And I will give it a name what I want it to do should return hello world. Hello World is actually like a running gag of programmers. Someone I don't know who once started. That first program you write in a language should return hello world. So we do that to write a test. For my first HelloWorld program, I expect my person to return hello world to me. And I'm going to test this. We haven't written any actual code for person. But we're starting reverse. So we're starting with the test, as explained before. So now I can just assume I was done. You see, it's red, which means we don't have a class person yet. But this doesn't matter. Now for this person, I need a variable name. And as my name is markers, just for fun, I call it person I call the person Marcus. Okay, now I have to create person markers. Remember, this was calling the constructor creating the object. And so this is creating the object of person from the type from the class person. And the equal sign assigns that object which is created in the memory of RPC to the variable, the reference variable person because this is a reference that we can later on use referencing the person. Okay. Now this is read, but we'll take care of this later. We just continue. Okay, so assuming we were done, what do we want? We want to test something And testing, we say we want to assert something, we want to assert that a method we're going to write is returning the hello world for us. So, we want to compare if our expectation is equal to what the method is going to return. So we say assert equals, this also is starting as red, because we will have to import more stuff. But for now, we just take it, I use this was again metric I add one quotation mark, and my environment already adds a closing quotation marks. This is what we call a string. And I say hello world, because I want my person to return HelloWorld for me, so, the first part here is the expected return Well, you know, I add a comma. And now I have to add what is going to be tested Marcus dot for calling a method Hello, world. So on the object, Marcos of class person, I want to call a method, hello world, with no parameters given and what is returned here, I want to assert that it equals to hello world. Now, this is not going to work. Because we still have some red stuff. For example, here, we don't have actually written the class. But here we will let our environment help us, you see. Now I just have to say create a class person. Sorry, again, create class person. And here, it already asked us destination package, create class person. COMM walkersville. java course lesson two. Okay, sounds good. Because our test, and the actual class of the test will be in the same package. This actually helps us a lot. But more about this later on. I say, okay, and magic magically, or first class got created. You see the package, and the class. This is actually kind of the smallest class possible, just with opening and closing bracket. But it doesn't do anything yet. Okay, but you see, it's not red anymore. So let's go to from next, assert equals, oh, it wants to import something statically. I said before, I will later on tell you what means static import. But for now. Just believe me, we have to import this. This is another import from org j unit. But this time, it's an assert. And so this is like a method. We import the method assert equals. But, um, don't focus too much on this. We'll go in more detail later. For now, what is important, we want to write our first test. So we still need to define a method. And it also tells us cannot resolve method HelloWorld. Okay, help us please create method HelloWorld. We had enough it moved the method to the wrong place, but I'll fix that. Of course, we need to have it here. Okay, no, nothing read anymore. And we can start calling our first test. I say run. And this actually executed our first test, which again executed our first class that was automatically written. And here we see we have an error. It tells us a missing return statement. So I said we want to return a string you see string. But as you see the method is empty. We don't return anything. So let's fix that fix that return. This is how we say it, we have to say return. And I just have to type Hello, world. exactly as I was expecting it, I get the column to say yes to it return hello world. Okay, now we switch over to the test. And I'll execute the test again. And that's green, all tests passed. This is our first test. And it worked on in our first class, Tara. Okay. Thank you. That said, lesson three debriefing. For debriefing, we will go back to our development environment, and have a look what we learned so far. Okay, now we're back in our development environment. And now let's repeat what we learned so far. The first line of our program is the package declaration. It must be unique. And it usually consists of your domain name in reverse order. So in my case, calm, Marcos, bu Java course, lesson two, and we ended with a color. Actually, it's not mandatory, it's optional. But please, I really recommend you to use a package name. Later on, you will probably see why you just need to have some practice. But for now, just believe me treat this as if it was mandatory. And always define a package name. After the package declaration, we can have one or more import statements. This just for our lesson, now I made up I created a new class called name. And this is an A sub package called lesson three. Actually, all classes that are in the same package. So person has an a package called macro spiel Java course lesson two, for all classes that are in the exactly same package, lesson two at the end, we don't need to import them, Java will find them automatically. But here I made this lesson three. So if we want to use the name class that I just wrote, we have to import it. Okay. Next thing is class definition public class person. And with these brackets, that says the class begins, this says the class ends. Public means all other classes, for example, my new class name, in any package can see the class person. What this can see means is still a bit work. For now, just take it as it is, I don't expect you to fully understand it yet. This will need some practice. And here for now, some new stuff, I added the class that I defined name, and I made it private, which is also best practice to have we call this a reference variable, because it is a reference to later on an object of type name. And I made it private, which means other objects that get created will not be able to see. See again, I say See, or access this field here directly. If they want to use it, they have to go using this method I also just created this one is public and it returns personally. So when they call person dot name, the method you can give it any name I just call it salt, but you could also call it I don't know. Return the name. So this can be anything um, and it will return the person's name. So here again we see return, which means I want this to be returned to whoever calls that method and the colon which means do it execute it. Okay. What else did we learn? We learned that this stream, and that having a class, returning HelloWorld is like a running gag in programming for the first program that you do. So this is why I made class person return hello world. I mean, actually, it might not make sense. But yeah, just was all made up. Then also, going to the test, we learned, we actually start with writing a test. When we wrote the test, we hadn't defined the class person yet. We hadn't defined the method HelloWorld yet. We did all this on the fly. In our development environment assisted us with some auto completion, it was able to create the class as well as the method. So this is really a handy way of programming. First of all, you define the test. So this gives you an opportunity to think about the property sign. And then you define what you need, and you don't have to actually even write it yourself. And when you did everything correctly, you can simply execute the test. And when it returns, okay, and it screen, you will see that you did a proper job. Okay, see, here, you'll see a green bar, which means the test executed successfully. So when testing we often speak of green or red bar, because the green bar is such a good signal that you understand your test passed successfully, that people got used to just speak of green and red bars. Okay, so we learned some more stuff, for example, that this is an annotation. And I told you, you don't need to know more details about it yet. We will go into details later. Besides on top of input static, and also, I just want you for now to know that something static exists, but we will go into details later. Okay. I think that's it. It's okay, if you don't understand everything perfectly yet, I don't expect you to. Um, so we'll go in more details later. And we will repeat all this stuff. So it's fine. I mean, the start is really tough. I know that I don't expect you to be an expert in Java yet. Um, this is just an introduction, and you will grasp it soon. lesson four. Okay, we're back in my ID E. Id is actually the short form for integrated development environment. And as this is much shorter, usually you just say ID e. m, let's recap what we learned so far. And the first one, you have the package. And the second line, you might have import statements, you don't necessarily need something I didn't tell you so far is here we use name. And we use the classes short name, because actually, the classes real full name includes always the package name, so that the name is of the class is unique. So we could also use its full name, including the package name, and then we would not need to import the class. But I mean, as you see, this is much more readable, much shorter, so also much more handy. So this is what you normally do. There's only one exception, which is a bit more advanced. So I will just shortly mention it. Sometimes it rarely happens that you would have two classes of the exact same short name but have different packages. And so to define which one you mean, then you would have to use one with the full package name. Okay. So next, we define the class. The class starts with a curly opening brace and ends for the curly closing brace. Um, we have here, we say it's an instance variable actually. And this is an instance method instance variable. And instance methods could be, of course, much more. But those together we call the members of the class, because they belong to the class. An instance is just like an object. So of one class, you can create various instances, like, one person could be Marcos, another person could be, could have the name of Peter. And you could have hundreds of hundreds of class of objects, sorry. And each one of these objects is an instance. And for the instance variables, this means that each instance has their own version of this variable, which each might have a different value does not need to. But it's like a duplicate version. There's also another thing, which is called a class variable. And a class method, which we do when we add static to it, we can add static here, as well as to the here. In this case, now when we create different instances, and we change the person name of one instance, this means that all other instances will also have the name change to the new value. This is a bit more advanced and static. We should talk about this in detail later. So I just shortly, just to be complete, wanted to mention it. For now, it's totally enough, if you know, this is an instance variable, and this is an instance method, okay. Besides that, I would want to add a constructor, I think I talked about constructors already. Okay. Opening and closing curly brace. This is what we call a default constructor. It does not have any parameter here, not any variable. And so this is the default constructor. When we want to create an object of type person of class person, this constructor will be called and everything that we would do in here would also be executed. So this constructor is actually used to initialize an object. Because for example, let's do something else. Now let's add a parameter, prison name. So this now gets a bit more dynamic, more interesting, because we could try to set the inner person name to the given person name. Now, you see something is wrong. Variable person name is assigned to itself. Well, of course, how should our ID or Java know? What do you mean? Here, we need something to differentiate to tell Java, what we want is we want to set this instance variable to the value of the parameter person name. One thing we can do to fix that, we could just rename the variable to see it works. Now we can automatically automatically resolve the problem. But usually you don't want that I mean, person name is better name, of course. And now what we have to do, we have to add this to one of them. And as we want to set the value of person name to the instance variable person name, we add this dot person name. And so Java knows that we mean this one here. And now, when someone calls the constructor to create an object of type person, it'll also have to add the person's name. And then the person named darts directly gets set at the time the object is created. Okay, one more thing that you should know is now that we have created our own constructor that has the parameter person name, this means this class does not does not have a default constructor, an empty constructor like I showed you before this one has gone. Java will automatically created when there is no constructor defined by us. But as soon as we have defined one, General will not do that. Now if you remember our test from the last version, we use the constructor without any parameter. So this will later on fail, but I want to show you so I will let it as it is. Okay, so, um, remember we had that method here HelloWorld, I told you that in the first program in every programming language has like a running gag, you return hello world. Hello World is actually a string. And here we say the method should return a string. Now, I want to do some more advanced on, I would like to have a method, I can give a parameter of string. And then I want to say hello, the person's name. Um, okay. And as you also might remember, usually we start with a test. So let's write a test for what I'm planning. Okay, so how do we write the test? So we have to first of all at the end here, and then say test. This is what we call it a notation. Much more. We don't know yet. And you don't need to know for the moment. I mean, this is all confusing. So relax. I'll repeat everything various times, you will understand that very soon. For now, let's just write the test. So I say should we turn Marcos. Okay, because this is what I want the method to do. Okay, now I have the opening and closing brackets for the method. Okay, so we need to create an object of type person. Last time I called it, Marcos. This time, I want to show you how we can use any name we want. So it's called person, new person. So with that new person, and the regular brackets, I call the constructor. And this is like a method that is being initially executed at the time when the object is created in our memory, and see something is read here. Because I told you the default constructor is gone. So if we want to do that, we have to go back to our class. And we have to add the default constructor again. We can add it at any place, put it here. Okay, and now this is empty, and it'll work. But having an empty method or an empty constructor might be confusing for a colleague. So usually what we do in this case, we leave a comment. To mention we haven't forgotten anything. We have done this on purpose. So let's see how do we do a comment actually. So I say empty. On purpose, default constructor. So what I have here is a multi line comment. There's also also a single line comment, which you do just like this single line, comment. But I really recommend you should prefer the multi line comment for various reasons. I will go in detail about comments in a later session. So for now, this is all I want to show you. Okay, so we have fixed the test. Yes, the red thing is gone. Great. We have created an object of type person, let me copy this to show you one thing. You can actually create various objects one after the other. But now, we already have one object that we called person. So this will not work. So we would have to give this for example, person two. And so like this, we could continue. We could create any number of objects, just so that you see. We have one class of type person. And we have two objects created calling the default constructor. And so we have two objects when this is executed later on. I will delete this again. I mean, this was just a short demonstration. Because we should remember what we want to achieve actually is we want the method to return Marcos. Well, actually I was wrong. I want to say hello, Marcos. Okay, so now let's assert again. assert equals, I want Hello, Marcos. And I want to say person dot Hello. And I want to give it here, when we use a variable here, we call it an argument. This is just to make it more confusing, and people use this interchangeably. But to be correct here, it's called an argument. But it's all about variables. So we add a string. And I add markers. Okay, and see something is missing our ID, he tells us something right here, we need to call him to finish this. So I want on the object of person we created in the line before, I want to call a method Hello. And you see it's red. And it also our Id even already tells us cannot resolve method Hello. It doesn't exist. But we are programming in a test driven style. And so we will have to create a method right now. Okay, I'm actually, with some magic, I can automatically make my array he created for us. Well, there are different IDs, and I will speak about it specifically later on. So for now, I just did this to speed up it up. Just believe me. I mean, you. I'm sure you could create that by yourself. Now and he did something it said return now about now this is something special. I don't want to talk now. I'll tell you later. Okay. Sorry, I don't want to confuse you. But I also don't want to tell you too much. So one after the other. And now, I would add well Marcus's a bit. Let's say name. Name, because it could be any name, not necessarily has to be Marcos, we could add any name we want. And what I want is I want to add name to Hello. What we say here we want to concatenate hello and name. And something is missing. Oh, it doesn't like it. What is missing is a plus. This is how you concatenate two strings together. So a new bigger string is created. And you can do this any number of time. But for now, I mean, all we wanted to say is Hello, and the given name. So this should be fine. Actually, there's a little back hidden, which you will see very soon. Which I did on purpose, because I want our test to fail. Let's execute it. Ah, so you see expected Hello, Marcos. But actual Hello, Marcus. So there's a space missing. So see, this is one reason why tests are really handy to help you to think about the stuff you code. But also when you do introduce a back an arrow, then you will directly spot it and you're able to fix it before it goes on production and destroy something. And yeah, this can be really expensive. So let's fix this. Let's go down to our method. And here was a space missing. Let's add it. We go back to the test. executed again. And now the bar is green. It's works. Oh, that's great. Okay. Um, yeah, I think that's it for now. Lesson five. So now, I would like to talk about modifiers first of all about visibility modifiers. Actually, we already talked about them a bit. One visibility modifier is private. Another one is public. So public, I think I already said this class is visible or usable. From all other classes in all other packages. This class now resides on the package comm Mako speelde. java course lesson two. So here, for example, name is in lesson three. So if we would go in the code of the name class, it could easily use person as long as it's public. A private class, we can try that. No, it says modifier private not allowed here. And of course how That makes sense. I mean, a class that's not usable anywhere. But just in this class. This doesn't make sense. But actually, there is one more option, we can leave the modifier away. And this will give us the default modifier. This is also why it's called default modifier, also package level modifier, because now, person can only be used from other classes within this package. And we can do the same for the variables, the constructors, we can even have a private constructor, we could have that public, we could have that method private. And this one default. And we can even call, let's use this one. Let's call HelloWorld. From this method here, all this is working. And this actually even makes sense. Because especially when your methods are growing, I personally would say not more than three or 10 lines. Then to break things up, you can split a long method into smaller private methods, and then calling the private method. Like, I mean, here, we have only two methods. So to make things up, you can call one method three times. But of course, I could define further methods. We don't have this now. And then you can call any number of methods later on. Okay, so to recap, visibility modifiers, we learned so far is public, private, and default or package level. Besides there are other visibility modifiers, one, for example, is protected. But we don't need this at the moment. So you should be perfectly coming alone, along with just public, private and default. So for now, let's just concentrate on these few. Let me fix the class shortly. Because very soon, we are going to need it in our test. And I don't want to adjust the test, I want to have the code as it was before. Okay, because now I want to show you a new concept. I have this idea. I have prepared the test should return number of persons. Let me create a few objects of type person, one person, person to person, we could also use the other constructor, but then I would have to create an object of name, as this at the moment is just too much work for me, I'm not doing it. And I can also give it a different name, like my person, just to show you, we can have any name for the variables. So what this means is when the test will be created here, after this line is executed, which is just after the column, we will have one object and memory two objects in memory. And after this line three objects in memory. So what I want now I want to test on a number of objects. Now I should have three objects created. And I want to create a method that tells me exactly that. Just dynamically, my person thought number of persons. Okay, still read, remember, we'll create it. And today Ah, int appeared. Because I mean three is a number. And a number in Java is an integer, or he In short, an int an int this actually a primitive. And the default of this is zero. So this is why my ID he put zero here. So it's not red anymore. We can have a first run. But this will not work of course, because it statically returns zero we expect three. So this is not what we want. Well of course we could say three statically. So, now this should work. It's a bit cheating, of course, greenbar Tada. But, I mean, I want this to dynamically work. So why not only have two persons, I want this to be two. And well, of course, I have to rename a variable. Let's copy it. And now when I execute it, of course, this is not going to work expected to, but it's still three. So my first approach the static one, always returning three. Nice gag, but yeah, not what we need. So what we need is, at the specific time, when each object is created, we need to count each object that is created. So what would be the place where the object is created, there is one thing, similar to a method that is called and this is, you might guess it, the constructor, we used the default constructor for creation. So we would have to do something in here. Now, I want to invent a variable, an instance variable, I also call it or let's call it person counter, person counter equals two. And now I say person counter, because I want the value it had before. And then I want to add one to the last value of person counter to have the new value dynamic. So on the left side, is the new value. On the right side is still the value from the prior calculation. And I add one to it. Now, this is a lot of code again. And this incrementation by one is used so often, that they invented short form for that, which is plus plus. So with plus plus, we say take the current value of person counter incremented by one and save it again into the value of person counter, it's still red, because we still have to create it. Let's do that. Make it private, of course, it's an int. I call the person counter and column. Because I don't have to say zero, I could also say equals to zero. But the default for end is zero anyway, so what we usually do is, we just put it here as is. So the idea would be it starts with zero. The first time this constructor is called, it's incremented by one, and so on. So that my method now should not statically returns three, but person counter instead. Okay, let's try that. Execute the method. Still not working it returned one. It didn't return zero. It didn't return three it returned one. How is that? We didn't say one anywhere. Maybe you guessed it already. So we started with zero, we incremented by one. Now I told you something in the prior session, which is this constructor is part of the instance. So each object has their own constructor has their own method. So this is called for each of the objects. So in the end, both objects would have the counters set to one. So what we need is more like a global counter. That is not on the instance level. But we say on the class level, because for all the objects of type person, there's only one class person and this we achieve with a modifier called static. Okay. However, as a recommendation because this will help you in the future, I won't go on details Why just believe me. As we have the variable of types of static, you should also have the method of type static, it would work also without that, it just better believe me. Okay, so now let's execute it. And this work Great. Let's try another thing. Let's add this time for free for for an exit executed and it works, I said actually person to why not saying person one. And it works? Well as you see this might be confusing I mean which variable to decide on. And also there is a recommendation. Actually what Java does is Java sees that number of persons as a static method, it sees that you have an instance variable off type person. And as this is a static method, it doesn't call the method on the object. Because as this method is static, it's not part of the object anymore. This is like moving it out of the object. This method now is part of the class. So Java does some magic here, is trying to be smart and is smart, and calls the right method of the class. So what we're doing here is working because Java knows how to do it properly, but it's not so nice. What is better is darkly saying person, so that everyone knows you're not going to any specific instance, we're just calling a static static method. On the person class, let's execute that again. And it's working. Thank you. So in lesson six of this Java course, I'm going to talk about the tools which I'm using. So first of all, let's start with this computer. It's an apple MacBook Pro. This ID that I'm using here is IntelliJ IDEA, which actually at the moment is my favorite ID. Before I was using many, many years, Eclipse clips is open source is also very popular at the moment, especially with companies because it's open source and free. However, I think intelligence here is really getting better and better every year. So I really like it and recommended. And they're not paying me for saying that. But I mean, this is your personal preference, and every person is different. So I would say just try it out yourself. There's also NetBeans. NetBeans is also very popular, and it's also for free. I'll just in a second, I'll show you where to get them. But let's have a closer look at my tests before. So in the tests, might have seen it already. I'm using j unit, which is a testing framework. framework means it's like a tool set. It's a set of tools to set of classes. And it's open source. So it's free to use. And I mean, writing such a framework, it's not really hard work. But why doing it if it's already done. So this makes it really easy to start with testing. J unit also is only one of a few testing frameworks. The second one I would tell you about is test and G, I think they're pretty much the same. And really depends on the company that you work in some use j unit, some use testing G or any other framework, I think between j unit and test ng g there knows not so much big differences. So it doesn't really matter. I just decided to use j unit in here. IntelliJ IDEA actually supports both of them out of the box. So you can easily try them. Um, I'm not going in much more details, by the way. I mean, this is a Java tutorial. So I focus really on Java. Just to be complete, I wanted to mention what I'm using here. But I do this in less than six because at the beginning, I think learning a new language is already quite difficult. So I wanted to focus on Java, but not that you puzzled. What the heck is that here? What are you doing? I wanted to mention this is J unit. And there is lots of documentation on the internet. Yeah, so you can read a lot about it. Okay, so maybe we just go to the browser now. and have a look. So first of all, I told you about intelli j idea for you pops up. So you can download, I would first of all, go with the free edition, and then see if you like it or not. Besides, of course, there's Eclipse. This one is open source anyway. And then you can choose your operating system, and 32 or 64 bit, whatever you need. Last but not least NetBeans. Just press the download button, choose your language, and operating system. And then also j unit, let's have a look on that. In most It is these days, you won't have to install it, because it would come pre installed anyway. But just for the record, I mean, this also has lots of documentation. So yeah, he you can download the most current version. Let's check documentation. Here. It also talks about Maven, which, by the way, also using so this way, you can define in Maven that you want to use the current version for 12 of j unit, which I actually did, because I'm also using Maven, which we're going to in a second. But after j unit, let's also have a look on tests and G test ng g on this page just provides the false for Eclipse. But as I told you in IntelliJ IDEA, it's included anyway. And I checked for NetBeans. I mean, I'm not so familiar with NetBeans, I have to admit that beans, but I saw there is a plugin, which you can download and install. So probably works just as well. Now let's talk a bit about Maven. Maven, there's what's called a build management tool. So as the name implies, it manages your build. Now, what's a build? Well, when you program your programming consists of hundreds of classes, and then you would want to release them on production or send them to a client. And then of course, you would not want to send each file separately. So the so you would usually do a package a single file out of all the tasks together. And in former times, and say in prehistoric times, this was done manually. And this is really not a funny job. So people very soon started to program, some little scripts to make this task easier. The first tool that I know of is probably make it's a Unix tool. And often make they came up with and and Maven again is the successor of Maven of m sorry. And Maven currently exists in version three. Besides Maven, there's also Gradle and other build tools, I'm using Maven, here you see it find that I'm using j unit 412. And also the find that my source encoding is UTF eight, because what this bill two also can do for you. I mean, it can do so many things is environment specific settings. So that I tell that my source encoding is UTF eight, I can do it here. And so much more. So also about Maven, you can visit the website, Maven. There, you can download it. They also have a free book, which is really a great book. You can download all the files, even the sources that you would need. And also check Maven book. I really recommend that. As far as I remember. It's available as HTML. And also there should be a PDF somewhere. All this is just too long. Anyway, I know there is also a PDF available which you can download. And so you can read all about Maven Last but not least, let's also talk about bit about text editors. Because I think in at least one of the lessons I did so far, I told you, you should start not with an ID. But you should start with a text editor instead, well, there are two that I would recommend, first of all testbed for Windows, I really like it using Windows. for Mac, it's unfortunately not available. In this, you can write your code, then you would save it. And then assuming you have already downloaded the Java JDK, which I have also not talked about, because I assume I should be easy, but maybe we could first, shortly go there. So for the JDK, so that you can download your code, you can just go here, say download, by the way that was NetBeans, if it was soiled, and you can choose your operating system and download it. I assume you have already done that. And so when you have installed a text editor, or like text pad, or sublime, you're on. Mac, I'm using sublime, which is also a great editor. Download button. It's also available for Windows and Linux. So using this text editor, here, I've loaded the class person that we saw before. I mean, it helps you a bit like see, I click on person's name, it highlights the variable person name and all forms, but it would not so heavily assist you, like you might have seen when I was in my ID, which for the beginning is actually good, I think. Because when your ID is too smart, then you don't have to use your brain cells too much. I mean, after some time, when you have coded too much, this is really welcome. But for the beginning, I really recommend to use your brain cells and so that you get used and familiar with all these keywords, public class, private static, should really get familiar with that. And so for the beginning, just use a text editor, then you can also go on the console and called Java arc and compile the class. Also, this is one show you because in this course really I only focus on the theory of Java. So yes, I think that's it really short introduction of the tools that I'm using. If you have any questions, send me an email as always, um, yeah. Lesson seven. So now let's start with the topic of this video, which is conditional statements, and of course, conditional statements, and Boolean. So a Boolean is a new data type. This one is actually a primitive and it can have two values, Boolean, true or false. And this is all there is to it. So conditional statements, I mean, there is a condition and it can hold true or not. And that is something is executed or not. I think, already from the wording, it makes sense, and you might easily understand it. But what exactly is a Boolean? Why is it called Boolean? I mean, this is a bit weird, I think, well, at least this is what I found. So I just looked it up on the internet. Here on Wikipedia, we have Boolean algebra, and I'm really not a big fan of mathematics. So let's go over this really fast. The only thing that matters to me is Boolean algebra was introduced by George Boole in his first book, blah, blah, blah whatsoever. So it turns out that the Boolean is called all the end because of this guy here. Um, I leave this as your homework, read everything about George Boole and Boolean algebra, of course, this is again a big topic by itself. We have folk focusing again on Java, I just wanted to help you that you get a feeling why Boolean is called a Boolean. So this thing here is really helpful when we want to say if something happens or something exists, some condition, then only execute a specific area of code. And then you can also say else if this condition does not hold true execute something else. So this is really the if statement is probably the most important statement, not only in Java probably in all programming languages, at least the ones I know of, because it allows us to, like really have a different execution flow each time. For example, we could say, I mean, B is a bit boring. Let's call this Monday. And let's add all the raining. I was raining. Let's also have Monday. Okay, so in this little example, it's Monday, and it's raining. And nobody could say if it's Monday, and percent twice, raining. So what these two M percent mean is, and so this tells Java to check on this boolean value, check if it's true, and only if the first boolean value. Or he could also be a function, like, is it Monday, which would have to return a Boolean. And if it does, only then Java would execute, go here. And check if this is also true. Which also could of course, be a function if Is it raining or whatever, right. And if both here are true, then this block here, starting with the curly braces, is going to be executed. Now. I mean, I don't want to implement the functions. So let's make this Monday again. And simply raining. Just to keep it simple, and then drink beer. Because rain. I mean, what else can you do? Um, but now let's make this more easy to drink beer. I'm from Munich, so I'm really a beer lover. So on Mac, I mean, as depends which platform you use. On Mac, you press just out and seven, twice. This is called the pipe symbol. And the pipe symbol symbolizes or, um, yeah, I know this is a bit weird. This, you just have to know by heart that this means or, again, as before with the two ampersands. When you repeat it twice, it's called the short circuit operator, which means if the first condition is already not true, for the end, at least, then it's not going to execute the rest. So whenever In a statement, it sees that a condition will cannot hold true anymore. It will stop at the beginning and they will not execute the rest, which is very handy. Because I mean, if before we had a method here, is it raining. Now imagine this method takes like two hours to execute, we could really save that time if we already see. This is only true if both are true. So this is why you use the ampersand twice. And the pipe symbol wise, this is I would say the default. So I want to even spend time to talk about the other alternative. But now this is so much nicer. If I have an orange here, if it's Monday, or if it's raining, I drink a beer. So this really increases my chance my chance to get a beer. So I personally liked the statement so much more. I'm just kidding. Um, so this is the difference. Or, and, and, and of course you can further combine that led so I don't know what to do. Let's say raining and let's say Tuesday and sunny. So we have to introduce these Boolean variables first. So Tuesday. Well, if it's Monday, it can't be Tuesday. So we will say false here. And Boolean, if it's raining, it can't be sunny. So sunny will be false. But of course, let's change this. Now it's not Monday. It's Tuesday. So this will be true. And I misspelled that sunny. Okay, now they're not red anymore. So now what do we have here? Monday is false. So if Monday is raining, but it's not Monday at the moment. So this is the whole thing here is not true. But here we have an or true Tuesday, this is true, Sunny is still false. So this is also false, which means the whole if statement is false. And we cannot drink a beer. But let's make this true. And now it's Tuesday. And it's sunny, and we can drink a beer Ray. Of course, I mean, when it gets more complicated, I'd recommend you to introduce more brackets to really tell Java first execute this. And the result when you have it, then only execute the next statement. I mean, if you go more in more detail on the algebraic logic, you will see there are preferences. And they're really rules on that. But if you don't know them, and if you always just add the brackets, you're on the safe side to show what you want. Okay, now, let's make this not so complicated. Because let's introduce something, something else. And this else is the else statement. Because if it's not money, we can do something else. And this is the new keyword that I'm introducing the else. statement. So here, we can say drink, milk. might also be nice. Okay, so, only on Monday, we drink beer. And on all other days, we drink milk. So that means we have to drink a lot of milk. So if you I mean, milk is really healthy. So I recommend you to drink milk like this. It's much better. But of course, let's introduce some more variation. If no sorry, else if, um, as you introduce a new day, let's say Friday. So we have to introduce Friday. At the moment, it's Tuesday, Tuesday. So we'll change that in a moment. Make this false. So else a Friday. Sorry. Drink water. Okay, so what do we have now? And I mean, you can format this in any way, but usually, you formatted like this, too, so that you can see this all this whole construct belongs together? Because it starts with if money. And if this is not true. Java has to check else is it Friday? If so, then call this function. And in all other cases, we still drink milk. So, okay, and you can have any number of L's if statements here. Else if I don't know some other condition, we could just say sunny. Um, if it's sunny, um, what should we do? go swimming, go swimming. Yeah, we can do anything here. Okay, so you can have any number of L's if statements. And you can have just one l statement, of course, but you don't have to, I mean, this is not obligatory. You can also leave it away. You just you cannot have AIDS if by itself because else what I mean, there has to be the whole statement has to start with some Eve. I'm okay. I think this pretty much is enough for if else if and else. Now let's do some more cool stuff. Let me Remove all that. Because normally, you evaluate some condition. And then when the condition is evaluated, this returns a Boolean. Under the, under the covers, I would say, for example, you could say in E equals to four. And then we could say end. j equals to three, omit that. Okay, so we have two primitive data types of the end, which are introduced in a form of video. And then I can compare those values. I can say, I mean, of course, as well as with the Boolean is it's obvious. But I mean, in a big program, it's not so easy. Normally, one function calls the other, and he would like have the user typing in nature. And then you don't know if the user typed in four, three, some in this is a really stupid example. I think we know that four is bigger than three. But let's assume that we don't know. And then I could say, if i greater than j, then do something. Else. Do something else. I mean, here, it's again, you can say ELLs, if you could say if j greater than I, what else can we say, oh, if i equal to j, which at the moment, of course does not hold true. This, by the way, you see there are two equal signs. The reason is this equal sign we use here when we assign the value of four to i, or j, so we can't use that again. Instead, in Java, here use two equal symbols to express I want to have a Boolean check. And what you also can do so so you see the result of this will be a boolean value, you can assign that boolean value are equal to a boolean variable. And this is actually quite often very smart. I mean, here, it's very easy to understand. But sometimes you have way more complex terms. And then if you give it a name, your code will be much more easy to read, because now you can say are equal. Okay. And then there is also greater or equal, smaller or equal. And then also unequal, which I will usually I'm typing like this, but it's actually the same. So not equal, you can say with the exclamation mark equal, or with greater, smaller, like this, it's both the same thing. I really prefer that one. I think it's more readable. Because this is like, exclamation mark, really easy to read. And with this, you can also whatever condition you have, if this no holds true, when you put the exclamation mark in front of it, that is false. If this before was holes. Now it's true. Thank you can even Yes, you can, you can add any number, exclamation marks, and every time the value is inverted. So from to false than true again, and false again, and so on. I mean, this is not really readable. So I wouldn't do it. Just to be complete. I wanted to mention this as possible. Okay, on. I think this pretty much wraps it up. We talked about Boolean. This is a condition. If it's true, we execute code that is in here. You see it can also be empty. I mean, it doesn't really make sense. I mean, I would really recommend you to write something, execute some method. You can also of course, you don't have to have an method in here, while again, I would recommend it because it might be much more readable. But in here, you can also do crazy stuff like i equals to eight, for example. J equals 299. So you see, now we have actually some code or plus class, the increment operator that I talked about, I think it was in less than five. So if j with three before, when this is executed will be four, or minus minus, it was three before it will be two. Okay, so you can have 30 Booleans. And here, what you cannot do is compare a Boolean to another data type like int, amin, this wouldn't really make sense what you can do, but, and this really, a lot of beginners do like to compare a boolean value let's make this Monday again. Monday. True. And now you could say, if Monday equals to true, what does this mean? I mean, this means if true, equals to true. Of course, this works. And if this was false, if false equals to true, false does not equal to true. So the whole thing is false. But I mean, this is one comparison too much. To say, if Monday, this is enough. Yeah. But really, comparisons like this false or true. I really see very often in code. So if you see that, you're free to refactor the code, and just shorten it. If it's true, then just say, if Monday, if it was, if Monday false use just say, if not Monday. So, see, this is not. Okay. Lesson eight, I would like to introduce you to loops. This is really exciting, because it's a very cool feature. It allows you to execute a repetitive task much faster than any human could do. So this really makes our programming very powerful. So it's very important to know how to program loops. So there are certain different types of loops. The first one is a for loop for because it says like, for a number of times, execute something. So this is why for and then sorry, this writing here will be a bit cryptic. I'm sorry. The reason is because this loop is really also a very old loop. That was also introduced before Java, actually, I think it's, for example, is part of C and c++, which are much older than Java, actually. So and when they invented Java, they just took over the same style. So this is why it's a bit cryptic. So we have three sections here. Let me first of all, type it and then explain. So this the three sections that this first loop usually has, which means First of all, introduce an int, and assign it a value of zero. calling this variable II, I sorry, is like the default, because I just for integer because the guys that invented programming, are sometimes also mathematics, mathematicians. So yeah, they really like short variables like AI. And it's so it's so common. I also used AI, but you could also call it like culture. It just that people would expect you to call it AI. In this type of loop. It's mostly always called AI or just why are some some variables short, just one letter. Okay, anyway. So this is our counter variable that defines how many times we want to execute a certain statement. Our statement that we want to execute is actually that Create a person object. And we want to do this four times. In programming languages, again, mathematicians, they're to blame. They don't start with one, but they start with zero. So if we want to execute it four times, we have to make sure that we stay that I stay smaller than four, because from zero to three, this is four times. And each time when we are finished at the end of the loop, I is incremented by one, see, this is the plus plus. So afterwards, it's incremented by one, and then the next round, it will be one, one is smaller than four. next one will be two, two is smaller than four, three is smaller than four, and four is not smaller than four. So for the fifth time, the loop will be exited. And so afterwards, the court will be here, the cursor kind of, and we will not execute it a fifth time. So I copied this into the for loop. And then this should make sure that four persons on the fly are created. Actually, because this variable is defined within the block, we cannot access the person object anymore in here, I think I showed you this, see it's red. This is about the visibility, what we could do is we could put the definition of the variable up here. This way, we can still access person one, but actually only the last one because the variable person will always be overwritten by the next one. I mean, for this little test here, this is okay. Because all we want is we want to calculate the number of times the constructor was called. So this works, as well as we could also define person in here doesn't make a difference. In our case, because this is a static method. We talked about this in the earlier lesson. So now, let's try that code. And it's green. Now let's try it to put the time here. This darkness does not work. Because see we expected for but actually, there was 10 times the person constructor was called because this is 10 a year. So this is how the first loop The for loop. The regular for loop usually looks to define an end, you give it a one letter name like I, you assign it zero, and then you compare it to some max value. In this case, 10. Before we head for so that the test is green again, you always have to separate these blocks with a colon. And then you increment i by one. You can also do any other statement in here. Like you could say, I equals i plus two. Which will then let's see. So I'll assume something. See now we only created two persons, because each time it was incremented by two, which means the number of times that we were going through the loop was only half the number of course. And if we add four or even I don't know 10 we will probably only executed once. Let's try that. Yeah, see actual one. Okay, so usually you could put any statement here, but the default is to just increment a counter variable by one. So, release. Try to stay with the default and do it like This, I could even further tell you crazy stuff. Like you don't even have to do all this can have this empty. This now would be an infinitive loop, you can try this at home, because this will, like probably crash your PC because it will create lots of objects. Um, but it is valid. Okay. But this is how it should usually look. So anyway, let's go to the second loop, which is the while loop, while some condition holds true, execute. And each of these loops have their specific reason to be used. I mean, actually, in theory, you could use always just the one loop like this loop or that loop, it just that when you want to count something, I mean, this really is helpful. Because it does all everything at once, if you want to do exactly the same code, we have to do it like this int i equals to zero. Well, I smaller than four. And then you have to say, at the end, I plus plus. So this is exactly the same. And you see, it's not so nice and short anymore. So this while loop, you would usually do one, for example, you have some condition that gets dynamically calculated, like we had the function here should drink beer. So if you had some function here, like should drink beer. This is when you would use a while loop. I mean, I have not defined those variables here. But I hope you get the idea. If you have some function that is always calculated, you will use the while loop. And then in here. You could also create person, and you don't have to do this now. Because we assume that this method sometimes would return false. And when returns false, this loop would be exited. Okay, but let's go back because actually want to run it once. And there is a bracket missing. Because I promise you we can do exactly the same thing. So let's try that. Okay, well, this probably will not hold true anymore, because then we have done it eight times. So let me remove that code. Okay. Let's check. Seems Okay. Let's see what j unit says. Okay, seems like this is okay. So it's the same one. And then last but not least, there's also another loop, which is called This is the newest loop because it was introduced as far as I remember, with Java five, this is the most simple and the coolest loop. However I'm sorry I cannot show you this one. Because for this I need to introduce you to arrays and collection which I will do in one of the next lessons. So for now just know there is another loop the coolest one actually. But yeah, so this was a very short introduction to two different loops. Well actually yeah, I could also show you the while loop you can also do it kind of let's say backwards. So you can say do while some condition um the regular while and the for loop I showed you that very common bows, but this one you will hardly ever see because Again, it's a bit more difficult to understand. What it does is it executes this statement the first time, sorry, without even checking a condition. So the condition is checked only afterwards. Of course, we also need to increment. Okay. So what we do here is we assert that number of persons equals to four, well, no, this is, this won't work, we have to sort it afterwards, sorry. So now we create the first person without even knowing how many times we have created, then we increment i. And at the end, we check that I is smaller than four. Let's try this and remove that. See, this also works. Um, this depends on the logic that you need. Sometimes you may use that. But actually, all the three different loops I showed you, they are like equivalent, you can do everything with each of those loops. So it's just the different style. And this depends on what you want to express what's easier for you to use. This you will get used when you're like, did a few months of programming, and you use each of them, you will get the hang of it. What's like usable in which situation. Lesson nine, I would like to introduce you to arrays. Arrays are also a very cool feature of many programming languages. And they also appear in Java. I kind of unofficially introduced them already in the last video, where I mainly talked about loops. And we stopped when I said there is one more loop the for each loop that is specifically designed for arrays and collections. So today I'm going to introduce you to areas at least. And so we can also see the for each loop. And so an array is really like container, a box, or let's say a list. So an array isn't is also an object is a data construct that can hold a number of primitive data types or objects. And as I already said, box, so far person, the way we define it is with these were brackets, which symbolizes something like a box, I think, which is easy to remember, because we will put our persons kind of in in here we could think and because this container will hold a number of persons, I will call this variable persons. Okay, now I say new person. But now there comes something new again. I don't use the regular brackets, or again use the square brackets. This does not call the person constructor. This would be done like this, and should not be working yet there's already a thread on the line. So I'm not calling any constructor here. This is a specific syntax that says Create me an array of type person that can hold a number of persons. And we have to now give the number which is four. That was still a red underline now it's gone. So now Java knows we want an array of type person that can hold four persons same thing we can do with it. And by the way, on a Mac, you have to press out five and six for the square brackets. So in that same way is equals to new end, which is also you know in this primitive but now I say new ends because I'm not creating again, I'm not creating an end, I'm creating an object, an end airy object. Okay. And you can also see that it's an object, because when I put it here, and I'll put down the button, I see a number of methods that I can call. And we are this is actually not a method, this is an attribute, which I can directly access. So if you remember, I think you I said you should have your attributes private, this is accessible, it's not private. So this actually violates that rule. And yeah, so this is also a very old construct, and shows us one place where Java itself violates the rules of good object oriented design, but we just have to live with it anyway. So what this does, and we will use it very soon as it gives us the number of like the the length of the array than the like, in this case for, okay, if this is three year, why intz dot length should return three. And in a minute, you will see what we use it for, let's remove the end. Because I want to continue with a person's I want to feel this error. And the way this is done, again, we need to break it we need a lot of times is I say zero here, oh, I said person, of course this is wrong, we don't have a person, we have only this one object, persons. And the type is person airy. So it's not a person, it's a person airy object. Okay, and here we can say new capslock. person. What this does is it creates a new person object in memory, and puts a reference to this person, which is like a remote control a way to access the person into the array at position zero, which is the first position. Let's copy and paste that four times. Three, four. So position one, position two, position three. Okay. If I would say position four, what you don't have, I would again, get an error, which we'll talk about in detail when I introduce exceptions, which is again, a new big topic. Oh, okay. So, and when you have done that, what you can also do is, you can do crazy stuff like at position three, put the object that is in the person's array, at position, whatever, zero or one or whatever. Right, because whenever you write on every ad position, as it contains a person, it's exactly the same as if you would say, person, my person equals to a new person. So now I created a person. And this object was assigned to this variable to this reference variable. And can also do it like this. So now, this variable can access that object, as well as all there's title. Persons at position three, can also access the same object. So we have like two references to like remote controls to this one object. Yeah, and you can do also the opposite. You can say, my person equals to I don't know something Let's take two persons at position two, which means the object that is at this position, the reference to it will be assigned to the reference variable, my person. So this, my person object now should still be here, if I'm not wrong, I mean, this really gets confusing. So, I mean, I'm just explaining this so that you get the hang of it. But in reality, don't make it too complex, because you see, the more complex the more box packs you could introduce. Okay, so I hope you get the hang of it. Um, one more thing I might mention. Of course, no one forces you to, to really define to set an object at each position. Now, when I left out position one, this position is empty. So what does that mean? What we say is at position one, there is now because knowledge the word like for nothing. So there is nothing, there is no reference. If we access it, we get an exception, because Java will not know what to do. Okay. So that much about now, which we could also specifically do, by the way, we could also now it, it's called, the wrong button. Sorry. Yeah, so now you can also write, so this is like, put nothing here. Or, here, that would mean that the beginning, you have the new person object at position two, later on, you kind of throw the reference away. And if no reference exists to an object anymore. In Java, there is something called a garbage collector, I will talk specifically about the garbage collector very soon, in a specific lesson only about the garbage collector. So this one is smart, and we'll throw away that object, we'll clean up the memory. For us, this is really a cool feature of Java. In other languages like c++, this doesn't exist. And so you have to take care of cleaning up the memory by yourself, which is really not fun. So this is really one of the coolest features of Java. But anyway, I guess I'm going too far, let's make this more simple again. Because what I actually want to do is now I want to take the for loop, and combine that with the arrays and introduce the for each loop. But let's start easy, let's first of all, go to the regular for loop, take that put it here. And now we have let's remove all that all we have is an object of person array called persons. And we have this for loop that may create for whatever in this case persons. And so we will use that dynamically, so because I will change while we go through loop, we'll start with zero will be 123. So, we can say persons at position I this is really a cool thing now, because this means this one line Let me clean this up. So we create each time an object of type person and we put it into the array dynamically add position I. So this will on the fly fill the whole array with persons. And what we can also do is in a different loop but also just in the same loop. We can access this object by saying persons at position I and call some method on it like hello world that we created in an earlier lesson. Um, okay, I think I have not introduced you how to print something on the console. But maybe I should not do this now, because I guess I feel it gets confusing with all this stuff with Aries, but would be handy now to show you that this can print all the name of something for each person. But maybe I will do this in a later lesson. Okay, so just believe me, if we would print that, we could like print, hello, and then a person name for each person. Okay, this is already nice, but it gets nicer with a new loop for each loop. And this is not so much different from the regular for loop. It was introduced only in Java five. And this works like that. person, person, and then colon and then persons. So what this does is it automatically under the hood, it does everything that this for int it does. And now we can also access person dot HelloWorld. Of course, this requires because now we are using it. So this requires that this has already run? Um, let me think. Yeah, so this is only for like reading it. I'm fulfilling it. Now fulfilling it, I wouldn't use it. Because you have to specifically say what you want to do. Because if this is empty, this would also be empty. Okay, so but we can call person HelloWorld on it, and see how much nicer This is really condensed. So this is the for each loop. And the for each loop is like besides areas, there's also other constructs, other container types, which I'll also soon introduce, like collections really a cool topic, because they're even more powerful than just arrays. And so this for each loop also works with these collections, whatever that is. And it does whatever is required. And it also does it in a very smart way. So it's really smart to use that for each loop, not only because it's more condensed, but also because it's a performance and proper way of doing it. Because Java will assist you in doing it. Okay, so I think this pretty much wraps it Oh, no, there is I have I have a not sorry. I didn't know Have I told you. I think I promised and then I didn't do it. Person start length. This attribute which is not private, I think is public. Yes, should be public. This gives us dynamically the four. So I mean, here, we know that it's four. But just imagine what can also be yours, you have a method, which just gets a parameter. And you don't know its size. So you couldn't say four. And so this just dynamically takes the lengths that you need. And as you see in this loop, we don't even need it because this is dynamically calculated by Java for you. Which of course also that's the person that links in the background. At least this is what I assume. Okay, lesson 10. I would like to introduce you to enums. enums and Java represent an enum eration. So they enumerate something they were introduced in Java five. Now, I want to further extend my explanation about arrays because there is one more cool thing and it also makes it easier for us. We can actually even on the fly out five, aisle six, well this is autocompleted id he already PR Since two equals two, and now I do something new, I say curly brace, this is alt eight and nine on my Mac, by the way, and see, there is no red marking anymore. This actually also works. So what does that mean? This actually is a shortened form. And this says there should be an array. And we don't have to say, a specific size, because the size is automatically calculated, because the brackets are empty. This means empty size, that would be the same as saying zero, which, of course, doesn't make much sense. But just technically, it's possible. So and we cannot feel this array. So and we don't have to set the size, this gets calculated automatically. So I'm just copying. I can also put your mouth if I want to, I can also create a new object. My let's call it my personal Sorry, I can also just to show you what's possible define a variable of type person and then assign now to it or talked about now, which is like nothing and put it here. So this actually is the same like that. And I mean, I want you to also see this, what this does is it does not or what is not is, it does not like combine this array and that array. Instead, it says what you have at position zero of this array, which in our case, is this person object. Take the reference to add and the reference, copy it here, which means this position as well as later on, persons, zero. So later on, after we have defined the array, if we say, person to zero, that will be exactly the same as persons zero. Because they both point to this object in memory. All this is a bit complicated, I'm sorry, I hope you can follow me. And I will do a specific tutorial only on memory management and show you how things look in the memory. For now, I just hope you can follow if not, it's not so important. I mean, we're talking here about areas and what I want you to understand is like this is an array and this is a way of defining the array and the specifics about the memory Don't worry, we can go in more detail later. And you will you will understand this very soon I'm sure let's do the same trick again just with a different position. You can actually even do it twice or any number of times can take another one or it doesn't matter let's put this or we can also remove them now put it here. So yeah, you can do what and you can also do it on the fly you can say new person. Now there is no a little difference which is this object that defined here. It sits somewhere in the memory and might error a person's to has a reference to it outside of my array there is no one who has a reference to it, which we can change after we have defined it. We could also say I have not to count 0123456 I hope I have counted correctly if not imagined I had counted correctly. Okay, so I said six. So at position six. We cannot copy this reference and I can say my let's call it secret person. Let's call it just VIP. So my VIP, now I have a reference to it outside of the airy. So I created it dirty on the fly in this line together with the definition of this array. And later on, just for the sake of it, I assigned it a variable, which we then also can use and work on it like hello world, which you can also do is, say, person two at position six dot HelloWorld. So you can really work with the areas at specific positions, just as if you had a variable, it's exactly the same thing, even though it looks a bit awkward. But yeah, you get used to it. Okay, anyway, I think this is a very handy short definition. Because see how much shorter This is here we find just for persons and area for persons. And this was actually five lines. Now in just one line, we have defined an area of six positions, and we have filled it, and this is all in one line. And I think it's still readable. I mean, readability is the most important thing. So it's not about making something short. It's okay to make it short, if it keeps being readable, or if it's even more readable. That is okay. Okay. And I might also already introducing new stuff, I might also introduce you to final final is another variable modifier. We already talked about public and private and static, not final, something new final says are like locked in this variable, I don't want to anyone to poke around with that variable. So if I later after saying final, say this, Java will say Oh, no cannot assign a value to a final variable person to. So this is like a protection. As you see, I have to say final. So this is one more keyword. And this is one key more keyword to read. This is one more keyword to write. And so I would only do it if it makes sense for a reason. And if you have code that is just like here, two lines. I mean, while doing that, I would assume you know what you do, and you wouldn't like put this to now if you don't want to just one line later. Where this does make sense is if you have something like some constant values, some status values, for example, you could have a process a program that operates on some values. And then you want to remember the state that your processes in Okay, let me give you an example. So for this, we will again define an array, but we would do it in the class on the class level, and we would not do it for the objects, but for all objects of the class. I mean, and this, of course, is static. So static, we talked about this already means we have just one of this type for all the objects and no final. So static and final, they're really close friends, they are used together very often. And all that say string because I want to have a string. But actually I want to have a string array. And I said we said the braces right after it so that we see it's not a string. It's a string array and I call it my state values equals and then the curly braces again. And now I can say like pending, processing and processed. I could of course sorry, brackets missing. Add many more. Just for now. I have a short example. So this is what we could do. Something is wrong here. Yes, comma. Okay. And this means now, and I've also, oh, I did something and didn't explain you why I did that. So far, all the variables that we defined, we had in lowercase letters here, use the uppercase letters, and the underscore. This is also, again, a best practice, because like, we would use this static final, somewhere down here in the code. And you see, now the definition is gone, we don't see it anymore. And so that a programmer working in here and knows what you're working on here is static final. So I don't want you to touch it, I just want you to read it. There, therefore, we use the capital letters, and we separate them with the underscores so we don't use the camel case. And then we could, again, of course, iterate through these values. For so let's do the for each loop, say, stream, nice date, or just stayed. And then the curly braces again, we could say, if we're talking about if state has a certain volume, will actually we can't on a stream, say equals, this is not going to work properly. Because the equals is working on on on primitive values like int, and it's comparing the value that is directly in the variable. Oh, no, sorry, I'm going really complicated. Um, I don't know if I, if I'm making it too complicated. But now that I already started, I might as well continue what we have to say for if we want to compare two strings is equals. And so we can compare that to some other value. So we can do it, state equals and then a string, some other value. So this is some that equals is a method that is directly given to us from the string class that we haven't written, but we're using it from Java. And the says, compare this string to some other something, blah, blah, blah. Okay, if they're both the same, we could do something. And then we could do this a number of times for each value. So we had, as far as I remember, something like pending. And processing. And, of course, uppercase and lowercase make a difference here. And I think it was processed, but I mean, this is just an example. So it doesn't really matter that much. So, and then we could do some some something, colo method. And here we would call a second method and the third method and so on. Okay, but actually, this is a lot of code. So there is a faster way of doing that. And this is the switch statement that are also promised to talk about. And second. This string here is also not so nice, because you could change it any time. You could say in here, state equals to love. And, of course with just a few lines. I'm sure no one would ever do that or hope. But he mentioned we only have always see a very short examples. We could have like a very complicated code, hundreds, if not 1000s of lines and we could like call other methods For what is two other classes, and then if someone in some other class, like changes your value, you might not notice. And you don't want that. You want actually to have the value final. But this with final doesn't work, because final only protects the variable. It does not protect the value in here, which you can change any time. And for this, we have the email. The enum allows us to define an enumeration. Oh, okay, oh, let me just remove that. Or we can keep it for the time being. But let's jump over I have prepared here class will actually it will be our enum and it will not be a class. Okay, so far have just said package. For less than 10, I have set less than 10. And now, like you know it with the class, the class we would say public class, logging level, and races. But this time we're not doing a class, we're doing something a bit smaller. And this is the enum. And now this is obligatory, you have to start with the status definition. And it's not a string. So we don't need the double codes that we would have for the string. Now this is really a value and enumeration value, which we define as our email. So we like we like program our own type. And we already program the allowed values pending, had processing. I think we had processed. Yeah, and then we end here. And now we have defined an email. And we can use that. Let's go back to our test. Let's say logging level logging level, or let's call it my state equals to logging level pending. So this is a lot looking like static. And this is already how it came. Because now we can use these static values, we can also iterate over them. But we cannot change this. I mean, we cannot. Of course we can change it. But we can only change it to the allowed level allowed statuses that we have defined beforehand. We can set pending, processed and processing, the order is different but still the same. It can only have one of the three values. We could not say here. something crazy, because it's not a string, we can only use the values that we have defined here. And this is really helpful and makes also our code more readable. Now we can again, iterate through this enum. In this case, it's a bit more complicated actually, because we have to call a method, which is called values. This method will give us something like an array of all the allowed values in here, pending processing processed. And then, of course, there's not a string anymore. We say let me also remove that. And then we can do the same. Now, it's okay to say equals, see this works. Of course, it does not make sense. I mean, a string will never be equal to an enum, but it's perfectly fine. You may compare any object to another object. Of course it makes more sense to say equals dot for example, pending and then here, processing and prose So let's put processing. Here. Let's put processed. Okay? Um, but this is not so readable. And we don't need equals here. This is so cool. Actually, for an enum, we can do the comparison, just with the double equals, again, this does work. Because yada yada, yada. Java DOES MAGIC under the hood. So for now, just believe me it's working. Because this is not an object, this is a static value. Okay. Let's just remove this. Okay. Now, you see, I think it already got so much more readable and shorter. That However, there's still a shorter form, which is the switch statement. However, we will not do this today. We'll do this in the next tutorial, the switch statement, because I think otherwise, it's just too much for one tutorial. Now we talked about arrays repeated the for each loop. Yeah, and I introduced the enum, which has here this values method. Actually, there's much more an enum can do. Maybe I should show you this one. We can also add these brackets here. Let me do this for a moment. And now we can put values in here. So what is this going to be? I'm adding a constructor, which must be private. Let me check if it may be default, but I think not. Well, let's just try it seems to be working so far, but I'm sure it may not be public, yet. This is not working. So default, visibility seems to be okay. Even though I think it's a bit awkward. And now see this. It says the end cannot be applied to this constructor. Because so far the constructor is empty. Because what happens is, this is calling the constructor. So let's put in here, and now it's working. So having the constructor here, you might also see I was kind of lying to you, of course this is an object. But it's just that for specific reasons, I don't want to go in detail, we can still do the comparison with the double equals here. Okay, anyway, so we have a constructor. And let's now assign the eye to some other variable. Of course, you see, this doesn't make sense, assigning eye to eye and we have already had that. This thought I know, of course, I have to define it. And make let's make this private. So now it's working. I don't like it, I want this private, this is just what he would do. Okay. And then I mean, this, this depends what this means could be some code of some form. So let's have a method that returns public code. And this was returned. I. So this enormous, really powerful, is allows us in dismissing to have methods to return something. But it has these static values that we can iterate over and that we can only choose from. You could also think of a traffic like light with like red, yellow, and green. You can also of course have more values here any number. I'm actually you don't have to have the enum in its own file. You could directly on the fly define it in line in a class, I would just not recommend you to do saw, I mean, forever, you're all there is an exception and find out these exceptions for yourself. But in 99% of the cases, you would be better off having it in your own class. So yeah, there's much, much more actually that you can do with an enum. But I think we already this tutorials already a bit long. And I think I want you to digest this for now. We can further extend this anytime, of course. So that's the name. With its constructor and a public method returning the I, you can also have more parameters in here like a string. But if you're if one of them has it, and all of them have to have it, and every parameter appearing here has to appear in the constructor string, some string or let's just say s. You may use it but you don't have to use it. But usually, of course, you would use it as equals s. And then something. Yeah. Okay. So I think that's enough for now. And the next tutorial, I'm pretty sure I'm going to show you the switch statement. Because this is really cool for using for iterating over these enum values, then the code gets much shorter. I am going to talk about the switch statement, which is another conditional statement. Very similar to the if statement. However, first of all, let's recap what I showed you in the last episode. Actually, in the last one, I covered a lot of ground, I think, I hope this wasn't too fast for you. So let's shortly recap. First of all, I showed you this new way of defining an array. So like the traditional, let's call it, the traditional one was this one, where you just said, person, square brackets, persons equals to new person have four chairs with the size of four. So this can hold four elements starting at zero. Well, this needs a lot of lines. And this actually is the short form just with the curly braces opening and closing. And with a comma separated list, you can define an array. And my recommendation is end with a comma at the end, so that you can easily extend the array at a later time. Also, I introduced a new modifier for variables, a final modifier, the final modifier kind of protects a variable for us. So what it does is when in a later line, I try to assign something new. Like let's use this area on top here, this is not going to work cannot assign a value to final variable persons to also we can try to assign now, which is like emptying the variable will also not work. This is nice ish. However, I personally prefer to not use it locally in a method. But instead to use it for static final variables that are used read only and are defined at the top of the class usually like this here. I hadn't said any modifier. So this at the moment is default visibility. Usually I would prefer, like having it private. And if you need other classes accessing it, I mean, this is supposed to be read only. So it would be okayish have this public. However, even better. If you really want to focus on clean code like I do. You could provide a public method returning the string array. I don't know some name. Let's call it states. And in here, first of all, let me finish this we could copy this out Because with a copy if someone else, because the final, what it does protect is as I set the variable, what it does not protect as the content. So it's safer if return a copy of the array. And there's actually a helping Claus, which provides of Java, Java util, which provides some static methods and really have a look, see, we are going to use the copy. But there's also many, many more methods like here for doing a binary search and so on. This is really a big toolbox of methods that you can use, play around with them. And I might show some of them at a later time. For now let's use the copy off. And then we take the array. And we have to state the size, which again, we take dynamically, array dot length, yeah, we also talked about this. But this is dynamically returning the length of the array, which in this case is three, because the array has three elements. So this is really a nice way of generating clean code and returning this array. Also, I told you, it's all in capital letters and using the underscore and not written in camel case, because this symbolizes that is a static final. So in short, you just talk of a static final, because this is how you write it. Okay. Let's go back to the bottom. I'm sorry, so not much about the array. I also very shortly talked about equals, because I had to, because for two strings, like ABC. And you if you want to compare them, you cannot do so with the double equals. This is not going to work, even if it's the same. Because the problem is that this comparison does not compare objects. And this is an object, instead, it compares the reference variable. So equals does work for int three, and then you can say three equals I, because the three is actually in here. But if you have a string, let's make it null for now. In here is not the object or now in here is the reference, which is something you can think of something like a number also will be saved in here. And when you compare with the equals the two equal signs, then you compare this variable, which means you kind of compare if it's exactly the same. So what will be true is if you would say my string equal equal my string, but this usually is not what you want to say. And so when you compare two strings, you have to say equals talking about equals usually in one sentence, you should always also talk about the hashCode method. This is already a very advanced topic. So let me keep this very short for now. It just that if you create a new class, like I created the class person, it's often a good idea all depends, but you might want to implement the equals method in your person object so that you can compare two persons. But if you do, so, you also have to implement the hashCode method. What the hashCode method is and all the details I will explain at a later time. Okay, so that much about the string comparison. Oh, one more thing. I made this now because I also wanted to make a point. What I see very often is people that would write equals like this, my string dot equals and then a static value. This is not so nice, because as you see this Might be now. And then this throws an error. And of course, we don't like arrows. So instead, always put a value in the front, which will never be now, like this string here. I mean, this is ACB, as a roll down, it will never be now. So ACB equals now, we'll just return false. But now equals ACB will always throw an error. Okay. So let's stop here. Then, actually, the biggest part of the last lesson, we talked about enums, which I introduced, I created this enum here logging level, let's go to the class. So public enum logging level, I do find, actually, the name is a bit awkward. Because it's not a logging level, I was thinking of something like info, warning, and error. But then I decided we haven't talked about logging either. So I instead took pending processing process. So this would more be more like a status. But I don't know, let's leave the name for now is just a stupid example. So this is the IEM that are introduced, which is a bit similar to a class, but has some limitations, but also has some features a class does not have. So it allows us to define these static on, let's call them labels that we can act upon in our code. So we can say if something is pending, to this or that, so it's not only more readable, it's also more safe. enon was introduced was Java five. And before that, people would have taken numeric values, like if something is equal to not to zero, or one. But then already people started to calculate these values, this really gets nasty and problematic. And I'm not showing you this because I want you to do it in the proper way. And that is using an enum. So this is really a cool feature. You can you don't have to also introduce a constructor, if you want to have extra values for each enum value. And you can provide methods that would return these values, or do whatever you want, which are also like to make the code more readable, is I often provide I mean, not always. Whenever your code and you design your code, always think decisions through don't make a decision just because this is never smart. So if for whatever reason, then the code you work on, for example, the pending value, and you need to ask is it pending, that it might be nice to add this method is pending. And then you can say return this, which is the minimum and not only the minimum, but the current value of the enum equals equals pending. So if in the code, you have an enum let's do this modern level, still I call it stage or status equals logging level, not take processing. And then I could say if stayed Dodd is pending, which now would be false. Some code would have to be executed. But what I want you to know is only add such a method if you really need it. So it would not be wise to always by default, provide a method for each of these values. People usually get lazy and when they see something is working, they tend to just overuse stuff and they just like I might be I might need this. So let's just ask Method just because no, never do that. Never add a method just because always think think it through, I mean, code lives. And you can always change your code later. And you always can add a method later. So only edit when you need it. Let's say no, we don't need it. So we will also remove it. Okay, I think this pretty much rounds it up. For enums. Actually, they allow much more crazy stuff, like each value could have their own method implementations. I hardly ever use it. So let's not show this for now. I think this is pretty much what you need, usually. And now, let's finally actually go to the topic of this lesson, which is the switch statement. So I think I already a bit introduced it. In the last lesson, I said, we want to shorten this here. So the switch statement is also a conditional statement. And that's pretty much exactly the same, like these ifs here, just in a shortened form. Okay, I mean, don't think about the exact meaning here. This is just pseudocode. To explain you something. Okay, this time, I will not use a for loop, I will directly operate on this state here. And then we can instead of saying if we can say switch, so we are operating on that value here. And then, instead of if we're saying case, so if it's the case that the state has this or that volume, case pending. So this is the same as saying, If equals pending. If you just have one, then if it's of course shorter. But the switch statement is usually used when you iterate through all or most of them, because you have this extra of saying switch, but then the more states you have, the easier or shorter it will get processing case process. Now I mentioned we will have 100 different ones. Let's format this. Now what happens is, I haven't put any method here, and I have not put a break statement here. So actually, what would happen here, now let's put the same method call, I mean, I have not implemented the method, just the method. Imagine this was a method. So for all these three different states, while there is a common reason, we would call this method. If imagine we use a switch statement within a private method, you could also like return a value. So this depends, the difference with a return is when you return something from a method, of course, you also leave the method, while I'm pointing this out is because normally usually, what you want is you want to do something and it might not even return something like printing something on the console. And you would call one method. And in here, you would call a second method or do a second something calculation or so. And here a third one. Now it gets problematic if you forget the break, because what then happens is a fall through this will be cold, as well as that will be cold. So this is really a big source of bugs. Very, very dangerous. So in this case, never forget the break. And if sometimes you'll want to have them together because you want all the three of them for example or to to call a certain method it's recommended to leave a comment false through so that you tell the next program I know what happens and I did this on purpose. Okay. So that much about follow through. And you don't have to set all possible values. You can also leave One out, if nothing is found, in this case, we will just leave the switch statement, and we'll just not do anything. What you can also do is you always have the possibility to adding a default, which will be called if none of the other case statements apply. And then people sometimes say, I don't know, call default method. Well, he, I really want to warn you. And of course, again, we had fall through would have to say, break. This is not so wise. The problem is, I mean, code lives. And who stops the next colleague from extending your enum adding, for example, an error state here for some text, your colleague would just do this would not know there is this switch statement. And now, you implemented the switch statement, you didn't think of the error case. And the error case might need a specific behavior. But now you would also call this method for this new error flag. So usually, we don't want that. So what I recommend you for the default statement, either you don't use it, or even better use it. But here, you would throw an error. He say, I'm not doing this now, because I haven't talked about exceptions yet. We will do at a later time. But this is the place where you would have like an exceptional case. And the good thing about this is when someone extends your income, and someone forgets to extend also, one or more switch statements, you will see this, I mean, you might say Oh, but then my program crashes. And this is so nasty. Well, of course it is. But there is a rule in good design. And this is called fail early, it's always better to have a high severe back on production even. And to have to fix this within let's say, seconds or hours than to have a high severe bug. And no one notices it. Because if it would not throw an error, it might calculate something in a wrong way. But a client might notice this, let's say three months later, and then the problem will be so so much bigger. So when programming, sometimes you just have to be brave. I also see people that try to prevent arrows and like return something, for example, return now. So this is actually just, instead of accepting I have done something wrong. And let's fix it. This is just like putting the problem to the future and making it bigger. So I want you to be brave and throw exceptions and handle them then this is always better. I mean, I'm not saying you should program buggy code. Of course, we should try and concentrate. But sometimes bad things happen. And then it's always better to fail early. And so you you notice the problem and you can fix it. This is always better than hidden bucks. Okay. I hope you got my point. Okay, so also here. Well, if you have an exception, you don't need to break because an exception always leaves the block. But what is important to always have a break, or, like here, we don't have to break, leave a comment for through to tell the next programmer, I know what I'm doing, I want this and Tommy about warnings. One more thing. don't overuse switch. as well. don't overuse the if statements, these conditional statements, you'll see how much the code grows also in combination with for loops and see how many levels This adds to the code. You have to understand this switch. And then there is different case statements or default. And then inside of the case statement, there might be a method called and so on. So this really complicates the code. Same as with the if statement. You have to See what is the condition for me to enter this blog, ha, then this method is called, you might click to the method, you might want to check here. So this all makes it more complicated. And actually, this is also like a, let's call it a relic from the past. This is what we call procedural code. Because it's like a procedure, it's like really, this makes you thinking like a machine, like a machine would switch a state. What's a case this dude that case this do that. But humans usually don't, they don't think like this. And the cool thing about object oriented programming is that the object oriented programming is very close to how humans think. And this allows you to like talk to business guys. And this really makes your code nice. And switch is not object oriented. There are some cases, corner cases where you, it might just be easy and fast to use it, but don't over use it. Really, I mean, there are people that would have maybe hundreds of lines in here, this is just crazy, really hard to read. This is also why I had here method, this is not yet perfect, but still better than just having huge switch statements. There are techniques, for example, just shortly, you could have an object representing the pending state, and an object representing the process state and so on. So they are at once techniques of how to prevent a switch statement. And it always depends, like, what's better? for very small switch statements? It might be okay. Just remember, they are a bit like evil and should not be overused. Okay, I hope I have added enough warnings of switch. And if statements. This is also one reason why I'm only introducing it now. Because I really want you to become a object oriented programmer. I will further continue talking about the switch statement. So I told you that it's used to iterate over the different values of enums enums, which are also told you were introduced with Java five, um, before that, the switch statement also existed, but you had to emulate enums. And the way this was done was by using int values. Um, this is not so optimal. And this is also why enums were introduced, because they're more typesafe. And I would also not recommend you to show to us ins in the switch statement. I think I already said that in the last episode. I even didn't want to show you but now I realized I think I should still show you. Because you will see it sooner or later. And so that you can understand code of others, I will show you, but just try to avoid it. Um, okay, anyway, with that warning, I'll show you. And now let's give it some name. Um, I call it my state. And now I give it some number 42. I mean, this is just an example. And could mean whatever. And this is already your problem. 42. What does it mean? Does it mean pending? Does it mean processed? How do we know? Well, to make it a bit better, they then introduce static final values, which I'll do right now also. So let's go to the top and on the class level. Let's introduce now this is a method. Let's do it here. Private static, final, let's call it processed, processed. Forgot to give it the type of the primitive type int and this is the 42. And we could also have pending so this is like a trick. But you see this is also where a normal use case From. So this is also why in enums, we usually use the capital letters. Okay, because it's a constant value that will not be changed. So now I will give this the name of pending cross cutting, let's call this processing and processed. Now, of course, we need different values, that could be a 40, then this could be a 41. And this would be a 42. And now I can copy that, go back down. And then I can say, my state oops, equals pending. And pending now, I think it was 41. And then I can now switch on the end. And now this is funny before depending was of the logging level. But Java is smart enough to realize, now we're not iterating on the enum anymore, but on the int and s, we also have processed there, as we have named it, it still works. Of course, I mean, just to show you, this is just because we named the variable the variable. So if we processing is not used, called is something then of course, we will have to use this something below here, because now you see pending as red, because cannot resolve symbol pending. Because we're not on the interim anymore. We only int something, the problem is that my status an end. So no one guarantees us that only these three values that we want to use are used. anyone at any time could say my state equals to 300. And then it will not be something it will not be processed, it will end up in the default. See. And this is also a reason why here you should not have regular code, but throw an exception instead. Which we'll talk about very soon, I hope. Okay, so anyway, this is what you can do with an int. And since since Java seven, I mean, at the time I'm doing this video we are, we have Java eight. So when they introduce Java seven, you now can also use strings on my string, give it a name, called also my string. Okay, not used yet. and copy it. And now we can also switch on strings. Of course, something doesn't work because it's not a string, it's an int. So now, I can of course start to use. Well, for example, the empty string or a blank string. I can use, again, something in lowercase letters. And of course, here also I can do a column labels, which then of course, are private, static, final string. And now I call it I don't know. I haven't used pending because here of change it to something. And I will call this pending. But it could also be any anything any string 42 Yeah, whatever. So of course, using that label, I'm only using one now I think you got the point on too far. Okay, so now, that label I can also use pending in here. Um, you might remember from the last session I talked about the fall through, which is you don't have a brief statement here. So if it's this case statement will be the same one as that statement, which will both then call this method and then break is called, which will leave the switch statement. So the court will continue online 122. The default is at the end. It could also by the way, be anywhere else. For example at the top which would not be also a full Through. So if it's not pending or something, or pending is, I don't even know anymore what we put there, I think it was 42. So, in this case, all the threes different cases would call a method, which he or we could have some other method. As always, I'm not going to implement the method. And then we could say break so that for the default, just this method would be called. And then we would end up here, leaving the statement and ending in Wait, where's, see, if I put my cursor at the beginning of the switch statement of the curly brace, I don't really see it ends up here. Because if you have a method, and this is also a reason why you should keep your methods very short. You see, the method seems to go until line 141. And this method now got so big, that it's really hard to see where it starts and where it ends. So yeah, I can't say it often enough, keep your methods short, I would really keep them at one to 10 lines at most. I'm, I'm really happy. If I'm able to keep them at one to three lines. Some say I'm really on my might be too strict on that. But you will very soon see the fruits of your methods are, the easier it is to understand them. And also, the easier it will be to reuse them. Yeah. Okay. But now back to the topic of the switch statement. So you can use it with strings. As of Java seven, you can use it with enums, like I showed you in the last episode, you can use it with ins and any other number types. So far, I've only showed you int. I'm actually there are others. I'm not sure if I should really talk about the others, because they're hardly ever used. They've just the range of the number ranges just a bit smaller. In 99% of the cases you would use it because I mean, it doesn't really matter these days. how large the ranges. So it is always fine. I mean, not but maybe I still show you. For example, this could be a bite. But now this is already not working anymore. Why is it because I have changed it on the string. Let's fix that. So the bite here. This is just smaller than the end. For example, if you put 3000 here, it says this is incompatible, because it's an int because it's too small. Um, yeah, but the three works. But I really don't want to go further in details. If you're interested, you can also read this on the internet. Because all you really need encode in 99% of the cases is the end. So okay, I think this pretty much rounds up the switch statement. So you can use it with a string and an int Oh, there's one data type, which I might show you. That's also interesting. And this is a car. A car is a string of a length of one, while it's not a string, but it's very similar. So it uses these single quotes instead of the double quotes. So if I'm using the double quotes, it's automatically a string. And this doesn't work anymore. Here it says incompatible types required car found string with a single quotes, it's a car. So it's a character of length one one single character. Of course, it could also be a or b. But it cannot be longer than one character. Because then it's not a character anymore. Too many characters in character literal. Okay, so we can also iterate over characters. This sometimes might be interesting. if you for example, parsing a string or what is parsing it's have a string five string equals something. And now you can take each single character, because a string is actually a combination of several characters. And then you can iterate over each character. And then you can switch over this. Um, yeah. This you might need at a later time. So I've also introduced car now and told you there are other number types. I would like to introduce you to logging. Well, actually, what is logging? Hmm. Well, first of all, let's tell you what my idea is. I have prepared this little test here. I have prepared a little class car service. I wanted to process this string, BMW, or Beamer. And in the class, this class so far is empty. My idea is I want to be notified in some way, like a print out on the console into a file, that database or maybe even an email or something. So I want to be notified in some way I want to monitor if someone calls this method, so that I, like later on, can go through all the course and can see if something happened. For example, if my system was hacked, I could go through a file and see what time what happened. And then yeah, analyze it. So that's the idea. And the way this is done, is by logging. So actually, logging for me this word was a bit weird. So I looked it up. Wikipedia is your friend. So let's do this. So logging is called logging for a ship's logbook. A logbook? Is this thing here, you know, of ancient times when the captain in his cabin was making plans, and was writing down at what time he was at which place and what speed the ship was going in that direction. So this is a logbook. So this is already like monitoring the state of the ship. And but still I was asking, why is the logbook called logbook. While this article here have a read just very fast going through it says it. The term originally referred to a book for recording readings from the ship lock. So what is a chip lock, let's click and ship block, also called common lock shaped lock or just lock is a navigation tool for marinas used to estimate the speed of a vessel through water. Interesting, so there's also an image. So this thing here is the shape lock from the end of the ship. And here's even a picture they were throwing out the ship luck and in equal distances they were not in this line in this long line and the faster the boat goes the faster Of course, this chip block is taken away. And by measuring the time they could measure the speed and this was done given by knots. So this is still why speed of a ship is given in knots even today. So here it says ship log and associated kit, the real of lock line is clearly seen. So it seems I don't know this, but I just guess it that it's called lock, because this really looks like a lock, like, like a three strong because it's this huge block. So I would guess that this is why it's called lock. So, this is why the ship lock is called ship lock. And this is why the act of doing like writing something into the lock is called logging. And as a programmer, you can think of yourself of like the captain of the code. And as such when you want to write on events that happen while your program is running, you are logging and this is what we are going to do today. So how is logging done in 2015 and 15 Well, currently you would use SL for J. This is a framework for logging. I mean, of course, you could write your own logging. But this is a lot of work to make it work properly. And this has been done already for you. You can just use this framework. Well, actually, this is only for Sade, well, FSH is a design pattern that we haven't talked about. So two, we could say it like, allows you to use here is how it's used. you import the code, Ork SL for j logger and logger factory. And then, within your code, you say logger, logger, logger, factory, get logger. give it the name of the class. And you can use it with different implementation of logging. Because for many, many years, the most prominent logging framework was log for J. Well, this has changed. At the moment, you should probably better use lockback because it's a more powerful, and it's author is I don't can't pronounce it properly. But I try shakey Goku, and this is the same guy that actually implemented love for J. So he continued with lockback, because he wanted to make logging even better. So today, therefore, we use SL for j in combination with lockback. Because using this sl for j visade. will allow us at a later time, if there is a new logging framework introduced that is even better than lockback, we can easily each switch to the new framework without having to change the code. Because the code doesn't use the code of lock bag. It uses SL for J. So how is this done? Let's jump into the code. Okay, so first of all, I told you, I'm using Maven for the configuration of the dependencies. So here I've configured to use the dependency org. So for j, and lockback, classic. This is actually the implementation of SL for J. And this is the core code of lockback. So you need these three dependencies to get logging in your code. Okay. And then you should also have in source main resources, our file called lockback, dot XML. Here, you can define different things. Well, first of all, you can say, how should you lock where should you lock, in my case, I say, with giving this class console appender, that will result that my code is locked to the console directly. There are also other appenders, or other implementations for logging. So we can also look to the file to the database, to email. And if there's something you want to have locked to that doesn't exist. You can also implement your own implementation, like I don't know, maybe like logging into Twitter in some way, if that makes sense to you. Okay, and this is the pattern, how, when a message is written, in this case, to the console, it should look like so the patterns has, I mean, you have to read the documentation for details, but it's like, give me the time when this event occurred, the threat the logging level, because the logging level is like a mechanism. It's like a grouping mechanism. You can have different levels of logging. This is like a signal of the severity of the problem. Because debug is probably for debugging purposes, use that sparsely. Then there is a logging level info and error. So error you would use if there is an error in your code, info for general information, and debug, just for you know, some debug information. But this really should be used partly because for debugging. You can also use a debugger, like in your ID, or we haven't talked about debuggers either. But yeah, just for now. Now there are different levels. So, in your code, you can then say, I want to lock this on level debug. And here I have defined the package name. And I say here, this, when I'm when there's some logging of a class that is of this package, then I want to log it, if it's debug, I could to also put your error, that would mean only if it's an error, log it. Or I could put here info, that would mean only login, if it's info. info, of course, also, it would include arrows, because this is like more. So debug includes all includes debug, info and error, but error would only log messages that are locked on level error. So you see, this is really makes it more flexible. And you can even have here different loggers for different packages. So we could also copy this and, like have here a different package like Java course two, and so on. And we could then have this on the one on debug and the other one on error. So this is really flexible and can be changed. And here, this is the root level. So like, generally lock on info level just for this package. Log on debug level, this is what it means. Okay, this was only very short. There's much more information, of course, on the internet. But first of all, maybe a week go to our test. And we add the login details here into car service, I put it. So first of all, I need to import a few. Like we saw just before in the documentation here you see my ID, he already helps me SL for j because I said we want to import only SL for j and SL for j by itselves. knows that it should be used, I should use lockback because it will find the dependency of log back classic. This one here. So SL for j is really smart. So we don't have to tell it. Okay, so we say SL for j lager and we say import org SL for j.no. Just one dot logger factory. Okay, a factory, by the way, is another design pattern. At a later time, I will also do probably a course, only on design patterns. design patterns are like best practices on how you should program code. And when you know what a factory is, you will directly know what this thing he does. Okay, more about design patterns at a later time. Anyway, this is what we have to do. And now in our class, we would probably say private final lager. Let's call it log, because it's all log. And then we say logger factory. Get logger. So what this factory does like a factory. This is why it's called a factory. It gives us a logger. And we don't know how is it created on the fly is a longer reused, this is a smart thing and does all the necessary work for us. Now, we should still give it the name of this class. Because this will be used car service class. That sorry, in our log back XML XML file which is in source main resources. As I showed you, I mean, here we have a package, but we can even extend that and lock only for specific classes. So this is the test and this is the service. Okay, so this is how you generally find a logger. Now, in here, you can now use it log. Well actually, it's not static. I might just as well have this in lowercase log dot and in former times, like With log for j, some of you might know it, you would usually say like this is debug enabled. If it's debug enabled, only then log something, log dot debug. And now I could say, processing, car plus input. So the input given in our case, BMW, this will create a string, and then this will be concatenated. together. And all this will be locked, if the debug level isn't able, at the time when the code runs, which at the moment, as far as I remember, it is. So we can activate and deactivate this. The reason why we need this line, I mean, we could also do it without just like this. But this is not so good. I mean, in case of a string, it's not so bad. I mean, all that would happen is this string, and that string would be put together. But you mentioned the string could be really of in almost infinitive lengths. So Java in the background for you, this concatenation might take a lot of time, especially if we have some very big object here, that might internally consists of other objects, and so on. So this creation of a string, as stupid as this might sound can take a lot of time. And, of course, I mean, here, we just have a very stupid small program with just one debug line. But of course, you would log maybe not on debug, but on info or something, or error, maybe a lot of stuff in your application. And like, you could think of 1000s users concurrently calling this method. And then if this only takes, like, I don't know, 200 milliseconds, 200 milliseconds might not seem a lot of time. But if this is done 1000s of times, then this can really consume a lot of performance of your server or PC. And so we would only like to concatenate the string, prepare the string for logging, if this will actually be logged, because if we say log info, but then the logging framework finds out, well, this does not have to be locked, it would have to throw away all the strings that were concatenated. So we had done this without any need. And so this we would want to prevent. And this is why in lock for j, you would do it like is debug enable debug. Or you can also say is info enabled is error enabled, and so on, is info enabled. Now it's locked for j and SL for j However, there's actually even a smarter way. Because you see, this was three lines of code. And this is you can put here, these curly braces. And then you don't have to say plus, but you say comma. So within the framework, the framework decides, well, the user in this case, this would be us wants to log on debug, first of all check is debug enabled for this class. And if so, only then take this input converted to a string if it's not a string already, and only then concatenate this string with this string. So this is really a smart thing now. Okay, so another enough of talking. Let's try this out. Okay, let's check. We have the input given from the process method. And we want to say processing car, and then in our test, we put here BMW or Beemer. Okay, so let's also recheck our configuration file, log back XML. We said comarca spiele. java course, level is debug and the root level is info. So if we no log on debug, within this package, and comarca spiele Java course this is the package. This means we should log it. Okay, let's run the test. Okay, so something happened. Process finished with exit code zero. And here you see at this time, which is now on level debug from this class from this package car service, we wrote processing car column BMW. So this was logged. Okay. Now, let's try to deactivate it. Let's say we only want to log on error level for this package. Let's execute it again. Run. Process finished. On top, this is all information from lockback. When it gets configured? Well, you see there is no BMW locked. Okay, let's change that. We could say the root level is debug. And we could say or, let's have this on, let's have this on debug. And now let's change the package. For example, Java course two. Well, we're not in Java course too. But we are in the package called Marco spiele Java course, which means we should log on the root level, which is debug. So I would expect the test to log again. Let's try it run. And there you see it already. debug, call marks will Java course card service, processing car BMW. So this seems to be working. Okay. And here, again, you see the pattern. This is what's compared. Here, we have the minus that we have set here, minus and then the message, and then this n, I think this is for new line, so that when there's the next lowing a new line will be attached. Okay. And this is the console appender. So this is the console that we can see here, in our ID, if you would run this from the console with like, for example, a terminal here, you would only see it within the terminal. Okay. So let's maybe go back to the documentation, and check this a bit more. Okay, so here, you see, and you should really use read it. Now, I'm just really fast going through it, you can read it typical usage pattern for this is pretty much what we did. And here with the curly braces, we locked on debug. Well, we could also change maybe, after reading the documentation, let's also log on Arrow and info that you see this also works. And here, it's also explained what I showed you binding with a logging framework at deployment time. So it says here lockback Classic, you need this. If you want lockback as the logging framework, which we used. Yeah, so really have a look here and read this. And here you see the dependencies, this is what we did. You can also here you see you can use it with lock for J. But lockback, as I showed you is like the successor for for j and there is also documentation of lockback which should also have a look, by the way again. So the author is chechi Goku, and others. Yeah, so see they they worked on these frameworks for 12 years. I mean, you wouldn't want to work for 12 years and there are at least these three guys. So this is a lot of work and brain power that has gone in that logging framework, which you can use just by configuring it in your code. Okay. Yeah, and you see we have also done it import org. So for j logger, and logger factory, here they made it static which is also fine. And here they log on info level. Okay. And here's the configuration file. This I have also showed you Okay, and there are also other appenders I think I have put them here. Let's see, oh, there's also the explanation you can do it with logger is debug enabled, like I showed you, or you see better alternative with the curly braces. Because this is I mean, basically, it's the same thing. But this is three lines. And this like clutters your code easily. And this is only one line. So it's nicer. Because logging, I mean, it's important that you want to focus on the domain, on the business that you work in. And logging should just not be in the way of your business. The business is important thing. And logging is important. Yes. But it's like not as important as the business. So really have a look and go through all the documentation. It really explains this really nicely. Okay. So now, I promised you, and then we should finish already. We can also log on different levels, like you can see error. Well, as, as far as I remember, we're still on debug level. And error is included within debug, because debug is the finest logging level. So this should also look just here, I would expect to see not debug but error. So that we know, well, we would use this in case an error occurred. So that we can differentiate how important some logging event is. Now you see an error. So we would write, oh, some error occurred? Well, in our case, this is not an error. So we should also not log in on error. What else can we use? Let's see, we should also able to log this on worn for a warning. So you would use a warning for something very close to an error. But where no one has to manually interfere, then you could use one logging level. And info you would use for example, when your server starts when your program starts up, just so that the user of the program knows everything is fine. And like here, this is an info level. So we are informed lockback is just starting up. Okay. And here you see now we have one level processing car BMW. So now that we're using one level, let's put the root level to error. And now the package that we're not using as well as the root level are both on error. And it's printed to standard out, which is this appender the console appender which is this console here. Okay, and now, I would not expect to see any logging. And you see, just the info from doc back at the logging is gone. Which again, we can change. If we say here worn or let's change this back. Here also we can say worn. So now we should see the one locked again. Yeah, there it is. Okay, well, as I Oh, I think I promised you to show you the appenders and I have not. So let's finally go back to Firefox. And see I had it somewhere here found? employee No, this is not yet. But it's somewhere appenders. There, this is easy. Chapter four appenders is really a good read. So I'm really fast going over it. So outputstream appender, console. appender. This one we used. File append Not this one is of course very important to write into a file and go through it read it. So there you can set the encoding and all these parameters. And there are some really cool appenders like rolling file appender Well, that means that new files are created when like the file is has a certain size or like for every day we could have a new file. This is important for servers because otherwise if we're always writing into the same file, this very soon can reach tons of gigabytes. Yeah. And therefore on production for a server you very often use a rolling file appender so that thing is really important. Somewhere there should also be ODP appender that is supposed to To log into a database directly, really cool thing. And this is really very easy to be configured. Where is it, it was down somewhere. Somewhere, somewhere somewhere, maybe I've already missed it, there is an SMTP appender, I would assume from the name that is used for logging, sending an email when there is a lock event. And somewhere, that was also the DB appender. I know it is SMTP appender, blah, blah, blah, blah, ebf. There it is. So this allows you to directly write into a database, and you see all these databases are supported. So this is really great stuff, and so on, I mean, this page still goes on. So there are really a lot of appenders out of the box that you can use. And as I said, you can always extend it and write your own appender, which allows you to lock to any other source. So that pretty much rounds up logging. I would like to show you the main method of Java. The main method, as the name implies, is the method that is used to start a program initially. However, as this course, is done in test driven style, or TDD In short, so far, we actually never used it. Because we start programming by writing a test. And so far, we use the test to execute our code. Well, actually, as you might have guessed, at some time, when you're done with development, you would want to run the program. And for this, you will need a class that has a main method. So how does this main method look? Well, it's not so different from any other method. It is a public method, so that it can be started from outside of the class. It is a static method. Because we want to run the method without having an instance without having an object of car selector. Because the class car selector in this case here is only the like executer the, like the frame that we use to start our program. And therefore, I mean, we also only need, we don't need further instances of this class. And this is why the method is static has to be static by definition. The method is void because it doesn't return anything. And the name must be made. So that it can be found by Java. By the way, I might notice shortly, I always say noticed by Java. Well, actually, what I mean is noticed by the compiler, because the compiler will compile the program to bring it into an executable form. Well, compiler is a big topic, there are huge books, if not even libraries about compilers that you can so you could even study compilers. So I tried to prevent to keep you away from that topic. But maybe, if I keep talking about Java, executing something, I maybe should now say compiler, and at a later time, I might do a dedicated session on my bit of compiler details. So that you will know more about compilers. So anyway. Okay, so back to the public static void Main method. Now we add the brackets, but actually, they have to contain something, because when we start our main method, we want to be able to give it arguments that the program might need to run and this is obligatory. So these are arguments that come as input as strings, but as there can be a number of strings. This is an area here. So square brackets, and all the name of the string array. You can use any name, people usually would set here arcs. This is what you would see in documentation I usually prefer arguments, because this is more readable. Okay. And then of course, as always, for our method, you would have the curly braces, the opening and the closing curly brace. Um, yeah. And that's already it for the main method. Now, let's leave it empty for a moment. And now when you compile this class here, on the console using a terminal, you can execute this Java class. And it will then call this main method automatically. So this is the place where you like set up your whole program. In the last episode, I created a car service. So we can use this in here, car service car service. But I mean, technically, it also works to run just the empty main method, it will just not do anything. So let me directly say new car service, no title car service. Okay. And then you can call the method, car service dot process. Yeah, remember, and this requires an input. By the way, just to show you what is possible in Java. You can also do all this on the fly, you can say new car service thought process, the only difference is that, you will then just call the method, and you will not have any variable to access the core service. If you don't need it, that might be fine. Well, the only thing missing now is a string. And I mean, we could use any string here, like PVC. But I mean, to make it a bit more interesting, we could no, take the string array. And as as this as this is an array. Of course, we need a for each loop, which are also introduced already. So let's say string argument for one, colon arguments. So this is iterating through our array, that will be given to us. When the program runs at runtime, opening curly brace again, closing curly brace. Okay. That was formatting it. Okay, and now I can take that argument. And so dynamically call the process method, dynamically creating an object. While this is always creating a new object. So I mean, I wanted to show you that this is possible. But of course, it would probably be smarter to just create one object and then put a reference on this object. So this would be from the performance perspective, probably faster. But it's really hard to talk about performance. Because the compiler these days is really smart. It might, it often recognizes stuff. And when before a while it compiles it can optimize your code. So talking about performance is a topic by itself. And you would usually test for performance just by saying this will be fast or slow. You can hardly do but again, performance. Yeah, I could also do a course only on performance really a big topic. Um, yeah. So now I created an instance of car service. And in the main method, I have this for each loop. And then for each argument that is given to our main method when the program is run, we call the car service. Now let's execute this. Because now we can run this without actually a test. Well, I mean, in this episode, I want to show you the main method. But I mean, what I said still holds true, you should always start programming with writing a test. But anyway, see, now I have a run car, see, like the domain. And I can execute the main method directly. Here. This shows me the console directly in my ID. Well, it seems like there's nothing printed. This could either be because in the class, remember, we had the logging, the logging could be deactivated, but so far, I remember it's still active. It should log on worn at the moment. Well, the reason this doesn't work. Anything is a different reason. And the reason is, well, we didn't give our program any arguments. So I mean, this is running, this is not throwing any exceptions. By the way, we will talk about exceptions very soon. But it's empty. So the for loop will actually not be executed at all. When the program is run, so we will directly jump to line nine or 10, just after it so the program will directly exit. But we can change this easily using our ID, I can click on Run, and I say Edit configurations. And here, I can configure how my main class see this also contains always the full package name. So how this is run, I can give it some program arguments. So on the console, that would be car selector, and then whitespace, and then the program arguments. So let me put here a few car names. BMW, or shi. C, Mercedes. Yeah. And then Okay. And then let me run the main method again. And now you see, we have three warning loggings processing car BMW processing card pushy, and processing commerce. seeders. Yeah. So that's the main method. Um, one more thing just really slightly mentioned. What is also possible and not many people know is you can do this. Now what does that mean? And see, all the code is still working. This thing with the three dots here is called a foul arcs. Like a variable argument parameter, which means when this is defined like this, the code, the method that would call our main method, while in this case, it's directly started by the virtual machine itself. This would have the ability to directly put in strings that will be converted automatically by the compiler to an array. So this is very close to an array, but it's like just more convenient for whoever calls that method. Just so that you have seen this would also be possible. The question is, does it make sense because, well, Normally, you would not call the main method directly. So if you don't call the main method directly, it doesn't make a difference. But of course, you can write a test and you can call the method directly. And in this case, it would make a difference because you could directly call the method which just one string? Yeah, but let me talk about Fox arguments at a later time. Okay, so let's re add. Let's make this an array again. Okay. So now, string array arguments. Okay. So that much about the main method, now, maybe a bit of background knowledge for you. So I don't know if my Java course is actually the first Java course you ever listened to? I guess in most cases, you would probably already have heard another course or read the book about Java. And in this case, you might not directly understand why didn't talk about the main methods so far. I mean, this is Episode 14 already. So let me give you the reason for this. Because I really decided to do so specifically. Because this is really a main a main decision for me. Okay, so the reason is, first of all, I think, in the very first lesson, when you have never heard about Java, and its keywords, it's hard to directly be confronted with public static, void. This is just the name of the method would be okay, but public static void, and then even an array. All all this stuff for a very first lesson in Java is a bit much I think. Now in our episode 14, you should by now know what public means What static means what what means. And we have also talked about arrays. So I hope that by now, you can easily follow my explanations, and you understand what all this means. Okay? And then second, also, this is a static method. And I told you, I think various times, Java is an object oriented language, where you usually focus on creating objects, but static, this method is not object oriented. There's just one version of this method. I mean, of course, it might make sense. But, yeah, as you should try to avoid static, wherever possible, I think showing you a static method in the very first Java lesson might lead you to the wrong conclusions. Yeah. And then also, next reason is, um, even though, I mean, the main method is, on the one hand, very important, because you use it to actually execute your program to actually get your program running. For any program at hand, you would have only one main method. And usually programs would consists of hundreds, if not 1000s, of classes. And just one main method. And last but not least, I mean, this counts for Java, se. But if you like program a server application, what you usually do is you don't re implement all the server code. But you would like use, for example, an open source server implemented in Java, for example, Tomcat, and such a server, I mean, has already been implemented for you. And so you use that as like an infrastructure, even though it's software. And so the Java code you write will run within that Java software infrastructure. And therefore, when you program code for server, you usually don't write even a main method at all. So, for example, in my case, I mean, I have programmed in Java for pretty much 14 years now. But I have maybe, I don't know, 10 times 20 times, well, definitely less than 100 times I have programmed a main method, while I have programmed really 1000s of classes, I'm sure. So the main method is not so important. And, yeah, so we started with writing a test anyway. So you are also able to run your code, at least for testing without the main method. Of course, I mean, the tests. For example, let's look at this one. This one is based on the framework j unit. And j unit by itself is a Java program. So j unit does have a main method. Of course it does. But you don't see it. All you see is the test methods that we write. And his test method, they like plug into the whole j unit mechanism, bet so we don't have to write the main method. I mean, this is why just using a framework, like j unit is so handy, because it saves us from writing our own main method. Yeah, and I promise you, you can actually even execute even the main method as if it was a regular method. Now here you see I have prepared that he is an array of string arguments, BMW and Porsche. So this static method is called with the given arguments as execute the test. And yeah, you see, this works just as well processing car BMW processing car pushy. And, as one last thing, maybe you'll see I could change the signature of the method. Like I could say the method returns some end. In this case, just as an example 42 I could even not make it static anymore. I can change it in any way. This is okay as it's a Java method, it just will not be recognized as a regular main method. So this will will not allow us to execute it as a Java program, but our test can still execute it as it was before. I mean, now this is returning something. So we don't use the return value, but we could in return use equals to Yeah. So you see, it's really, we're calling the main method returning something. And we can still call it from the test. But if we want this to be really a main method that will allow us to start a program, then the signature must look like this. Okay, so I think that's pretty much all I can tell you about the main method, I'm really happy that we were finally able to have a look at the main methods. So now, with the 14 episodes that I've done so far, I think this course now really has gone quite far, by now you should really know quite a lot about Java, and should be able to write your own programs by now, I will, of course, add a few more things. But By now, you should really be able to write your own small programs. I would like to talk about Exception Handling in Java. So first of all, let's have a look at some theory, and some background information about exception handling. And then later on, we will as always, directly jump into my ID. And I'll show you how to do Exception Handling in practice. Okay, so as you see, this is the Wikipedia article about exception handling. So first of all, let's have a short look at the definition. So here this article says exception handling is the process of responding to the occurrence during computation of exceptions, and animals or exceptional conditions requiring special processing. Okay, let's stop here. Let's digest that. So, um, I think what is very important is two things. First of all, it is about exceptional conditions. Because in my opinion, this is something that many programmers get wrong. I mean, an exception is called an exception, because it should handle exceptional conditions. So the question really is what is an exceptional condition. While in my opinion, an exceptional condition is something that really, as the name implies, only happens exceptionally which means only really rarely, only in very specific situations. And those situations are an animal's soul. So for example, programming errors, you when your program, you introduce the buck, you forgot to like you have an array, and you have one field that is empty. And I talked about that means it has a field that is set to now. And then when you try to access this field, that, for example, can throw a so called null pointer exception. Well, that would be really an exceptional case, which you wouldn't have guessed it would happen. And yeah, that would be one reason for an exception. So exception handling is really the, as it says here process of responding to the occurrence of exceptions. So something exceptional happens. And then we need a way to react on that to handle that. Some special processing, which is not the normal program flow. But the cool thing about Yeah, this also sent here, often changing the normal flow of program execution. because ideally, we want like a central place that handles the exceptions. And so we want to leave the normal program flow and we want to just specifically take care of this exceptional case. Okay. And here continues, it is provided by specialized programming languages, which gives us a hint, it is not provided by all programming languages. Well, let's have a look at the history which will tell us. Yeah, software Exception Handling developed in Lisp in the 1960s and 1970s. Well, I think the first programming language was invented by Conrad Sousa in, like 1943, or something. So you see, it took a while until they finally came up with the idea of exception handling, that something like this is really necessary. And, well, maybe a bit more about the history and Java, because again, with Java, there was some something new introduced, and that is checked exceptions. Before all exceptions were unchecked, which means any line of code can throw any kind of exception. And there is no mechanism that forces you to handle it, if you don't handle it. That, for example, causes the program to stop. And well, therefore, as soon as exceptions were like introduced, many times nasty things happened. And so when they invented Java in like 1995, or something, they thought, well, maybe we should do this a bit better. And well, first of all, let's have a look. Check the exceptions here. The designers of Java device checked exceptions, which are a special set of exceptions here. Okay, and to make it short, so what's the difference about checked exceptions, he is also already an example and i o exception, which happens when there is a problem with an IO operation input output operation. The difference with checked exceptions in Java is they must be declared explicitly in the method signature, or be handled. If you don't do that, you will directly get a compile time error, which means you're not able to even compile your program. I looked at actually up I think it's here it's quite interesting. Like how it came with the checked exceptions. The Java programming language introduces the concept of checked exceptions, checked exceptions must be handled in a method, or the method must declare the exception in our throws clause. Now it continues, I think here it's even more interesting. According to Anvil wrath, who was there at the beginning, the credit for the Java exception scheme should mostly go to Jim Waldo. And then they go on. And here after some consideration, Java was retooled to have checked exceptions, only those exceptions for which there was no recovery, or reflect application errors would be unchecked, and the world was safe again. Well, so they thought. Now, in the meantime, it's 2015, which just like 20 years later, and it turns out, that was not so smart. Because the problem is, and this is also why stated at the beginning, maybe we should go back to the very top. Exception handling is the process of blah, blah, blah, blah, blah, blah, blah, exceptional conditions. And this is the important part. Because they had the idea to have still unchecked exceptions for something like programmer arrows for something that is, as the name implies, exceptional, and to have the checked exceptions for everything else. But now I ask, why have checked exceptions for these cases that can be handled? Why not? If you if you can handle a specific situation, why not that instead validating that situation? And not at all throwing an exception? And also, and now maybe we should already jump into the ad because I guess it goes too far. on too much theory. Let's directly jump into the code. So yeah, so here you see An email that I've written car stayed with a different states driving, waiting and parking. I've written this public static from method that converts a string to a car state using a switch statement. I told you, in a previous episode, that since Java seven, it's possible to use a switch inside air to use a string inside a switch. And I want you not to do it. This still applies. But in this case, I assume that we are getting input from the console. And input from the user coming from the console cannot be an enum must be a string. So this is all I mean, for every rule, there is an exception. So this is an exception to the rule, which is here, we do have a switch, switching on a string. But now here, we have the default case. And I also told you, I wouldn't, I will only throw exceptions and the default case, so that it cannot happen, that someone adds a new state. And this new state would then be handled by the default case without anyone noticing, to have the fail early principle. And so I told you to throw an exception, but I didn't show you yet. While we can do this now, and this is quite easy. You can just say throw new exception, because an exception in Java is just an A class. Like almost any other class, while it has some specific methods and stuff, but at least it's an it's a class and we create, we can create objects from it. Now, you know, you already see a checked exception and action. And you see how the compiler already wants me unhandled exception. java. lang exception. So this is also the package java. lang exception. And, yeah, this is the number one checked exception. Don't ask me why it's called exception. If it's actually a checked exception, something like a checked exception. I mean, the name was not used within Java Lang. So you just have to know that this exception is a checked exception. And on top, the default, unchecked exception is an is a runtime exception. This sorry, also not my fault. This also you have to know I mean, runtime makes sense, because something that goes wrong at runtime. And so you would normally use a runtime exception for things where you don't know how to handle them directly. And the idea was, as I said before, to have checked exceptions, for cases where you know how to deal with them. But as I said, if you know how to deal with them, why not dealing with them without throwing an exception beforehand, using validation? But anyway, let's continue. So how can we fix that compile time error? One reason is, at exception to method signature, let's use our ID to help us and here it adds throws exception. Now you see the compile time error is gone. Nothing is read anymore, it seems like we fixed the problem. So we told the Java compiler, we know there is a checked exception. We just don't care. The color should take care of it. And now I have this car service class here. And I made it to use the static from method that I implemented. And you see now this class has the problem. Okay, again, let's do the same thing. Add exception to method signature. Okay. And I guess you know, where this leads to. Now we are the main method. And again, we have the same problem. Well, we can notate This is all the wrong stuff. Seems like we're on the wrong line. But yeah, I can no here appears add exception to method signature. Okay. Well, sorry, I'm just lazy. I could of course have written that myself. But whenever you write something, you have the chance of introducing a typo like this. So whenever possible, I prefer to have my ID he helped me and to have code written automatically by the ID that can save From introducing bugs with typos for example. Okay, so now this will be, like fixed. But now the question is, what did it help us, we have here throws exception, we have here throws exception, and we have here throws exception. So three times we had to add this throws exception. And only because Java tells us this is a checked exception. But besides, we didn't handle it, which means what will happen when I execute the code, and the default case is chosen, the exception will be thrown, it will be Bob, it will bubble up to the top to the main method. And as the main method doesn't handle it, the program will stop. And we will see the exception stack trace. Yeah, same thing we could do, for example, with a runtime exception, throw new runtime exception. Also in in both cases, you can and you should add some meaningful message that tells us why the exception happened. So let's say on state, and concatenate that with a given state. Oh, okay. So now, I can still keep it. But I don't have to. It's not obligatory anymore, because this is not a checked exception anymore. Same here, I can remove all these. And this. So now I have exactly the same code. The only differences I mean, I'm not handling the exception, that my method signature doesn't get any longer. Because he mentioned again, I'm always bringing this example, you have a huge program of hundreds of classes. And as soon as one method has that throws exception, this is really contagious, which means another method, sooner or later, we'll use the method that says throws exception, will then also have to say throws exception, this method again will be used. And sooner or later, you will have that throws exception in each and every method. And then it doesn't help us at all. It just makes the code more wordy, let's say. And yeah, it's not really meaningful. So anyway, let's first of all provoke that exception that we see how such as exception stacktrace looks like for this to happen. I have to call the main method. And I have to give it some some argument that we don't know yet. Okay, let's go here run. I think I have prepared something already. Edit configuration. And yeah, flying parking, driving, driving ABCD E, F, G, because also, I wanted to show you, I mean, I've introduced the main method only in the prior episode. So here we have some valid states, as well as some invalid states. Also in lowercase letters, it will should be invalid. And as we're iterating through the arguments and a for each loop, we should see. Well, let's just let's just do it. actually still have to run it. And let's have a look what happens. Okay, so you see, the exception happened. I'm on state flying. So I would assume the reason is that this happened for the very first time the first argument was already flying. So this is our program stopped. This is the reason because it's not handled. Now, we could also handle it to show you what's the difference. Now the question is where to handle such an exception? Well, always as early as possible, like at the class that can do something about the exception. In our case, um, I just defined that. In the case that I get a wrong argument from from when the program is called as an argument. I want this to be printed to the console, so that the user knows which means I mean, I wanted to be printed here, which means the first place where I can handle this exception is only here on the very top. And so there is this new construct, I say, Troy, which is like telling the compiler, I know something evil can happen. And I just want to try it. But now I can say catch. And I can catch this runtime exception. Usually, I mean, I don't like really short variable names, because they're not readable. But in the case of an exception, because an exception log is always very, very short. The default is to call the exception for with E, for exception. And I think here, this exception is okay. Because we don't want too much with the exception, and the block will be so small that everyone knows the E is for the exception. Okay, so curly braces. And now we can do various things. First of all, we could say e dot print stack trace. Well, this is actually exactly what we have here. This is the stack trace, the stack, you can think of as a list of all the methods that were called in reverse order. So here you see main process from can also jump there. I mean, this is not, this doesn't hold true anymore, because I've no edits code. But at the time, we executed this code, and the exception was thrown. This told us exactly in each class, where the exception happened while he is still true. And he also, but in my car selector, I have adjusted the code, by the way about this. The fact that I've adjusted the code, also, when you sometimes have a stack trace, and you need to analyze where it came from, this is really often happening, that the code that is running on production is older than the code that you develop on, because of course development continues. And then you can only find out the exact place where the exception happened, if you keep the exact same code that you have running on production. Yeah, but this only really, I don't want to go into more details. Um, this would be a topic on its own, again, about revision control. And this is really a huge topic. But yeah, just that, you know, the stack trace is really helpful if and only if you have exactly the same code that was implemented at the time this code was running. I mean, that they're both in sync. Okay, so print sectors here wouldn't make sense, because in this case, it's just the default anyway. But this can be used. And it's often used to lock for example, in I don't know, was it Episode 13? I think I talked about logging. And so when you want to log an exception, you can do it like this. This is usually how you do it. Well, I haven't got the log class here. And I don't want to do log error or log one you will say and this depends error only when there is something that has to be done. For example, a database that has to be restarted. In other cases, probably one is also okay. Okay, message is the string that I added into the constructor of the exception here. And I have removed the stack trace, because this is actually done inside of the log object, which I want to add. Now. If you want to know more about logging, have a look at my episode 13 where I explain logging in detail. Okay, so logging is one thing we can do. But in this case, I say I don't want to log it, I want to directly printed on the console. I think also in the episode about logging, I want you not to do it always to prefer logging. But in this case, let's assume we have just a very small program only be used to run something from the console. And in this case, it can be okay to just say system error dot Clinton. Which I also wanted to show you once print ln For new line, and here, then I can say dot get message. Or I can also say e dot print stack trace, which doesn't make sense, because we already have that. So to alter the behavior, let's do this. Okay, let's run it again. Now, you see something else. You see the program hasn't stopped. But instead we see unknown state flying Unknown, Unknown state driving an unknown state abcdefg. Yeah, so all the invalid states were printed out. Without we don't even see the exception anymore. And it's red, because I use system error Clinton, I could also use out print on because this is a special channel, only for errors. And this is printing in general. See, now it's white. But really, I still warn you don't overuse system out or system error print on. Because Yeah, you can't configure it like you can configure logging. So in 99% of the cases, using a logger is better. Anyway. So let's have a look at the code now and think is this really nice. Now, we have a for loop, we have a try, we have a catch. Um, you see a lot of different hierarchies and a lot of different levels that we have to understand. And this is something I really don't like, this makes the code quite complicated. Okay, so this is something you should try to prevent. And, anyway, I can also, alternatively show you, we could do exactly the same. If this was throwing an exception. The only difference is that if we're not handling it, we have to add the signature throws throws. So yeah. Maybe also, I should now show you the alternative. If If we don't want to add the method signature, the exception signature, we can directly in here, say catch and then handle it. And then I mean, handling an exception does not necessarily always mean you have to print it, I mean, printing, it doesn't really solve the exception, it might be even better to really have a method that does something about the exception, and which I call no handle the exception. The only problem with that is, and I'm not implementing the method now. And this is what I said before, I'm the case that you're really able to do something about the exception, which in this case, I mean, what could we do, if the user typed in something wrong? There's not much we can do? Well, there is one thing, we could for example, ask the user to type in to fix the state he typed in. But this we couldn't handle here. So again, if we want to, like ask the user to do something about it, I would instead validate the state. So let's remove all that. Let's for the time being I add the runtime exception, but I will change it very soon, because now instead, I want a validation at it. And this can be done in the following way. I remove all that trycatch instead, I say Valley date argument and now I can implement that method. Create method validate my ad he helps me again. I'm now well actually I want to say is valid with a Boolean returned. Okay. Now, you see this is also interesting, by the way about the main method because this method is static. Also, this Method automatically esthetic. So because when this method is static, a static method cannot call a method that is not static, because an instance method can only be called when there is an instance. But for the main method, we won't create any instance, of course selector. So for this reason this is static, and it's private, because we don't need to call it from outside, only the main method will call it. Now how can we validate it? Well, for example, we could use a method directly provided to us from the enum class, and that is value of this is not implemented by us. But it's implemented, like automatically, when they implemented when they invented the enum and Java, this is one method that you get for free. So this will directly try to convert your string to an enum. So here I can say car stayed. Cars date. So this actually does exactly the same thing. Like our switch did. So actually, we won't need it anymore. Very soon. The difference to the method that I implemented is or bill, I did it actually also like this, when the conversion doesn't work, this will throw a runtime exception, I think, an in because they have different types of runtime exceptions. And I think it will be an illegal argument exception to tell us the argument that you are giving that you are giving to me, sorry, is invalid. But still, it's a runtime exception. So and because this will throw an exception, we have to add the try catch block here, because we want to handle this. Try catch. And then I say runtime exception he or I hope I'm right. I can directly say in valid on invalid human exemption, there it is. I think that should be the one if not, we will see it because the exception will not be caught. Okay, and then here, we can just return false without logging anything. Now, let's see, this is the wrong one, because we can't catch an exception that is never thrown. So invalid. Let's see what the lead catch. Now this is not what I want. Maybe it's an invalid state exception. Yeah, this works. So see, this is also how you see this value off may throw an invalid state exception if the argument given is unknown, in case of, for example, flying driving ABC. Okay. And to be honest, um, I think this is also not optimal, that we only have this value off method, I think it would be much, much nicer if the IEM base class will directly provide is valid method just returning true and false. But again, seems like the inventors of Java doesn't didn't listen to my opinion, crap, just making a stupid joke. So for this reason, we do have the exception, but we are able to convert it. So because we converting it directly. The exception doesn't be doesn't pollute our whole system, let's say like this. And we can now say here, return true. Which we could also put at the end of the method. This is exactly the same. Yeah. So wherever you have it. So and this is also the jump. I mean, imagine you could have lots of other code like system out print owns and just print something. So you could have many, many more lines. That would do lots of stuff. Let's just copy and paste that to show you many more lines. We could even reassign car state to something else. Let's just say now. So what happens if This line of code doesn't work out, because the argument is unknown, for example, flying. When the code is executed, the execution will jump from here, directly into the catch. So this is leaving the normal program flow, the normal program flow would go from line 2122 2324 25, and so on. But here we're jumping from line 21. To line 28. Yeah, and this is helpful, because, for example, imagine we have done this several times, for examples here. And there, even maybe in sub methods, then we have just one catch, that would handle all these different places where an invalid state exception could happen. That's the idea of exception handling. Okay, just to give you some more details, actually, I don't even need that. So I would remove it. We're only like, abusing that volume of method to have the information. Is that valid or not? Okay, and now I can react on that. I can say if not valid, or I can say only, like, only process it if it's valid. Yeah, maybe let's do this. Because you saw already hold the invalid states are printed. Now let's do something else. Let's only process valid arguments. The question, of course, is, does that make sense? Now we wouldn't even realize we have a problem in our code. So maybe we should also say else. Print that we have problem. system error dot print. ln M. invalid. argument given? Or let's say ignoring, ignoring invalid argument. So this, by the way, whenever you log, I think I'm not repeating myself, because I already talked about logging, but I can't say it often enough. Always add as many arguments as possible, so that whoever is responsible for a problem knows why this happens. Otherwise, yeah, it's really hard to understand why something doesn't work out. Oh, no, we still have an illegal argument exception. How is that? I don't know. And this is interesting, because we can now check. Like, this is what I told you. It's in car state. There's, ah, we still have the from it seems like we call it somewhere. But no, I'm wrong. Because the session line five, so this is not yet. Car state. Illegal Aha, this is why See, I was wrong. This is the invalid state exception. And what is actually thrown by Java is the illegal argument exception. So see, this is actually what happens most that we see it. No, no constant flying. So this is what Java gives us. It throws an exception. And this now we will catch. Okay, let's retry. See, this is how everyone introduces sparks. And this is why we need tests. Today, I'm not doing a test because I just want to show you exceptions. But yeah. We do need tests. Tests are very important. Okay, now it works. See, ignoring invalid argument flying ignoring new argument driving, ignoring invalid argument abcdefg. And the valid argument was processed. It just didn't lock just didn't do anything. Which of course we can change. Here we could say system out print. ln, again, this thing here is evil. Only use it in very rare situations. Yeah. I can say bellet. Stayed. Car stayed. executed again. Yeah, so you see three invalid states and two valid states. Okay. So of course, I mean, this was just an issue. Sample Normally, you would have some method doing something about the state further, do something with the car state. I mean, I'm just making this up, because all I want to explain you is exception handling, but I hope you get the idea. So anyway, there's one more thing. And then actually, I would like to, like, shortly recap the important points of exception handling. And the missing thing now is, oh, by the way, let's remove the from, because I showed you, we don't actually even need this anymore. Okay. Because what you can also do is finally, finally, this is very important, not in our case, now, I'm just making some something up. Finally, as the name implies, this is done. Finally, at the end, no matter even exception happened or not, this block will always be called. And this is important. When you have resources, when you have input output operations, or in short I O, which you have, if you communicate with a database, if you read something from a file from your hard disk, Yeah, something like this. Because when you like read something, especially from external systems, who can tell you that the external system is actually available, or like the hard disk could fail. And so with i o operations, there's always nasty stuff that can happen. But there's one important thing, which is, for AI operations, you need resources. And so you have to close them. In any case, otherwise, you really could have a problem with more and more resources lost. So yeah, this is a big topic, I can't explain it in like a second. But all I want to tell you for now, this finally is very important when you deal with IO operations that might fail. And in this case, you can close these resources and close resource for now I'm just giving you my resource, this stupid method. You can implement that yourself. But also they are very cool. Helping utility classes found on the internet, open source. Like for example, I Oh, utils. Oh, it already find something. But this is not the one I mean, the one I know of is for example, I think from Apache, and they will have something like close thing silently or so close resource. And then this will do all the nasty stuff for you. Okay, I'm stopping here, what is important is, and this I want to show you just by printing something system out, print, ln. And I will throw the exception again. Which means what you can also do is you don't even have to catch it. This also works try and darkly finally. Okay, formatted the code. So, now with the invalid argument, our program will be stopped, execution will be stopped. But in any case, let's say I am still running. And I can also show you this line will not be printed after exception. Well, it might be that this runs once if the first argument is a valid one. Because with the string airy, we never know for sure the order is not guaranteed. But so that you see, I would whatever happens for this vote for every time we call is valid. This will always be printed. So let's see what happens. Okay, oh, something's still wrong. Not Found. Yeah, because we have removed the from Yeah, sure. Um, so let's for now remove that. We at the moment, don't need it. And see, this is again, the reason why we need tests. I'm really doing some nasty hacking at the moment. Okay, and you see, I'm still running And then the exception comes. So this is what happens when the exception happens. We didn't catch it. So we see the stack trace instead. But I'm still running is printed before that. And this is the place where we can do some cleanup operations, like closing resources. But you could do anything in here, basically. Same thing, if we catch it, catch is a runtime exception, runtime exception, because it's also a runtime exception. We should talk about inheritance very soon. So that I can go in more details why that is. So now what is wrong? Yeah, we need the closing curly brace, and one less of this. So now we can say, oh, maybe I just have I will also show you print stack trace. So this should actually do the same. And now I will say, system out. print on. Hello, again. So you get an idea. In finally block. Oh, okay. Oh, no, something weird happened. And this is for all the invalid states flying driving. The stack trace was printed. And it's red. Because, yeah, it's the print stack trace. So it's printed on system error. Okay. And you see, this is the illegal argument exception, the first one, the second one, and so on. And you see at the end, hello again. Which comes after the whole stack trace. Yeah. And you'll also see this line will not be printed off to exception. Because it seems like I mean, we had different arguments in here. So for the valid ones, this line was printed. And you see also, I mean, now I'm really having a hard time knowing why this happened. So again, I violated my own rule. I didn't add the argument. So here I can say, our arguement. I say valid argument. Yeah, because if it's after the value of if this is printed, it means the exception did not happen. Now, let's call this again. And let me also remove the stack trace for now to make it a bit more readable for us. And let's run the main method again. Okay, see now it's more readable. So what do we have here? Hello again. So the runtime exception happened. And, again, I did not add the argument. In this case, I can also say get message, which gets us the message of the exception. I'm not sure if our illegal argument exception has a message. But we'll try this. Yeah, see, this is the message Hello again. And the message is no II non constant car marktspiegel car stayed flying. So now you see he can understand the problem so much better. And after this we under finally block then comes the valid argument parking. In this case, we're also ending in the finally block. Then comes a second valid argument. Also in the finally block. Here again comes in invalid state thriving, but we're also in the finally block. And the last invalid state also in the final block. So the finally block is always executed all K. I think this pretty much rounds up everything I wanted to tell you about Exception Handling today. Now because this was quite a lot. Let's go Shortly through the most important gotchas, okay, so, in Java, there are runtime exceptions, which are unchecked exceptions, unchecked means they are not enforced by the compiler to be handled, you can just throw them, and also Java will throw them for you. For example, a very famous or infamous exception is the null pointer exception, you should never throw that yourself, Java will throw that for you, if you try to access something that is at the moment now, just now for the exception is probably the most famous exception, because when it happens, you will not be very happy. Okay? So unchecked exceptions, or runtime exceptions. And they can happen at any line, because any line can also be null. And they don't have to be handled in code. If they're not, then in the worst case, the program will stop, like we saw before, because the exception will bubble up all to the top. And if it's not handled in here, the program will stop. And it will by default, print the stack trace. Then Java was the first and actually also the last programming language that introduced checked exceptions. Checked exceptions are exceptions, that are enforced by the compiler, that you do something about them, or you add a throws with the exception name. In your method signature. There are various checked exceptions. One of the most famous ones is probably the i o exception. That will be C, it's in Java i o package. This one will be thrown if you have any problems with i o operations, which is again a topic on its own. Okay, um, and I said Java was also the last programming language that introduced checked exceptions. So this really shows us indicates us that checked exceptions were not so smart. Because you see, all they help us in the end, is they add noise to the method signature. And the case that to use them for cases that you can handle them. Well, I say, if you can handle them, why not taking care of the problem beforehand, for example, by using validation, validating the case, the given argument, and then handling that without actually even throwing an exception. And then maybe last but not least, for every rule, there's always an exception, we saw that. I've removed it, unfortunately, yeah, let me go back. We saw that with the switch on the string were set in a prior episode. Don't do that, while I did it here. And, um, we also saw saw that here, where I use the value of method of enum, which throws an exception, and I said, Well, we're trying to validate it. So if we are validating as we don't need the exception, it just that we can't do anything about it how the method was written by the inventors of Java, so we just have to live with that sometimes an exception is thrown where we will just validate it. But what we can do is we can catch the exception and then return true or false, for example, so we can convert the exception into a valid return value. Also, there is a hack. If you have a library, like an old library that will still throw a checked exception, like an IO exception. What you can always do is you can wrap we say wrap a checked exception into our runtime exception. And this is like this. Let's create more ioexception Let's create an ioexception shortly. So see, you can also just create them like any other object. And now on that exception while it cannot be called IE because we already have that I can now say throw new runtime exception and okay. Give it the IO exception. And this is why we wrap it. Because we put this exception into the constructor of runtime exception, which means this is the wrapper, it wraps around the other exception. And now our compiler will be fine. Because we're not throwing an IO exception anymore. We're throwing a runtime exception. Well, this is a nasty hack. But I think it's still better than having checked exceptions all over your code. And yeah, I'm going to talk about interfaces in Java. Well, interfaces are probably the most powerful feature of object oriented languages. Well, before I continue, first of all, some organizational stuff. So this is divided into three parts. Part One, I will first of all, talk about the definition, what does actually the word interface mean? And tell you a bit about the history. Like how were interfaces introduced into Java. I'll make this part as short as I can not to put you to sleep. And then second, we'll jump into my ID, he will do a short coding session, and I'll show you how to practically use interfaces in Java. And then last but not least, I'll do a short discussion about the pros and cons of interfaces from a clean coder perspective. Okay, so let's start to jump into the topic interface. So what does interface actually mean? So I've opened up the dictionary page. And the definition is an interface is the point of interconnection between entities. And interfaces do not only exist in programming, but also in all other kinds of areas, for example, in chemistry and physics, and there is defined as a thin layer or boundary between different substances. And I think this perfectly also applies to interfaces in object oriented languages and Java. Because it's really a very thin layer, you will see, there is not much code needed to define an interface. And it also forms a boundary. When I say boundary, I think of something like the Chinese wall, which was a big protection from the hordes that were invading from the north. And this is also what an interface is, it can protect a class from other classes, but more of this later, okay. And then maybe we should also look at the object oriented point of view. So in object oriented programming, it's a piece of code, defining a set of operations that other code must implement. So yes, all this holds true for interfaces in Java. But now, enough of the definition. Let's have a look at the history. For this, I actually had to do some research on the internet. Finally, I found this page here from Oracle, where Oracle says the concept of an interface in the Java language was borrowed from the Objective C concept of a protocol. Well, pretty much everyone says are things that Java was actually the first language introducing interfaces. Well, actually, Oracle itself says that this is not true. It was birthed from Objective C. I find this quite interesting. Objective C. I thought we should also have a look on Objective C, then. So I found this page here saying, Brad Cox and Tom love created the Objective C programming language in the early 1980s. So actually much older than Java. Java, was released as far as I know, in 1995. So 15 years later, in an effort to get people to write cleaner, more modular and clearly Separated code. Yeah, that sounds actually quite good. Now, what is interesting is here, this paragraph also says, into interfaces were introduced to Java to enhance Java's single inheritance model. So whatever single inheritance model means they didn't say they had introduced the interfaces to get more cleaner, more modular, and clearly separated code. There is a different reason. Well, I haven't told you what inheritance means yet. And this for a reason. Because, um, well, Java was released in 1995, said before, and now we have 2015 20 years later, actually, in the meantime, the especially the clean code community does not believe so much in inheritance anymore. Because, of course, inheritance has a lot of advantages. But also many disadvantages about this, I'll tell you, and one of the next episodes when I'm going to talk about inheritance in Java. But anyway, so when Java was introduced, Java is the successor of c++ we could say. And c++ still had a model using multiple inheritance. So multiple inheritance is even more complicated than single inheritance. And here they write. multiple inheritance created too many problems for programmers, as well as compiler writers, because it's actually not so easy to implement multiple inheritance in into a compiler. So it seems, because they did not support multiple inheritance, they added interfaces to Java s, like replacement for multiple inheritance, to like, fix that Java did not support multiple inheritance. And this is quite funny. And let me say it in different words, I would say, it seems like the really powerful feature of interfaces was introduced into Java by kind of accident, because they said before, they didn't think about cleaner, more modular, clearly separated code, but mostly just to have a way of having something similar to multiple inheritance. Okay, let's stop here, and jump directly into my ID. Cuz I felt you were already feet been falling asleep. Um, so here, this is my car. So it was test that I've used in earlier episodes. Also, I've added this should demonstrate interfaces method, as the name implies, just for demonstration purposes, I'm still using the car service that I've implemented, also in one of the earlier episodes, and I've added a drive method to it. So the idea is to have a service class. And when I call the drive method, that this should, like start the engines of several cars, and make them drive. So for this, in my car service, I have now a method drive. It creates First of all, three different cars. I mean, this is just an example you mentioned, were hundreds of cars. And now I call the drive method on each of these cars. Okay, actually, all these classes are in the same package. This is why I don't have to import any class. But imagine each class would be in a different package. We would have to import each class separately like BMW and Porsche GE and mercy is and so on. So what we say here is actually this car service at the moment is really Deeply coupled to these car classes, this is something that we don't want more about this later. And also, you see, we need a lot of code to make all the cars drive. And this is something that we want to improve with using interfaces. Now what, again, what is an interface? Well, an interface is also like an abstract type definition, what this type should be able to do. In our case, we have an I mean, I'm already saying it three different cars. And all these cars can drive and you see it already, I have three different drive methods. I mean, the way they hold how they are driving might be different because of course, a BMW has a different engine than a pushy, and again, a different engine than ms cedars. But they have some certain specifics, like, for example, they would all have four wheels, and they can all drive which we can make something like a contract off. So in this way, let us introduce an interface and I've prepared something here, car dot java. So far, we only have the package declaration, we have to extend that. So let's start. Let's start as if we would write a class. So let's say public class car. And then opening and closing curly brace, and now public void drive. Okay. And then in here, we could do something. Well, the problem is if we do it like this, this is not going to work, because then all the different types will have to drive the same way. But this is not what we want. For example, He in pushy, I have implemented already the drive method. I mean, this is just a stupid example. I still want you hardly ever to use system out print line. But here for our example, I just wanted to show you that each method is implemented in a different way. Here it says masseter striving there it says Porsche driving, the BMW actually even has three different methods. These ones we will actually use at a later time. And it also has the drive method, which says BMW driving. Okay. So now, maybe before, I'm going to continue with doing the interface, we could also try to execute the code as it is. Let's do this. Now, just so that you see the code should be running by now already. So it says BMW driving Porsche driving Mercedes driving. So what I want to achieve is exactly the same just using interfaces with less and more readable code. By the way, exit code zero means everything is fine. If there is a problem, an exception thrown, it would be exit code one. Okay. So back to what at the moment is still a class. Now there is a very easy way to make this an interface. And this is I say interface. But now it seems there is still a problem. It says interface methods cannot have a body, or what is the body, the body is this part here in blue. So the body is actually the method implementation. method also has a method signature. This on top here is called the method signature, public void, and the name of the method is drive. Okay. Sorry. So it seems like it cannot have a body. How is that? Well, I guess even makes sense. Because we said we just want to have a definition, like a contract. But we don't want to actually implement it. The implementation will be done by the specific implementations by BMW by Porsche and by my seniors. And we have already done the implementations. So let me remove the body. Now there's still something wrong and you see it. Here it even says it It wants now, the semi column because the semicolon now says, I'm finished. I'm done. This is all I want to say. So now we have an abstract definition of a method that other classes may implement. And when they implement the interface car, we can also say they play the role of a car. Because actually a class can implement more than one interface. A class can implement any number of interfaces. And remember, before I spoke about multiple inheritance, well, multiple is, this is why it's similar, because it also allows to have, like, multiple implementations in a way, but more of this later. So a class can also implement multiple interfaces. Okay. And when I click here, you also see modifier public is redundant. Why is it redundant? because by definition, all methods that we define in an interface must be public, they are always public. So even if I remove it, well, if you still remember, the episode I did on the visibility modifiers, you might now think, Well, now that there is no modifier defined, it must be of default, or package level visibility, no, it is still a public visibility, because it always a method is always have public visibility. Another modifier that is implicitly here is abstract, can put it abstract just means what we have here, that the method is not implemented, and that it just consists of the method signature, and that the body is left away, and that we have to semicolon here. So also, this is redundant, we can and we should remove it. Always define your methods without public and without abstract, you should just know that implicitly, they're there. Okay. And then there's one more thing you can do in an interface. Um, but I warn you not to do it. This is actually an anti pattern. But still just to be complete. I let me show you. And this is you can add public static, final. So you can add constants, for example, Max, Max speed. I don't know 320. And however, you shouldn't do so. And when you think about it, I guess you will easily find out why. Because for example, the BMW might only do a max speed of 240. Porsche Yeah, maybe a Porsche can maybe do 320, but maybe also even more than Mercedes, I don't know. So this is actually not part of this should not be part of the interface, because this is an implementation detail. And such an implementation detail should be hidden within the class, or even better. In an email about this, let me also shortly show you a little page I found on the web. And this is here it is on the page of sonar. Well, actually, it's called sonar cube sonar cube is really a very cool tool. It's actually one of my favorite tools for static code quality analysis. I'm pretty sure very soon, I'll do an episode on sonar cube alone. For now, let me keep this as short as possible, because we still want to talk about interfaces. But in this sonar cube, it's actually a rule that checks that you don't use constants in an interface. Here it says console should not be defined in an interface. And there was also or there is also very smart, cool guy, Joshua blah, the author of Effective Java, which is, by the way, also a must read, I have a link to that book on my blog, on Marcus minus bo.com, where you can directly buy it from MSN. So if you have the time, you can also read all this, but I think I already explained the important parts. Here, we can also look at it. So noncomplying code is to define the variables directly in the interface. And you see here they even didn't say public static final because this is again, every variable you define, is implicitly a constant. So you don't even have to say public Static final. But this is not good. Anyway, the much better solution is to use an enum we have talked about enums already. So I won't go in more detail here. Another possibility, which I would not recommend, you can also have something called constant classes, which you make final. And then in the class, you have the public static final constants. This is possible, but it's always better to have small enums. Because usually what happens is in these constant classes, they would grow. And they would grow and have contain all kinds of different constants. While this only contains the constants of this status here. And also, I mean, talked about this when I talked about enums is type safe. Well, here, you could change any number. Okay, so anyway, so now back to our code. So, here, you already see it's redundant. All this is redundant, and should be removed. But this should also be removed. As I said before, because it's an implementation detail, this is not part of our contract. Because the car should just define what needs to get done, what behavior class implementing that behavior has, like it should drive, but the way how it's how it drives, if it drives fast or slow. This is part of the class and not part of the interface. This is really important when you want to do clean coding. Okay. So now let us implement, use the interface. So now, when I say implements car, when you you can now use BMW as a car. And when you do so, BMW plays the role of being a car. And as I said before, you can also implement several interfaces, which we're going to do very soon. But first of all, let me finish this quarshie implements car. And Marie cetus implements car. Well, the compiler was directly happy, I hadn't got to do anything, or implements car. Because the work I've done beforehand, implementing the method will normally let me know that this just to be faster in my here, code example. You won't do it like this, you define a class, you say it implements an interface. And then you see I already have a problem with the compiler, which tells me I have to implement the abstract method, Dr. Okay, and then you do this. And the compiler is happy. It has to be exactly like defined in the interface. You cannot, for example, say int as a return value, because this is not how it was defined in the interface. Okay, now, let me also show you, oh, there's still a problem with car. It seems there's the curly brace missing, somehow. Okay, it seems like I probably deleted too much. Okay, see how small is is well, actually, by the way, I'm an interface should have at least one method. While this is also not true, there are even something called market interfaces that don't even contain a single method. This is a specialty, which I'm not going to go in detail now. But usually they would have at most, at least one method, and maybe even many more methods. But again, I want to warn you, I see often interfaces with 10s of hundreds of methods. And sometimes it's just too much. It's better to have many, many interfaces and to have your classes implement several interfaces at once, so that you can decide what role your class is going to play. And lo let's implement more interfaces in here. I've already prepared again, adding these methods, because I have also what interfaces one interface is the lockable interface, which I defined. The idea for such an interface is for example, you want to do logging, you want to do you want to lock several different objects, could have cars, persons whatsoever, everything can be lockable. And I defined that in order to be likable. Such a class must implement a method called message, which I then later in my learning framework can call. Because I know that whenever I have a class that implements luggable, it will then have a message method that I can call and it returns me a string that should be used for logging purposes. Then also, well took me a while to come up with examples, because what other roles could a car play, I said, it could also be a property. And such a property would have an owner, for example, the owner of the BMW I made myself I mean, I want to have a BMW, how cool is that. And one more interface, I said, I just came up with the idea, we could also have a role of being an asset, an asset would have a value. And so my BMW also has a value. So I cannot easily say, implements luggable. Think this one I have not implemented yet. And I still have to do No, not twice implement car, comma luggable, comma, asset, comma property, the order doesn't matter. But now you see, I've implemented already the value method and the owner method, the message method, I still have to implement. And as I said before, the order is not controlled, so I can put it in any order message. And, yeah, here, we just return something on the car. Okay, now, I have a class implementing 1234 different interfaces. OK, now let's use my classes implementing the interfaces. For this, we go back into my car service, what I can already do is now my variable my reference variable is at the moment of type BMW, the class so my BMW can do everything that a BMW can do, which at the moment is drive message owner value, these are methods that we inherit, see, there is inheritance already, from the object class more of this very soon, but these were the classes that we have directly implemented in the BMW class, so I can use all of them. Or let me show you a message, we can use them. Now, what I can also do is, now that I've implemented the car interface, I can say my I create an object of type in W, but I put a reference on it of type car. And now, this will change the behavior. Now, I can just call drive on it, because now my BMW just plays the role of a car I can also say luggable and then I will not be able to drive the car because in the context of logging, I don't care about driving all I care is about login and for logging, I would need such a message okay. So, now, let me make all these cars and this is also something you should do I mean, the object is the object, but the variable when you have an interface, always try to like reference with the with an interface to the object. Because this way, you can more easily exchanged your code like imagine the BMW would come as an argument to the method. Now, at the moment we have these three cars, imagine at a later time someone in when so very cool Marquess car, then when the when the method is operating on the car interface type, this method will work even with new classes introduced without even knowing them at the time, we wrote our car service. So whenever possible, use the interface type. Okay. So now, I want to have a for each loop. And for this, let me put All these cars into a car array. We've also already talked about array called as cars equals two. And now the short definition I can even do it on the fly. Make it even more shorter. You W, you're pushy. You're more serious. Okay. Hello, on this array, I can now easily iterate. And I can now say car dot drive. And, or as said before, each car will drive differently. But this will be handled by the object. Now our car service does not know any specific implementation anymore. This is the coupling, decoupling the code is not coupled so much to the specific implementations, my car service, all that it uses, all that it knows is now the car interface. Okay, and with these few lines, I iterate over all the cars and I drive them. Let's execute this code to and have a look if it works. Yeah, see, this is exactly the same as before, my BMW is driving or a Porsche he is driving and marmet cetus is driving. Now let's also have a look at the car reference. As you see, we can only execute drive on it. That is defined by the car interface. And we do have a BMW as the first element in our area. But this headline 10, we don't know. All we know is we have an area of cars. Okay, so we cannot call any BMW specific method. In here. I can also not say BMW, because this is not competitive compatible. We need a car. And we don't need to be in w because this array is of type car. Okay, so let me fix that. Okay. So I think this pretty much wraps up my explanation of interfaces in Java. A really cool feature. And now let's have a discussion about the pros and cons about the advantages and disadvantages of interfaces in Java. Well, first of all, let's start with the disadvantages. And actually, I can tell you, there are not so many. Well, you see, for every interface that are introduced, I have to type down this code. And, of course, this is here, not much, it could be of course, much more. So, and each class that wants to use an interface has to implement this interface. So there is some added complexity. Also in my car service, I'm using now the car interface. And whenever you introduce complexity, this complexity must be justified. So if it makes sense, if it helps us with something, for example, here, I'm not able to easily iterate over all the cars. And you mentioned there could be many, many, many, many more. But my for loop would just be the same. So this would be for example, a justification. But my car service at the moment does not implement an interface. Well actually, this is kind of an exception to the rule. Most services should implement an interface. Very often this makes sense, because it's specifically for testing so that you can exchange the concrete implementation just here. In my example, it does not make sense because I just want to explain you interfaces and I want to have it really short and neat and not too complicated. And I know I will only have this one class here for demonstration purposes. So why Would I implement an interface here? So at the moment, I don't see a reason to make my car service implemented interface. Sometimes, of course, there are corner cases, we're not sure. My personal point of view there is, if I know that for the next months, I'm not going to need the interface. My probably leave it away. Because code, I mean, it lives you are allowed, you can change it, you can refactor your code. So if at a later time you, it turns out you need to interface then edit at a later time. Just don't do arbitrary decisions. There are people that like they love interfaces. And for this reason, they do something I would call interface readers, like an illness, blindly adding an interface implementing an interface always just because, and I think this is not too smart. And then really, interfaces can be a disadvantage, because they just make everything more complex. But now, this is already pretty much it. To the advantages, so the advantages, I think a few ones are already mentioned, while explaining the interface. Probably one of the most important ones is that it decouples your code, as I explained before, like now, the car service only uses the cotton Well, no, I was actually like, sorry, of course, as it is implemented at the moment, we still say new BMW new Porsche new messages. So of course, at the moment, it would still be coupled. But normally, of course, he would also not do it like this, what he would usually do is you forward an array that is already filled, only then. Now, our core service is not coupled to the specific implementations. So it really allows to decouple your code much better than without interfaces. And this decoupling also helps with other things, for example, team cooperation. Imagine you have a big team of 10 2030 developers, and you have a big project that you have to work on for weeks or months. And then you would probably form smaller sub teams. And then each sub team would work on a specific area. For example, one team in our example here, could work on the car service, while there would be another team implementing different car types. Now the problem is, the car service is then or might be dependent on specific car implementations to test it. And on the other hand, the team that implements the different car types might need a car service for testing, and for integrating their code with the other code. So it's like, each team is dependent on the other team. And so each team blocks the other team. So nothing can be finished. And interfaces can be a solution to the problem. Because when you introduce an interface here, for example, in this case for the car service, then the team implementing the different cars would just do a very stupid dummy implementation, something similar like I did here, where you don't have real code, or just something where you see it's working. And then the other team can independently also work on their code. And also add dummy implementations where needed. And only when both are finished, they can be brought together. So interfaces really help in team cooperation. And then next advantage is interfaces really include increase your flexibility, because as you see, as I have changed it now we have the cars array as a parameter to our drive method. So actually at runtime, in this case, in our test method, we have this drive method. So now at runtime, I could have something some condition if it's sunny, just making this up. Then I want to drive in my Porsche. And so I create a pushy here, so I would say car car And then I would say if sunny car equals to new Porsche else if it's not Sunny, well, I hope I had so many cars, then I would say I take the BMW instead. Because it's better for rainy weather. Knew, of course, and now I don't want to make an error, let me change the method. And I don't implement sunny nose. So I just say true here, just to have it simple. So in this case, Now, of course, you wouldn't be cold. And in my drive method to make this work, make this a car to have it simple. And I would call drive. So now at runtime, we will decide what kind of car this is. So this really adds a lot of power to our code. So it might be a pushy, and it might be a BMW that is given to the Dr. method. Really cool feature. Okay, I guess there are many, many more advantages of interfaces. Let me know if you have more to add. But I think this is enough for the moment so that you get an idea of what interfaces are. And all the advantages interfaces have. Just also, again, the warning don't fall into our interface, serious illness. This will also be not wise. But I think this pretty much wraps it up. I'm going to talk about inheritance in Java. inheritance is actually a very powerful feature of object oriented languages. Similar to interfaces, inheritance allows to handle a group of similar objects in a uniform way. On top of that, however, it also allows to prevent code duplication, by inheriting the members of a class from a parent class to its child classes. I'm the members of a class in case you don't remember, are the instance variables, and the instance methods. So everything that is not static. Okay, well, I guess that sounds very promising. The problem is, I think inheritance is just a bit too powerful actually. Well, if used incorrectly, inheritance, can severely damage your code. So really take here and use inheritance sparsely. I mean, there are definitely justified cases to use inheritance. But whenever in doubt, I would not use it. Okay. And also, it actually requires some experience to know when to use inheritance, and when to avoid it. To give you a real world example, I'm at the moment I'm working on a project of about maybe 15,000 lines of code. And there. I used inheritance, maybe once. Yeah. So there are alternatives to using inheritance. I'm about this. We will talk at the later time. Yeah. Well, let's stop here for a moment. Because now the introduction is almost over. You see me in the button right corner talking to you all very soon disappear, because I'll jump into the code. And I'll show you how to implement and use inheritance. Before that one personal request. I'm doing this videos for you. So that you can learn Java, I hope they useful to you. If so, I would be very happy if you could give me your thumbs up in the bottom right corner of this video. And remember, you can also subscribe to my YouTube channel. Okay, well enough of advertisement Now, let's really do a coding session and jump into the code. Okay, so here you see I have prepared this CEU test class for you. We are actually not really testing something now. This is just for demonstration purposes, any arbitrary example. Um, this example is actually taken from the book, headfirst Java, from Kathy Sierra, she is really my favorite author of any Java related book, highly recommended to read this and any other offer books. In case you want to know, you can find a link to her books on my blog on market minus b.com. I have a must read section there, you can find her books. Okay. Now back to the code. So I have here the SU class. So the idea is, we have here an area of animals, similar to the area of cars I had in the last episode, where I introduced you to interfaces, and I had a car every with BMW and Mercedes and a pushy, now we have an animal array with a dog, a gorilla, and a line and a tiger. So you should already see interfaces and inheritance in Java. When you use them, here, it looks quite similar. And this, by the way, is called polymorphism. You might have heard that. And the idea of polymorphism is that on the left side, you have a variable a reference variable of this super type a parent class animal. But Polly Morphe. I mean, this also works with interfaces. So the idea is just that you have an interface or a super or parent class. And on the right side, an animal can be a dog, a gorilla, a line, a tiger, anything, so different things can be assigned to the left variable. Because the polymorphism means like, many sides solve can have different implementations on the right side. And they will all be handled uniformly here, I have prepared this feed animals method. Let's maybe jump here. Okay, so you see I've prepared this for each loop, everything that is read, we still have to implement, I have only prepared it. So we're iterating through my array, we still have to implement the eat method. And we still have to implement the H method. Now, again, totally stupid, arbitrary example. But just to have something to show you. And to have variation. My idea was, I mean, totally arbitrary. Really, this depends on the design of your code that like because code is always like a model of the real world. And so it totally depends on the example that you're working on. Well, in my example, I just defined that I said, Well, every animal, a dog, a gorilla, a line, Tiger, they all eat in a different way. Because for example, a gorilla would probably eat, I don't know what it eats grass, or leaves or something will align. I don't know. It's some kind of meat. So therefore, my idea was to have an implementation, a concrete implementation of the eat method in each different animal subtype. And further, my idea was to have this H method. Well, every animal can be of a different age. But the calculation Well, normally, you wouldn't probably calculate the age. But I mean, this is just my stupid example, I made it a method. So the calculation would be the same for every animal. So my idea is to have this as a concrete method, an animal and have this as an abstract method, because this is something here, where interfaces are different. Sorry, yeah, but interfaces are different to inheritance. In interfaces, you only have abstract methods. And because you have only abstract methods, the abstract keyword is not needed. But here we can enhance inheritance, we can mix it, maybe I should already jump now to the animal class. So an animal class this is still just a stupid simple class totally empty. So you can use inheritance with just a simple class. And now let's implement two methods concrete methods, public void, eat Later on, I'll make this abstract. But for now, I wanted concrete. public void. Ah, oh, okay. So now maybe we should also do something in the method. And again, avoid system or print boom, just, if you're like me doing an example, showing something. This is the exception polluter rules and it's okayish to use system or printable, but avoided in real code. Okay, so I say, animal is eating. Well, this is not what we want. So it's just step one, I said every animal is eating in its own way. And here is say, h is cold. collated. Okay, it's here the dots to just for fun. So now, see, this class looks totally like a regular class, you have seen so many times before. Now, I go to the dog class, and I want the dog to be an animal. Well, if this would be an interface, I would say implements you remember, but it's not it's a class and we extend the class and therefore the keyword is extends really, totally easy. Okay, so we say extends animal. And all this is already using inheritance. Now it's looks like as if the dog class was empty. But in fact, we can already use these two methods in dog Okay, let's continue doing this for all the other subtypes gorilla extends animal line extends animal. These by the way are two interfaces, I also want to show you and I might just as well do it now, we can mix using interfaces and using extending classes using inheritance we can mix them the question is should we first say extends or first implements, well, there is a rule it must be that we say extends first and then implements because in Java, we have single inheritance. So, we can only extend a single class, but we can implement any number of interfaces, and therefore, this is a comma separated list. And therefore, to make it a bit easier, it's at the end. So, we say implements and I can say this interface lockable and comma printable. So, an interface plays a role. So Aline can play the role of being a lovable, when like, he mentioned, the code is running on production at a certain time where we want to lock the line or we want to print it and therefore we can implement this interface. Again, this is pulley Morphe that align can be a luggable Okay, so, you see there is something red, because now we have a lot of methods that we have to implement. First of all, from the animal, I mean, the order is arbitrary. We can also start with a printable. So there was a public void. Um, was it print I hope method. And then there was a public void I think message for luggable. This might have Yeah, you see, so the rule is, when we implement an interface method as well as when we, when we implement an abstract method from animal, the signature, the method signature must be exactly the same. We can't say what year because the interface said it must be a string, return something just for our little example. Okay, and in here, I say system dot out. Print. ln printing, okay, get the idea. So, now, there is still the eat method missing. No, actually, it's not because we made it concrete. So we don't have to implement the method I'm already a bit too fast. So see the red is gone. Everything so far seems okay. But there's still a problem and Sue test. Let's check this are the tiger, we still have to do the tiger extends because the tiger was not an animal yet. Maybe we should look at this again. I mean, this is interesting. So see, all those classes are all already extending the animal. And so these are already animals, but the tiger is not yet required, we need an animal with found is a tiger. Okay, so let's make this also an animal. Now it's an animal, and now it's working, the red is gone. Okay, but we still haven't done what we want it. Because I said I want this method abstract. Now, you probably remember from when I explained interfaces, an abstract method does not have this method body, the implementation, but just the method signature, this here on the top, the method signature. So let's remove the body. And we have to say abstract in the interface we didn't have to, because in interface, all the methods are, by definition abstract. But here I mean, how would Java Nope, there's a concrete method. And this one is supposed to be abstract. So therefore, in inheritance, we have to explicitly set abstract. But now there is a difference. Because if one method is abstract, the whole class has to be abstract. Now, what does this mean? Because actually, this changes a bit of the behavior. And this, again, depends on your personal design of the program that you're writing. An abstract class cannot be instantiated. Now, we cannot say the compiler will not allow us We can't say new animal. An abstract class is like just the contract, just the protocol. Pretty much the same as an interface is just the raw definition. But we cannot create instances from an abstract class, we can only do so from concrete classes. But concrete classes cannot have abstract methods. So this is something that you have to clearly think of. And also amin, I said, another warning, I said that this can be used to prevent code publication. Now you might think, well, cool, I just create some tool class. And this has any method that I'm like needed anytime for example, age. And then I can say animal extends tool. Because even the inheritance can have several layers. So even though talk says extends animal animal, again, could extend some class. So now we could say, extend some to class haven't implemented that. But I hope you get the idea. Well, even though you can do so you should not do so. Because the rule is you have to apply and is a test. Also, this is from the book of Kathy Sierra had first Java. They you say an animal is a tool? No, it's not. So because it's not a tool, we don't say tool. Because otherwise, this can really get nasty. And so you shouldn't do that as a recommendation. But really a strong recommendation. Okay. So yeah, it still has to be made abstract because of this abstract method here and we have to remove new animal as I said, doesn't work. Okay, not everything read has gone. Now, let's go into our classes again. See, now there is a problem. Now that this method is abstract, we also forced to implement it. So we have to say, public void, eat. And we have to implement this method. And again, stupid examples system called print ln dog is eating dot dot dot Okay, So gorilla is eating in a different way. It's, I don't know, grass or something reuleaux is eating leaves. Um, next one line, the line is eating something again, and the tiger is eating something. So in this case, they all implement the eat method in their own unique way. So in reality, you wouldn't, of course have your system out print on but some specific, Tiger related logic that only fits for tiger. And this is why we have it here. And all the logic that fits for all animals you put here. And this by the way, I mean, on the one hand, this is handy. But to me, this is really a double double sided sword. I mean, this is handy and can help. But on the other hand, it also is really complex. Because when you're in a class like Sue, how do you know which animal implements eat, and which animal just inherits the eat method, same for the H method, because we could of course, again mix that. And we can also override a method. So for example, ah, this one is implemented. But we could say, gorilla is implementing the age by itself are not something. So this is like, how you could define an exception to the rule. You could say, well, my gorilla does not use the H method. But instead, the H method is replaced by exactly this method. And the way this is done is, the signature must be this method signature here must be pretty much looking the same. You can't like change the return value or the parameter values. Well, you see, you can, but it's just not using inheritance. Now, this is also why it's not yellow, but gray. Um, this is called overloading a method. overloading a method means you implement a method that has the same name as another method. But it's just something completely different. So this has nothing to do with inheritance. If you want to inherit the method and override me override it, it has to have the same signature. Okay, there is one exception. And for this, I have to introduce a new visibility modifier. I think shortly, I talked about it in an earlier episode, but I didn't really explain you what it means. And this is protected. Now what means protected? protected, means it's visible, on the one hand, similar to default, or package level visibility, and the whole package. So now we can use the H method. In Su. See, this is not read. It also means it's visible in any class that extends animal. In our case, now, we have all the classes in the same package. But he mentioned we had a car sitting, extend animal, I mean, of course, we should not this would be stupid. But just technically not from a design perspective. We could then use the H method, because it's protected. So the visibility is to any class that inherits from animal on top, any class that is in the same package. And this again, makes it complex. Do you see how much I have to explain? so that you understand, and this is why I would avoid using it. So I just want you to passively know when someone else uses it. But I would really avoid it. But so protected visibility is less visible than public. And what I am allowed to do is I can increase the visibility in a child class. So where was I? Here? So I'm allowed you see it works. I can say public void. Now this is still not inherited. Nowadays, it's yellow again. So I can say public And now I can also say protected, which at the moment is the same visibility as in parent class animal. But I'm not allowed to say private, this will give me a compiler error, attempting to assign weaker access privileges. It was protected. So you're allowed to make it public, but not less than protected. The idea behind that is, I mean, an abstract method defines a contract a protocol. Exactly. Like with interfaces, by saying extends animal, you promise any other class in the Java universe? I am an animal, and you have a method that is public. And you can call it. And me. You mentioned the crazy stuff that would happen. If there is one class that just does not fulfill this contract. So this is why it's not working, it has to have the same visibility. Oh, okay. Then also, I mean, I said, we inherit the members of a class. And I said, the members of the class are the instance methods. These are the instance methods, and the instance variables. So you can also have here a protected, I'm in H. And this will also be inherited. We can now say, directly access is in here. I mean, this is the H method. Maybe I should now here have a public void. h method instead of the eat method. Okay. And now I can say this dot age, or just age? Or a statement? Yeah, of course not. It's not finished 45. So this would now we'll set the age to 45. Or just age because here, we don't need this. Because we know what we mean. Um, even though this is possible, we inherit the age field, I would not make use of it. Well, first of all, because I don't like protected as I said, and second, because I think this kind of violates the capsulation because the animals should be the only one working on its internal variables. Okay. So avoid protected and avoid like, making the variables the members the the instance members visible. If we have a static method, public static, something. Well, I have to implement it. Of course, this can be used static void. For example, by saying animal dot something can also be used now. From Zoo or wherever. So we could say, animal dot something. Yeah, you see, it's also formed formatted differently. So we don't really see this as a static method. But this will not be inherited. So you cannot, like override this or so. And the gorilla class again, you can say animal dot something will actually you can even say and this is a bit weird. Gorilla dot something. But this is not inheritance. It's just Java is a bit smart. Here. The compiler is a bit smart. It knows gorilla is an animal. So it realizes this is an animal and then it takes the static method. But this is still not inheritance. Oh, K. Let me remove that. I hope I haven't confused you too much with that static. Just remember, we only inheriting the members of the clause. The instance methods and the instance variables. All Okay. Well, I think this is pretty much it. Maybe I should execute it again. And now we see dog is eating. He is calculated. Gorilla is eating gorilla is implementing the H by itself. This was I was overwriting the H method in gorilla, and only in gorilla lion is eating, he has calculated Tigers eating ages calculated. So inheritance really is a complex beast. And in conclusion, use it sparsely. Only use it when you can say, when you can apply the is a test. A dog is an animal, a gorilla is an animal, a lion is an animal, a tiger is an animal, a tool is not an animal. So you will not say tool extends animal never. Um, if you're just looking for something to like, not copy and paste, to not duplicate code, you can do something else, put your code into its own object, a tool object. And then always you can use composition. You could say, for example, a tiger has, I don't know, um, has a leg. If that makes sense or not, I don't know. So leg, leg. And then you if you have a method, for example, walk, you can say leg dot walk. And if you have another animal that also needs up it called eat still. So this would be walk. So now if you have another animal that should also use the lecture also use this method, you can also make it to have this member. And this by the way can and also should be an interface. So that really makes it much more flexible actually, even than inheritance. Because using an interface, you can exchange the behavior at runtime. This is something I showed you in the last episode talking about interfaces, where I said you could have some condition, if I don't know, Sunday. He was this implementation and otherwise the other implementation. I mean, this is just not real code. Just very fast. Else. I just hope you get the idea. I could say if Sunday, like equals to my fast leg, legs, you know. And the other days, I'm not so fast. I say used to slow lag. And then after the instantiation I would say like dot walk. Okay, so of course I mean this if else again introduces some complexity. So whenever you design something, there's always pros and cons, you have to think, what do I really need? But so you can use this, just to give you one example to not use inheritance and still not duplicate your code. Oh, okay. Let me remove that. Don't want it to be read. Wanted to be working. Okay, now, let's maybe recap before I finished this video. So we talked about inheritance. We talked about polymorphism. I showed you you can use composition. And there's also actually design principle it's called favor composition over inheritance. As I showed you you can mix using inheritance with was that one of these classes? Yeah. With interfaces, I showed you can implement several interfaces, you can only extend one class. So I cannot say it already. When I do the calmer Something is wrong. So I cannot say this animal to this doesn't work. Just believe me for now. Or I mean, yeah, this is also a class, which is implemented. Yeah. So you see class cannot extend multiple classes. This works in C plus class. And it's even more nasty than Single inheritance. This causes something called the deadly diamond of death. But I will not continue. This is too, too much for now you can google this deadly diamond of death. Because Java doesn't support multiple inheritance. I'm going to talk about the method finalize of the class object. The class object is the root of the class hierarchy. Every class in the whole Java universe inherits the methods of this class. So this is what makes those methods here, very important. Which is probably also the reason why those methods are very often used in Java developer job interview questions. So one way or the other, I hope I have now raised your attention. Also, you should now that this episode, as well as the following ones talking about all those methods are based on the really great book, Effective Java second edition from Joshua block. I think I mentioned it already earlier. Now I have to say it again, buy this book read it. Even better would be if you read it twice. It's full of condensed information. Advanced Java developer must know my episode is supposed to give you an introduction to the topic. But for more detailed information, it's necessary that you read this book. Okay. So let's already start talking about the finalize method. The finalize method is actually a hook method. What is a hook method? a hook method is a method that, um, there is an empty implementation provided in the class object. And the idea is that when you want this method to be used, he would provide an implementation in your own class, by inheriting by overwriting sorry, by overwriting this method. And then this method will be called by the JVM. But before I go in more details, the one the most important takeaway from this episode is, this method is flawed. So the best you can probably do, generally speaking, is not overriding this method. So not using it because it has its flaws, will, in this episode, see? Why. I mean, there are some few valid users, at least according to Joshua blog. I can tell you, I'm developing in Java since 2001. So quite a few years already, I have never ever overwritten this method. So today is probably the first time to demonstrate you what it is what it does. Okay. So maybe we should already jump into the into the code, because it might be easier to understand for you, or maybe before we read here, this description. So the finalize method is called by the garbage collector of an object, when garbage collection terminate determines that there are no more references to the object. So again, next question was probably what is the garbage collector? Well, the garbage collector is really a very cool thing of the Java language. Other languages such as c++, don't have it. As the name implies, it collects the garbage what's the garbage the garbage is or objects that you created, worked on them. And after some time, the process will be finished, at least on certain objects, he will not need them anymore. And so it helps to free up those memory resources. So that you hopefully never run into out of memory exception. And this is all done behind the cover as synchronously by the garbage collector for you. But here is already the problem of the finalize method. Because I said it's, it's called just before the garbage collector runs. The problem is the garbage collector is running as synchronously so you can't influence when or if the garbage collector is running. It is like its own smart beast. And you have no influence to tell it that it should run. You can only give it recommendations. But you have no guarantee that the garbage collector will ever run. And so you also have no guarantee that the finalized method will ever run. Yeah, and what would you usually do in the finalize method, the idea was, you will also clean up stuff, they're just not memory related resources, but not memory real related resources. For example, if you have a connection to some i o resource, like a database or a file, those are also system resources. And all resources are limited. So if you don't want to get in trouble, and if you don't want that your system totally, totally freezes. You have to, again, free up resources when you don't need them anymore. So the idea was to do that in a finalized method. Now the flaw is, you don't have a guarantee that runs. And this already says it's not working as intended. Okay. Besides, Joshua Bloch also gives other reasons. For example, He somehow measured that creating an object and destroying it, again, is 430 times slower when you have an finalizer method implemented. So again, don't use it. And now let's jump into the ID and look at it in more detail from a practical point of view. Okay. Also, just before, in the API documentation, you might have seen, this method is actually protected. Here. Again, we can see it protected void finalize, I mean, this Java API is just written into the source code. Here, you can see the source code of object dot java. So you see, it's also just a regular Java class. And you'll also see this method is empty. This is what I said, it's a hook method. The idea is that you override the method and that you provide code that is executed for cleaning up non memory resources. And Java, try to prevent that you directly call the finalize method, because as I said, the idea is that you don't call it but that the JVM calls it for you. So this is why this method is actually protected. Protected is quite hard to understand. One way you can use a method that is protected is if you are in the same package. So let's check this class isn't a package Java Lang. So I thought being nasty, I can just as well create a class in this package. And this is what I did here, test Java. In package Java Lang. You see, everything seems fine. I don't have any exception from the compiler. So now, let's try to call this method. And you see, this dot finalize, seems to be working. I mean, this is not working, because this is a static method. So we would actually need a non static method. Or I could also say, new object. Well, there is an exception, because it can throw a throwable as we see here at the bottom. I'm not going to handle this now, because I only wanted to show you from a theoretical point of view, this is possible. There's just one problem. Let me now surrounded with a try catch to get the compiler happy. So see, this would be now directly calling finalize, from a class that is in package Java Lang. So I'm within my public static void Main method. So I execute it. Bam, I get an exception, security exception. It's prohibited. I cannot use Java Lang as a package name. So this is not working. Okay, I just thought I should show you. I think this is quite interesting. Now, let's close this again. And let's complete remove this method. Okay, so what you should also know I mean, I said object is the root class, but it's also a concrete class, you can create objects of the class object. What I don't like here is that the word object is used twice, because the class is called object. That's a bit confusing. So anyway, you see, you can call all those methods. But here within the class car selector, we cannot call the finalize method. Okay. So for this, I have here, this portion class, that's also close the object class. And now let's override the finalize method, public void finalize, without any parameter. So to override a method, it is very important that you do it exactly. Like in the superclass, the only difference is, and this is allowed, I don't make it protected anymore, I can make it public. Because public is more visible than protected. This is fine. Okay. And now, the idea would be that in here, I do clean up my resources. Let's imagine I had some i, o reader, i, o reader, reader, Peter, I'm not going to implement this, just so that you get the idea. So the idea was that within here, he would like for example, close those resources for this, usually I already use provide a closed method. Now there are several problems for one, I said, you don't have a guarantee that this method is ever called. This is totally in control by the JVM, and you can not influence that it's running out of your control, it's running as synchronously. And therefore, it doesn't really serve our purpose. Second flaw is, if within here, we have an exception that is not caught, the process here will be stopped. And our objects will remain in some weird, let's say zombie state. Yeah. Okay, so the question is, what's the alternative than to using the finalize method, the alternative would be, if you have a class that you will use that uses resources that you want to be closed before it's cleaned up, you could provide, like I told you here, the reader would do. You could and you should provide some closed method. And then in here, you do clean up i o resources. I'm going to implement this now. And then make this compilable in car selector. Let's imagine this was a client of using Porsche. When we have Porsche, Porsche, a new Porsche you use a try Finally, we talked about Exception Handling array. And I think, there in this episode, I told you also, you can say try catch and finally, but you can also use the finally without a catch. Now, if we need a catch or not, this is a different discussion. What is important is that at the end, you have finally because the finally the cool thing about the Finally, even when there is an exception happening, it will always be executed. Because this was our problem, we need to make sure that the non memory resources get cleaned up. Okay, so try finally. And then in here, we could say Porsche e dot close to clean up the resources. This is how you probably do it in Java. Okay. Also, shortly, let me show you what I think is interesting. Let's go back what I had before and the finalize method. What I also want you to know is I mean, I said we overriding the method from the class object which is empty. And there's actually an annotation that is quite helpful here. And this is the annotation, the override annotation. See, when I put the ad, there is override. So about annotations. We have haven't talked a lot yet. So let me explain that. In short, this is actually some meta information for your compiler, that you say, Well, my intent here is I want to override some method. If this has a different name, some other name. Here, you see, you get an exception method does not override any method from its superclass. Now, you might not understand what this helps us. So let's, again, call it finalize. Now the thing is, you only override a method if the signature is the same as in the superclass. Now, if I add the parameter here, this is not overriding anymore, but overloading the method, because it's just a method that has the same name. But as it has a different parameter, it has a parameter string, and not no parameter. This is not overriding anymore. And now we get a compile error. So you will directly notice. So this helps us to have the problem directly at compile time while we're still in our ID. And we will not because otherwise it could happen, you think you have implemented a method while you have not. And then you're still using the superclass method. And this you will only see when your code runs on production. This is why whenever you override something at this override, annotation. Okay. So I think this is pretty much it, talking about the finalize method. In short, again, generally speaking, don't use it. Instead, to free up non memory resources use a try Finally, I'm going to talk about a method clone of the class object, a class object I said before, is the superclass of all the objects in the Java universe. And this is why you can use the method clone in all your objects. Now, the question is, should you Really? And the short answer is, you should not at least generally speaking, and this is similar to the finalize method that we talked about in the last episode, which is, again, the reason why I'm talking about clone today, because in this aspect, they're both quite similar. Okay, but before going in more details, maybe first of all should clarify what actually does the clone method do. And clone as the name implies, it creates an identical copy of the object that you call clone on. So what it does not do is, if you have an object, you can always assign it a second or third, how many references ever you want. The problem is with references, that when you work on this reference, all other references will have will be influenced by your changes. And sometimes this is not what you need, you want an independent copy. And for this reason, you could use the clone method. However, there are actually better alternatives, which I'll tell you later. But now enough of talking Anyway, let's jump into my ad and look at the code. Okay, so, here you see my Porsche test, you might remember the pushy and the other cars from my earlier episodes. Before I show you the nasty stuff, I wanted to show you one case, where actually I think using clone is actually good. And this is here I have prepared an array of strings 123 and here, I mean array is also an object. So it also has the clone method and for the string for the array, it was already implemented the way it should be. So you can and you should clone your array. So I can say string copied array equals to array dot clone. And then I can assert not same, which means this check checks. Now, if we just have a reference. In this case, it would be the same airy and copied airy. Which, to show you that their friends I can also call, assert same and use twice the same reference. So this should be true. They should with not also be true. So there are two different instances. You see, it finished with a green bar, this is what we want to see. So it seems error and error compared to itself, it's both the same reference, they're both referring to the same object. But the copy is not the same reference, it's not the same object, it is a new object. And now, I mean, I want to make this short. But I want to show you at least system out, print ln. And then, you know, this is not I just want to show you the first element and then I just hope you believe me, or you can do it at home can print out the whole elements in in an in a loop. Now I'm just showing you the first element of my copy, and you see it's one. So the other ones are also or unlike just as well. Otherwise, you're telling me copied error. This way, you also learn how you can print out the whole array. And this is now I can print odd STR and this will then in the loop and a for each loop, print out all the strings for us. So I hope this is working now. 123 C, out. Okay. So for now this should be enough. This was just a very short demonstration of a good case of clone. Actually, I found on the internet and very interesting article Actually, it's a newsletter article from Dr. Heinz Cabot's, he's really a very cool guy. I love his newsletters. And he actually made a test and found out that clone for very small areas might be a bit shorter, f slower. However, for large arrays, it's actually faster than any other method. Well, I can't go in more detail, we don't have the time. And this is also very, very advanced already. And we're still on beginner level, approaching more advanced. So anyway, let's continue with our portion. And this is now really test driven style programming. Because I start with an empty test. The code is not finished, we start with writing a test to test Well, first of all we read, and then we are working our way to get the test screen. Okay. So I say Porsche Porsche equals to new Porsche, actually, this is something you can't know. Before doing this episode, I have extended adjusted my class a bit. I mean, you might remember the Porsche from my last episodes, because it was empty. Initially, there was no attributes, no instance members. So this I had to change because I want to show you something that we copy. So I added a string. And I said, it's the owner, the name of the owner. And well, which name should I choose? Because I always wanted to own a Porsche. I thought I might just as well make me the owner of the Porsche. And because you probably also want to own a Porsche. I thought I should make you the owner of our copy of our clone. Because I will not give you my pushy, but I might just as well copy mine and then give you this copy. Well, in real world, this is pretty much impossible. However, here in Java, See how easy that is? Only problem we have is I don't know your name. So for this example, I just assume your name is Peter. So I say Peters for xi equals to new pushy. But this is not what we wanted to do. Right? We wanted to clone. Yeah, because this is no easy. I can just say Peter, and then you have your pushy but this is not the original idea. So let's remove that. And now let's say Porsche dot clone. And interesting enough, really, I mean, we can see what happens behind the covers, because this is done really, by the JVM. And we don't care too much, as long as it works. But there is never a constructor actually cold. So this is really internally copied from the memory. It's just see, we still have this read something is still wrong. I mean, I said, we start with a not working test. So it says clone has Protected Access and Java Lang object. And this is something we have to fix. So the method that says the method is already there. The problem is, it's not visible to us, because it is protected. Protected would be visible in the same package. The class object is in the package, Java, Lang, as I showed you last time. But here we are in a different package. Also, my Porsche test does not inherit anything from Porsche. Because this is from Porsche, so I can't use clone in here. Okay, but what I can and what I will do, I can override the original clone method. But still, I want the code the implementation of the class object. But let's already jump into the Porsche class. So I will override it, public, Porsche, because I wanted to return a Porsche to me, clone. And then you might still remember from my last episode, we can and we should put the override here to have a check from the compiler side, that we actually did everything correctly. Now, let me format that. Okay. And you see, there's nothing red. So it seems like so far, everything is fine. We'll actually went into one interesting thing is the original implementation says object, because in object, what could you return, you don't know. The object that the method always is exactly copying whatever object there is. And in our case, we have a Porsche. So the so it is also fine to directly make this return pushy. But now we have an empty implementation. And we have to return a Porsche. Or we could say return new Porsche. But again, this would not be a clone. So this would, our test would fail in this case. So this is not what we can do. So we have to say super, super means. I want to call a method from superclass in this case object. And you will see already here I see clone is actually the first method, because my ID is already smart, it knows the name of this method is clone. So it assumes I want to call super clone. Okay, so and then I want to return it. So all we did so far is we override the method. And then again, we said, well, actually, I don't really want to override it. All I want is I want to use the method of class object. So all we did so far is we made the visibility public so that we're able to use it this is all we did so far. But now, you see there is still a problem unhandled exception Java Lang clone, not supported exception. And this is already in my opinion, a flaw because, like, why does this Now throw a clone not supported exception, if we do support clone. So, anyway, this is how it is. And now we have to fix that the way we fixed that is we say try, because there is an exception that could happen. And we will catch the exception. Catch. And there my ID Egan helps me clear not supported exception. I usually give it the name here. Okay, now, what should we do here? Some people say return now. Because we have to return something. This is just the signature forces us to return something. But this is not so nice. I mean, actually, we assume this is hopefully never happening. But if it for whatever reason is happening, we really want to see that it is a problem. So in this case, and I kind of copied that from Josh block. Because again, my episode here about clone is based on his book, Effective Java second edition. And it was exactly the same with a finalized episode. So I can only give you a short introduction to the topic. Um, Josh block in his book, he has like, I think eight pages only on the clone method. You should really buy the book and read it. So for this, you can go to macros minus bu.com, click on mastery, it's, and there you will find the book and you can buy it directly. Yeah, also all the books in the must read section. I mean, I have picked the name for a reason. Those are really books. I want you to read them all. They're really classics, the best of the best best Java books you could find, in my opinion, at least. So if you trust me by that book and read it, okay, anyway, so what he did and what I will do the same, as he said, throw new assertion error. Because if this happens, this is not even an exception. Is this really an error? We really have a big problem here. If we get this clone, not supported exception. Okay, so this year now seems fine. But there's still something wrong. And this is it says I'm calling super dot clone. And as I told you, this is the method from object, an object returns an object, at least from the signature of the method. But we are smarter we know actually, it's safe to say pushy, because this object, I mean, the super type is object. But the subtype is a Porsche. So we do an explicit cast, and we cast it to Porsche. This is safe here. Yeah, if it was not safe, it would throw a class not support F. Class cast exception. Sorry. But in this case, believe me, we'll see. It'll it should work. Okay, well, are we done? It looks like we were. Well, actually, as I said, this method is flawed. So we are not done, we still have to do some more thing. But this I want to see. I mean, my idea was to implement the method I did that. So now let's go back to our test, you see, everything is? Well, I can't say green, but the red stuff has gone. So I can execute the test. But I haven't asserted anything yet. So the first assert that I want to do is I want to assert not same. This is just a shorter, Handy form of saying not equal. So it won't be the same if we say pushy, not equal to Porsche Peters pushy, because the idea is that when my clone word that I have a new object. And because it's good to have a method that already from the method name tells us what it does, I use this one. And I compare not pushy to Peters pushy. So my first test is just asserting that this reference here is not referencing this Porsche here now. But something else, this isn't our first test all I want to achieve. Okay, so I execute the test. And bomb. You see the assertion error? I said, Well, everything will be saved law when it's not. And this is why tests are so great. Yes. And now we can see what happened. And think about why did this happen? Okay, so by jumping here, see, line 28. I see this happened. Problem is here in this case, without further knowledge, it would really be hard to know why this happened. So here, sorry, I have to help a bit. Thing is, I mean, I told you this method is flawed. It's not enough to use the power of inheritance here. On top you have to use, you have to implement an interface here. So we are already implementing car. But for interfaces, I told you in the episode about interfaces, we can implement several interfaces. So here I have now to implement the cloneable interface from Java Lang also. Now, funnily enough implementing the interface, normally, I would expect that I would have to implement some method. Well, in this case, it's different. We don't have to implement anything. And this is a specific case, this interface we call a market interface. So this interface is actually empty. There's nothing in there. It just tells the JVM. I'm implementing cloneable. So you can call cloneable here, it's a clone here it works. And this is a bit awkward, because normally when you implement an interface, you would on the Reference Now, like I can now say that I implement cloneable, I can also make this a cloneable. So that my pietras portion now plays the role of being a cloneable. The problem is, this doesn't help me anything. I don't have the method cloneable. Here, all I have is the other methods of the class object, which we're not using now. So because I can also say car, I mean, I'm implementing, also the car interface. And then I can call the methods of car, which is drive, plus all the methods of class object. Okay, well about macros interface. That's also another topic. This is a design pattern. haven't talked much about design patterns yet. Marker interface really has good users. So a marker interface, generally speaking is not bad. It just here in this case, it's a bit weird that you have to implement a market interface and then on top, you have to override the method. Okay, so I make this portion again. But now, and now the same as already, again, working because otherwise you could not compare different things. Let's try it again. And see, now we have the green bar process finished with exit code. So my first assumption is correct. Peters pushy is not the same instance, as pushy. Okay. So now I want to see who is the owner at the moment of Peters, Porsche, Peters, Porsche, Dodd, s string. And this is why before I prepared this method, because it returns Porsche II off plus the owner's name, because at the moment, we don't have another way of seeing the content of owner's name. So I wrote this method to see who is owning it at the moment. Okay. And my expectation when we're finished is that the name would be Peter. So I would say it should return partially off, Peter. So let's write a test for this. assert, equals, first, the expectation, you also see it expected. So I'm expecting it to say pushy off Peter. Okay. And then comma. And I put here pushy, Dodd as string, which is calling the method. So I expect the method to return portion of pizza later on. I mean, there's also again, a method called equals. In an later episode, I'll talk about this and we will have a better way of comparing that for now. I'm using the S ring method, because we haven't talked about the equals method yet. So there's still something missing. Okay. I can remove that. So let me also execute this test now. And it should be read. Yeah, oh, there's an error. I have missed a semicolon. Again, sorry. Yeah, comparison failure. Expected portion of Peter bar is still mine. Now this is even cooler for me. Now I have actually two portions. But okay, I said you get one. So let's change that. And for this, I will now change the owner. So I will sell on my second car. Okay, and I will sell it to Peter. Which means I mean, I just made this method up before I assign the owner's name the new owner. Okay. Also, by the way, I mean, here I'm using string to have this as simple as possible for our example. Usually, I would prefer to have this proper object also, like, name, for example, and I also already have that here. But in this fast example, I use string. But more object oriented would be if you have name as an object there. Okay, so I sell it to Peter. And now I expect the test to be green. Let's try it again. Okay, it's green, it worked. But now I have a fear. What if now my pushy would not be mine anymore. So on top, I want to assert that the The original pushy is still mine portion of macros to the original portion. K, which also worked. And this tells us now starting from my pushy macros, I called the clone method, it created a new object in memory. And this new object was assigned to the reference Peters Porsche he inserted that they're not the same object to different objects. And then I changed the second object. And I gave it the owner of Peter. So and I asserted that now, the owner's name is Peter, by comparing the string. And second, I asserted that what I was working on the second object, the copy was not influencing my policy. So this is like proving that our clone operation did work. But now let's look at the code. What we needed to do for this, I had to say implement cloneable, I had to override the clone method, I had to call the super clone method, I had to catch the clone, not supported exception. This is a lot of lines for only this. And actually, there's more to it. Because actually, what this does is it creates only a shallow copy, and not a deep copy. Now, again, this is a more advanced topic. So I try to keep this as short as possible. What's the difference between a shallow copy and a deep copy? Okay, well, a deep copy for this, I have prepared here a more complex object BMW. And here I'm using actually the object name. And I'm even using a second object color. And let's make this a bit bigger. So you see more, a deep copy would mean that not only BMW is copied, but also all the objects inside of BMW are copied. So that they are also independent, that they're not referencing the same object. But a shallow copy will here, only copy the reference. And the object for name, as well as the object for color will still be the same objects for shallow copy. Sometimes this is okay. And sometimes it's not, it really depends on your implementation. However, in short, if you're using clone want to make a deep copy, you will also have to call clone on the internal objects, and this here, I have prepared. So here, I'm calling clone actually, three times. Now, one more problem of the clone method is what I'm actually doing here is, first of all, I cloned BMW, and then on this attribute, and this one, which is already fully functional, I assign a new value, which only works if this is not final. So it turns out not to in order to make a deep copy, it only works if your internals are not final, and sometimes you want them to be final. So this is really a limitation of the clone method. And also, I mean, how complicated it is, is not so nice. Okay. Um, and for this, there are alternatives I told you. I've written here a lot of code. I have written this code so I could show you what to think. Yeah, I would want to make this episode not as long, because I noticed many of you are only watching like the first minutes. So 95% will already be asleep anyway. So let's keep this short. So in short, let me show you alternatives to using the clone method. There are two alternatives. The first alternative is using so called copy constructor, and this is this thing here. The copy constructor has one parameter, and this is the same object. And then you see here, I say new name, on owner's name, new color on BMW dot color. So I'm taking the internals and I'm creating new objects on it. And so in the end, I will have a new object that has the same values as the original object. This is One alternative. The other alternative would be, and this is actually my preferred one to use a so called static factory method. And this is this here, it's a static method. So you can directly say BMW as the class name dot new instance, you can give it the BMW object you want to copy. So in this case, probably Marquess BMW. And then you You see, I again, call the constructor, new BMW. But here, this is a more complex object. So I have to recursively we call this recursively. Because again, I say new instance. And he also new instance. And I have to again, call those methods to also cop copy the owner's name, because now I'm actually doing a deep copy, I could have also just assigned the values, this would be a shallow copy, but it's safer to have deep copies. Okay, so And for this, we can also have a short look into name and color. Because there again, I do the same thing. Here I have my new instance method. So this is taking a parameter of name, and then says new name, first name, dot last name. Now, first name and last name are both strings. And strings are also objects. So why do I not need to copy down? Okay, now it gets more and more complicated, I'm sorry, um, thing is a string as an object, but it's actually an immutable object. And immutable means whenever you change the object, like you assign, instead, first name, Marcos, you say, Peter, you will not influence the other reference. But instead, whoever said make this, Peter will get a new object. So this was really helpful. And for string, this is done for you. Actually, you can do this for your own objects too. And in order to achieve this, you just have the limitation that you don't offer any method to the client that allows the client to change the values in here. But instead, you will always for any change, return a new instance. And then you have an immutable. For this, I have also here an immutable test. Because there's another class that actually does it, which is big integer. Big integer is similar to an int, that we already looked on it just a bit better. First of all, because it can work on ends of, well, at least theoretically, any length until your memory is full. And there you have operations to add and subtract, for example. Now, when you say one, add one, this is returning a new object to but the original object will not be influenced by this operation, you can also subtract, but everything that you call, every method that you call will never influence will never change how the object looks. So it's created once with the constructor, this will like assign one to it. But after this, you can never ever changed it again, which is very helpful. In many cases, it's really a good design principle to use immutables whenever possible. Um, yeah, and it's also very good to use multiples when you do code multi, multi threading. We haven't talked about multi threading yet, we will at a later time. But there immutables are also very helpful, they will make everything more easy. So, maybe you take one more thing with you from this episode. And this is favor immutables try to design your objects your classes in a way that they are not mutable, that they cannot be changed after they were created. Or came here at the same thing with string. Maybe I can show you so I call so assigned twice Hello, which in memory is actually the same object. But when later on here, I Say hi. This will influence the string one, and not influence a string to let's execute this shortly. So you see, like the speaker so we can see Bo's bigger even. Okay. So now I see the first string here printed Hi, the second string printed Hello. And so they're not equal, the first one has high, and the second one has Hello. And if I remove this, this is why I had commented it out. Let's execute it again. Of course, now they both have Hello. So that's the difference. And this is one example of an immutable strings are, by definition immutable. Maybe we could also call this here. So I print out any n 01. And two. And also, I assert to do a few things. So the input value of one is one, the input value of two is two, and the end value of zero is zero. Well, I'm operating on these objects, they will always return a new object, return a new object, they will not influence the original object, this is an immutable, this is something that you should try always to achieve our K, let's go back to Chrome. Let's recap. So in order to properly use clown, you have to first of all, override the clone method so that it is public. Second, you don't have to, but it's recommended. Use not object here, but use the type of the class that you're in, then you will have to do an explicit cast to the class here. Catch the claw not supported exception, thrown your assertion error, which will show you in case you forgot to implement cloneable, which you will also have to do. However, what this is going to achieve, it will create a shallow clone for you. Which means if there are objects that are not immutables, and you then operate on those objects, this can break another object, because still you're not totally independent, you're only potentially independent, you're only on the first level independent. But if here you have name, this will only copy the reference and the object here would still be the same. If you also want to achieve this, you have to implement a more complex clone method, you have to also call clone on the internal objects and then assign the new clone values to your internal attributes, which will only work if they are not final. So this already limits the way you can implement your code. See if this is not working now. So and this is one of the one of the many, sorry, one of the many reasons why you should not use clone, other than to clone an array. And I showed you two alternatives. One is use a static factory method. I call the new instance. Same like Josh block in Effective Java that you should buy. And here, I call the constructor. And again, recursively. I call again, a factory method on name. And again, a factory method on color, which even creates a deep copy. Or I can do the same thing with a constructor. But you see this is actually shorter. So this is why I would prefer to use the factory method. But it both works. Okay, so here, I call twice a new constructor, I create a new name object, and I create a new color object. Okay, and then in name, we can also look. You see, I do the same thing. And this now is strings and I said strings. Now we don't have to call clone because a string is immutable. So you have to do this recursively until you reach either an immutable object or a primitive. If this were again, like first name object, we would have to continue with cloning, or copying, like calling the constructor until you reach either a string, or a primitive value or another immutable object. See here also implemented clone. And then we can also look at color one last time. For all of them, I have done the three different implementations here with a static new instance method, here with a clone method. And last but not least, here with a copy constructor, it receives a color object, and then it retrieves the string from the original object, which is a string, which we don't have to clone any further. I'm actually going to talk a bit about various smaller topics. We're still on track, talking about the class object, and all its methods. The last two methods I need to tell you about are hashCode. And equals. Actually, they're one of the most important methods in Java, I think. However, hashCode and equals are a bit more complicated to explain. So before I can tackle them, I decided to push an episode in between to straighten things up. And to talk a bit about the missing pieces in this episode. Okay, so let's start. As you see, I have prepared this demo test class for you. Actually, we're not really testing something today. This is really only to use to demonstrate those few small missing things. So let's do one by one. And the first thing is, I want to talk about static imports. You might remember, I think I talked about static imports, in the first three episodes, and I kind of promised you to later on give you more details about it. The problem at this time was we hadn't talked about static. Well, in the meantime, we have, I just didn't have any better opportunity to talk about it. And I felt a bit guilty. So I think now, I should really finally tell you what exactly is a static import, how you can use it, and what it helps you. So actually, we used it all the time. And you might have seen it. Here on top, I have this import static org j unit assert dot star, it's just grayed out because at the moment, I'm not using it. This is also set here unused import statement. Now you can see it. And you can also see here, the regular import or j unit test sub question is, what's the difference between the two of them? So this one imports the code of the whole test class? Well, this one here, a static import just focuses on all the static methods. Because in j unit, you know, when we want to test, we always use these assert methods. assert equals assert true. Let's do that now. Like assert. True, you see, it already helps me true. I mean, when true is always true. There's a stupid, but I just want you to see the method. And the thing is, this is only not working because I have this here assert and seeing, it's not great anymore, it turns white, because now it's in use. So let's actually have a look at this class, I can jump there, you see even it says it extends object will no wonder all the classes extend object anyway. So here you see, I see the decompiled code. This is what my ID he can also do to show me the code. This is very helpful, so you understand better what happens behind the cover. So you Here you see a lot of static methods. So this class actually like groups them and makes them usable to me. And as you might know, from static when I talked about static, the way you would use a static method would be normally you say class name, dot assert true. Now you can either use the full fledged class name, which is org dot j unit dot assert, and then assert true or if you don't want to use the package, you would import the class and then you can just say assert dot assert true. Of course, there are also other methods, you can have a look on those, by yourself. actually quite complicated ones like you can even compare areas, and so on and so forth, not equals equals, with message without is equals, and so on. Well, we have used some of them. So this means I can also say, assert dot assert true. But now you see this is not working, because I have not normally imported the assert class. So if I would want to do this, I would have to say org, J unit dot assert, and then import it like this. Now you see it's not used anymore, because now I'm not statically importing it, but regularly, and I'm using the class name to use the method. But I mean, when they introduced it, I think this was with Java five. The reason to introduce this where it was to just make these statements shorter, because you don't always want to write assert dot all the time. Okay, and you could also do it as said before, without any import, this would even be more longer than you could go without the import. Now, they are not see, but there it is working. That's the difference, because now I don't do any import. Let's put it back. And then we can go with or without. And if you wanted like this and the shortest form, you need the static import and not the regular import. So that is a static import. And the dot star means just input all the static members or members, static is not members, all the static functions and also the static variables of the class. So if you have variables you want to import that are static. This also works with the star operator here. But you can also say you import only specific functions or attributes. So this is up to you. Okay, so that's all I can tell you about static imports, I think sometimes they're helpful. More often, it actually happens, then you would think that you would import several methods or attributes that are the same in different classes. If you have that it's exactly the same, like I told you about the imports, you can only import one method name once by using a static import. If you're not have a second class that has the same method, you will then have to use the full fledged, or at least a class name so that the JVM, the compiler knows, in this case, I want the assert true method from this class. And in the other case, I want the assert true from another class. Okay, so you can't I mean, there must be a way that the compiler understands what you're trying to do. If I only import this statically once, I mean, then it's just obvious the assert true is part of the assault class here. Oh, okay. So that much about static imports. The next small thing I want to talk about, let's open this up is default values for different data types. I think this is quite important. And also interesting. Because I see many people that would have here, member variables defined. And then they would say something like, here, or for cards, different weight. Like for the Boolean, they would say false. Or for the object, they would say novel. And you don't have to do that. Because now for object, as well as false for a Boolean is the default. So this is in my eyes, this is just clutter, you write code that you don't have to. I mean, for every rule, there's always an exception. For example, if this is very important that this is set to false. And this is really a specific case and you want to give a message with it. It might make sense to sometimes right here explicitly false. But then it also maybe you should name your variable a bit different so that it says why this is important. And because my Boolean now I mean, this might be the problem. It doesn't say why this is always false. Okay, so And now let's have a look at all the different defaults. But when I say default, this really only applies for these member variables up here. If you for example, have a local variable Like Boolean, B, you can't do that, if I'm not trying to use it, this is not going to work. If b, this will give me a problem variable b might not have been initialized, but it does work with the Boolean up here. This is going to work, see, and now it will count as false. So the if would not be executed the branch. Okay, but now enough of talking, blah, blah, blah. You might already be asleep, so wake up. Okay, so let's make this a bit bigger, so we can see it properly. Okay. Now, so you see, by default value, short default value, those are all zero. Actually, there are many number types that we haven't talked about. And this is also what I'm just going to introduce right now. Because we totally focused on end, because this is actually the one that is most times used. But as you see here, there are also others. I think I shortly once showed you bite, and I also showed you one's car. Um, but there are also others. In my opinion, this is just the smaller data types, we will see the ranges very soon are only here because I think like this or similar, they existed in other programming languages before Java, like maybe c c++. In my opinion, this is a The reason is probably because like something like 30 years ago, the memory was so expensive. And that was really the memory space was so limited, like you would have a memory of, I don't know, a few kilobytes. Now with gigabytes of RAM, this is totally a different issue. So the space end users actually a bit more bytes. But the space is really not relevant these days, in 99, and probably 99.9% of the cases are always use int. So wide and short, in my personal opinion on something like deprecated. I mean, this is not true, actually, because I'm sure someone can tell me there is a specific case where you would need them. It just that on average, generally speaking, you should be fine with an int. And we will look at actually the sizes of these types in a second. So yeah, that long is actually bigger, can save longer numbers than end. This sometimes might be needed, but also not so often really, I think, now float and double, as the name implies, at least for float, they're both floating numbers. And double, I think the name comes because it's like double the space or something, then that of a float. Actually, also these I hardly use, because first of all, I personally did not worry too much with these kinds of floating point calculations. And second, in case I did, for example, calculating on money that you would need that. But they are they are quite problematic, actually, because they don't calculate properly on the scent, it can happen that when you have something like two euro 20 multiplied by, I don't know, divided by a number of people that in the end, you lose or you gain a cent. And like in India, in the financial industry, this is just not okay. So therefore float and double can't use be used there. The reason I can't perfectly tell you but I think it has to do with internally these numbers of course stored in a binary format, you know, a computer only knows zero and one. And then when, from this format, it's transferred to our decimal format. For those floating point numbers, then there are rounding issues. And therefore, when you really need to have a correct floating point result, there are various other solutions. One is to store the number without the floating point, for example, as a long or end or alternatively even as a string. And then you do your calculation, and when it's finished. You insert the floating point visually at the place in the UI where it's needed. Which is also dependent on like local settings, like numbers are formatted differently in different languages. So therefore, this is usually the way you would go, at least definitely in the credit card or in any financial industry. Okay, so anyway, float and double are both floating point numbers. What is interesting, by the way, is like, when you have a constant value, like 34 43.31, this here, I mean, this is a value of constant value. And if I just write this down like it is at the moment, this is now by definition automatically a double. If I want to have this as a float, I have to say, the capital a lowercase F, at the end, which makes it up float. So, if I have like float my float node equals to this, or he really have to say f at the end, because if you leave it, I would get a problem, because it says it found a double, but float is required. And the same applies actually for int, short bite, there is just the other way around, because there is the default. And when you want to use a short short as equals to 43. This just works implicitly because Java sees the space is fitting. And then it will just implicitly convert the end because this is really an end to a short. Ever. Let's try the same thing with a long, long for d3. This also works because now you try to store the smaller thing, the end into a long, which should always fit. Okay. So what else, so we have object, the default value is now as I said before, Boolean, the default value is false. Car. Now this is interesting, it depends on if you safe if you display this as a car as it is. And then this is I think it's called the null character. And I think this is just nothing or maybe space here you see there is something it just can't be displayed by my UI. I mean, here, if I try there's nothing blue. But here when I go over it, it's displayed as blue because there is actually something it just not visible. And I can convert this character, the default character to an end. And then it's a zero. Okay? Now, so these were the default values of the different number data types as primitives. Okay, and now, as the next topic, I also want to tell you never told you so far, all these number types, they in parallel also exist as objects. Let's have a look, and then see and discuss why that is. Okay, so you would have bide my, this is used already on top. So let's call, let's just call it b equals to bite dot value of now, this is a static method method, which can and should be used to convert convert, sorry, a byte primitive to a byte object. You can also say new byte. But this is just not recommended because this might use more space. So, I don't want to go in details because then I could talk forever for performance optimization. But this is just creating always a new object, while the other one might reuse an existing object of the same value. So, this usually is good enough. Okay, there's also other methods, static methods like pars. The difference is, this works not on a string as far as I know, let's try to Yes. And let's go into the function See, I can Also see it here. And this converts it not to the object, but again to the primitive. This is the value of it converts it to abide. He even you can give the radix, like the radix of 10, or eight or 16, or whatever. This usually, well, I never really needed. But there are a lot of lot of functions. What is also interesting is that these objects, they all extend the abstract type number, abstract class, we talked about inheritance already. So you're here you can see all these different functions that each of those number types have to implement. So each of them, you can convert to an int, long float, double as the primitive value. The green stuff is, by the way, the Java API documentation that you can also read online, short. So this, all these types automatically will have. Okay, so back. Now, besides offering these cool methods, that might be helpful. There is also another reason why these exists as objects. The reason is, I think, mainly because there is something called collections that we will talk about very soon. I think I even mentioned it shortly, it's something similar to an array, it's like an array on steroids. It's just a container that you can throw in objects. And that's really it, you can only throw in objects. And so you could not throw in any primitive. And therefore, this is also called a wrapper type, because this object then will wrap around this primitive type, and can be wrapped and unwrapped. Which by the way, in the past, when working with primitives and collections was needed. So before putting it into the collection, you would have converted your primitive data type, like the CMI byte, input, the object would then have, let's just say collection, let's just say add, I mean, in reality, it looks a bit different. But just so that you get an abstract idea, you would have added this thing here. And later on, when you wanted to retrieve it again, you could then say, wide dot, get the byte value. And then again, there were people saying all this is just too much work. And so I think also, with Java five, there was an auto conversion introduced, that now Java can work with a primitive and an object, and will automatically behind the covers convert a primitive to an object and an object to a primitive, whatever is needed by a certain function. Now, this is heavily in used by almost every developer, I really don't like it, and I really activate in my ID, that I get displayed these conversions. Because for one, this could even be an issue with performance, because I see functions that would like convert from a primitive to an object, and to a primitive and so on back and forth several times, which is just stupid. Second, for a primitive, you have the default value of a zero, that is safe, that will never throw a null pointer exception. Ever for an object. When it's not initialized, like here, the value will be now and then when you on an object call, b dot byte value, this will actually throw a null pointer exception. The problem is you don't see it, because it'll be automatically be inserted by the compiler for you. You only see it at runtime and then you get a nullpointerexception. So really be careful with these automatic conversions. I personally hardly ever use them. Okay, but so, so that you know of each of these primitive number types There is also the same type as an object. The names are pretty much always the same, like there's a short object. For int, it is integer. So there's an integer. For long it's long. For float is float and double, it's double. And also Boolean exists as an object. Which by the way, also has static Boolean object values. So you can even say Boolean be laughter Remove the bite. Because this is also B, Boolean b equals to true, or equals to false. But now this is an object. I can also show, you know, the automatic conversion works. Even though this is an object, the aesthetic value here, can even jump there you see public static, final Boolean false equals to new Boolean false. So the cool thing when you use this is there's only one object that is always reused, and you don't always say new Boolean, to save some space. Okay. And now you see, I can assign this object to the primitive type, because internally, the compiler will do this for you, you just don't see it. Okay, so that's, I think, all I can tell you about the different number types and their object variants. Now let's have a look at their ranges. I said for example, byte In short, they have smaller ranges. But enough of talking, I think the best is I just show you. So execute the test. And we see, let me scroll this down. I think this makes it easier. Because then we can see the test and the code in parallel. Okay, so here, I used the system print long. Remember, don't use it avoided. Just try test, it doesn't really matter. I just shortly wanted to show you the results. Otherwise, in productive code prefer logging, because it's more flexible and would probably lead generally speaking to more performance, okay, but enough. So here you see. So there are signed types and unsigned types. Signed means you see, there is a minus, so it goes from minus 128 to plus 127. Interesting is, this is not 128. But 127. While he is 128. This actually is for all the sign types. The reason is, the JVM in your memory of your computer will actually need this one number to store the information if it's a minus or a plus. And this is why they had to take one number away. And they just decided that minus has one, one more number than Plus, I mean, they could have also done it the other way. But this is how it's done in Java. Okay, so you see, this is only for very small numbers. 120 minus 128, two plus one and 27 short is already much bigger. It can store 32,000 something plus and minus again, one less here on the right side in again is much bigger. I think this is like 2 billion or so long, again is much bigger. I don't even know how long this number is. Um, yeah, usually you should be fine with int can in some rare cases you need a long Yeah, actually, sometimes I needed a long Okay. And then there's his float floating point number with the exponent minus and plus and the double see here even is much bigger 324 to 308 minus plus and the car this one is unsigned. So, this is why there is no minus which is also why the size here is 65,000 something is the double size down to the short because the short has the same space, but it needs to have it in a signed form with a minus and a plus. So this is why here we can store zero to 665,000 Okay, and car as you have seen before, usually is used not to store numbers, but characters. But if you convert it to an end, you can also use it to store numbers unsigned from zero to 65,000 something okay. I think this is actually interesting to see all these ranges. Okay, so these were the ranges let's go to the next. And so, in order to be able by the way to show you see here I converted this two intz and also our This is also interesting you see here I used actually the object, the objects and the These are static values, which gives me the min and max value. This is really handy. When you need those ranges, you can just use them out of the box and say min value max value, because I wouldn't know them. Yeah, directly, I can just look them up. And Java will tell me then, okay, let's close this now. And go to our next test. Because now, what I want to show you is actually, you can also save your numbers, not only on the base 10, but also on the base to base eight, and base 16. So now it depends. I don't know, if you had this already in school or university, I'm assuming you had, they should be really easy for you to understand that, for example, with the base two, you would store you would display a number would be displayed differently, then with the base 10. If you never heard of this, then don't don't mind this really is not so important. I think I never needed to display the number in one of these formats, decimal was always fine to me. I mean, this is also the way the value will be stored here on the left side is always the same, no matter which bass you use. So this might just be used, because you are in a certain domain and a certain business area where you need, for example, the hex. And so you would, for example, have documentation that speaks of a hex value. And so you could have the same value as you have them in the documentation here in your code, which would make it easier possibly to look at the code. However, this has nothing to do with how they're stored. I mean, they're still stored on your computer in your memory. And your computer can always only store them as zeros and ones. So internally, no matter what format, you use them internally, they're saved always in the same format. And by default, they're also when I print them out, which I'll show you in a sec, they will also always be printed out on the base of 10 just like a regular number like you know them. So this is only a displaying issue in the code. If you want to display them in the binary format, you need specific formatting options. This will be an episode on its own. So I will not go in detail on this. Now. Also, I think this is not needed in many cases. What is also interesting, by the way, I mean, the space two was introduced with Java seven only. So this only recently got added. Speaking as of 2015, before, you had only the option to store, base 10, base eight and base 16. Now the Edit base two besides to make this stuff more readable. I mean, especially with base two, you will get these long strings here of zeros and ones. So that you could easily read this. And also for something like credit card numbers, you can add these underscores actually as many as ever you want. You're just not allowed to do it at the beginning of the string and at the end of the string. But I mean, I don't see how this would make any sense, because this wouldn't help to read it. So this is why you put them here in between, you can also add more like here. Now the question is, is that more readable? In this case? Of course not. But I think it can be quite helpful, especially for something like credit card numbers for long numbers that you can read them more easily, like on the phone talking to a colleague, and you want to read out the number nine you can talk about the blogs makes it easier. But these underscores again, this is just the displaying issue in the code. The way they are stored is exactly the same like before. So now let's execute the test. So I mean, so that this gets printed out, and we can have a look at it. Okay, so here you see the first one ob this just indicates I'm storing the number in binary. The number is given in a binary format. So this is just the zero. You can use the capital and a lowercase it's supposed to same. So this one is an apple On this long thing here, so ob four is binary format, and undo redo Do you do all this, you can use your calculator and calculate it. And in the end, you will see this is this number in decimal format. Or K. By the way, of course, just shortly, binary format means you can't, for example, use a three, this will give you an error, integer number two large, because now we are in binary format, indicated by the B and zero here with the base eight, and scroll down. It, it started with a zero only. So zero and seven means this is a seven now, but 010 is actually the eight in the on the base of eight. As I said, if you know it from like school or university, you will understand what I'm talking about. If not, doesn't matter. Not important. Yeah, you will hardly ever need it. Let's have a look at it. So as I said, this is the seven, this is the eight. And this is some large number. So these underscores are not displayed in here. This is just to help so that it's more readable in the code. And the base 16 hex code is started with zero and x. And then the zero is 01. The F, you know in Latin, no, I think our numbers are not Latin, their Arabic numbers. And these Arabic numbers, they are based on the base 10. So nine is the last number. And when you want to say 10 you need one zero, while on the hex, you don't have any more Arabic numbers. So therefore they used ABCDE, F for 10 to 16. So the F is actually the 16. Let's execute this. Well, I was lying to you. It's the 15 in this case, because we start with the zero. No, yeah, it's the 15. Because the 16 again, would be one zero. Okay, yeah. can get really easy, confusing. Sorry. So anyway, I mean, I think it's not so important. It's just interesting to show off. I mean, like in a job interview, I think you really should know, Java inside out. And so I think you should know that this is possible. The question if you personally will use it, because you personally in your project will need it. I don't know, depends, maybe you need it. But if you need it, it's here to be used. Okay. So now, I think really did an in depth view on all these small topics. And I think this is really now a good base to talk about hashCode and equals. Going to talk about the two methods equals, and hashCode. This tutorial actually concludes my presentation of all the methods of the Java Lang object class, equals and hashCode both follow a contract that ties them closely together, which is also why I'm talking about both methods in just one episode. Knowing all the details about these two methods, will make you a better programmer today. So get yourself some popcorn, and listen carefully. So let's start with the equals method. What does it do? What's it actually useful for? the equals method is used to compare two objects for equality, similar to the equals operator, which is used for primitive values. But before I'm going into much more detail, let's first jump into my ID and see this in action. Now in my ID, let's first of all, see, what do we need the equals method for anyway, because so far, we happily used the equal equal operator, and this was working. Let's see this again, with two primitive values, I equals four, and J equals four. So now I assert, with the equals operator that they're both equal. And we get the green bar. Old tests passed, everything is fine. So i equals to J. Now let's do the same thing with strings. Here we have a constant value of Hello, and another constant value Hello. And each has assigned to its own string, reference variable. Now, we all Want to compare these two strings with the equal operator? Let's try this. And Ted Ah, this is also working. And I told you a string is an object. So as this is working, it seems we don't need the equals method at all. Well, with a string, it's a bit tricky, actually. Because with a string, there is some optimization going on in the background for constant values, because for this constant value, there's actually only one and both variables, they both point to the same object in memory. The variable is stored in a memory area called stack, the object is stored in a memory area called heap. And there's only one, but things get quite differently. As soon as I add a new string variable, and always say, string hello, three is only age. And then I say at runtime, hello, three equals two, hello, three, plus, concatenate ello to it, which will be Hello, at runtime. And just to be sure, let's also print this that we can see there is really Hello. In the variable, hello, three. And then let's assert, hello, one, equal operator Hello, three. And this is not working, we get the red bar, nasty, nasty. So now they're not equal. But here you can see it printed out Hello. So from our expectation it should have been equal. So this is something really tricky with string. And ensured you should not use equal operator on objects, also not on strings. Instead, for strings, there is the equals method. Let's try this. Hello, one equals Hello, three. This works, it seems like using that method, they're both equal. Now, let's have a look actually at the method. Here we are clustering. And there is a method equals operating on an object. It says things like if this equals to the object given return true. So if it's the same reference, if it's the same object, this is actually a performance optimization. Now it checks that the object is actually a string. This is achieved by the instance of operator so that we can safely cast the object to a string. And so that we can compare both strings. Interesting thing about instance, of By the way, which not many people, many developers know, or at least not all, yet. This also includes a check for now, if an object is now this will never be a string will never be true and will return false. So anyway, without going into further details, there's this while loop. And this compares character by character of both strings. And only if they're completely equal, it will return true. So this is how equals was implemented in the class string. But actually, I told you, the equals method is a method from the class object. And yes, it is. Well, it turns out string is also a subclass of object and the string class overrode the equals method here. So then it works on strings as expected. Okay. So it seems like for strings we can happily use equals, so that we know that a string like hello one and hello three is equal. Now, how are things with classes that we implement ourselves? Like here I have created a class car with owner Marcos. It is a Porsche and it is it has the color silver So it seems like it has both instances have exactly the same attributes. So I would expect them to be the same car. Now let's first of all, try it with the equal operator, like before. And this is false. It's not working test failed. Well, of course, because we have two different instances here. Let's try the positive case. portion one, equal operator, my Porsche one again, comparing it to itself. So yes, this is working, of course. But it seems like for to be able to compare Porsche one and Porsche to we again need to use the equals method. Let's do this now. For sheet one. Oh, let's first of all, I want to push it to here. But let's also do this, my portion one equals my portion one, I would expect that to be true. And yes, it is true. My Porsche one, so it is equal to itself. Now, let's compare my Porsche one to my Porsche e two. And let's see if this works. Huh, it's not working. We have the nasty red bar. This was so nicely working with a string, why is it not working with our car? Let's jump to this method again. And you see, we're in the class object. Because in our car class, we have not overwritten the equals method. So what happens is, the original method of the class object is used. And as you can see here, internally, what happens is, we compare this which is the object itself, in this case, my pushy one, we compare it using the equal operator to the object that is coming into the method, which was pushy to. And this compares only the reference variables and not the objects. So this is false, because we have two different reference variables. What by the way, is also possible. To make this true again, we could assign my portion to the reference variable of my portion one, which would mean this object is somewhere in memory, no variable is assigned to it. And there is this one object here in this line, and both variables, point to it. Let's try this. And see if this works. Because now actually, we only compare the same object with each other. Like here. This compares the reference variables, which now have the same value. So this would be working. But this is not what we want. So let's remove that we really want to compare both objects. We want to compare this one with that one. Okay, so let's have a look at the class car. This is a small class I wrote. And it just has a constructor and these attributes for now. And there is no equals method overwritten. So this is what we have to do. Public Boolean equals now, I want to compare a car car. No, this you cannot do in the class object. There is object. So we have to say object here. And then later on, we have to cast it to a car, like we saw on the class string. And then it's always good to add the override annotation so that we make sure we have properly overwritten the method. Now, I mean, this is not a true implementation. I always return false, just to see that when I'm in my car test, not jump there. See, it jumps to me. I overridden method. Now, of course, when this always returns false, this will also not work. So we will have to implement it. But actually implementing such an equals method is not so easy. And we need some more theory for this before we can continue. So let's first of all, jump back to my slides. Before we are able to implement the equals method, we need to come up with a proper design first. Actually, many developers just skip the design phase, and simply click on autogenerate. But this may lead to severe bugs, or at least two sub optimal performance. Let me show you how you can properly do it. First of all, you have to define what it is in your specific program that makes two car instances equal or unequal. In your program, are two cars equal when they have the same manufacturer, maybe when they have the same manufacturer in color, or the same engine, the same number of wheels, the same top speed, the same vehicle identification number, or when In short, based on a knowledge of the business you are working in, you have to decide which fields are identifying, and which fields are redundant, and not helpful for the equal comparison. Besides for improved performance, you need to define in which order you want to compare the attributes. Are there any fields that have a high chance to be unequal? Are there fields that may be compared faster than others? To implement a meaningful equals method, you must first analyze all these aspects in great detail. Let's go through this process. With my example. I would assume that the car's top speed relates to the type of engine and some form. So that seems to be a redundant field, that will not be helpful for the equals implementation. So let's just remove it. Let's just say the number of wheels is always for in our specific example. So number of wheels would also not help us to differentiate the car. What about the VIN? Well, this again depends on the type of program you want to create. For a public authority like the police, this one is probably the only proper way of identification. But what about a program used by the manufacturer itself. While the car is still being built, and not sold yet, I would assume the witness of less importance. But I personally wouldn't know that in detail. This is what you will have to clarify with the business people of your company or your department. Based on their knowledge, you have to select which attributes to compare in which order. In my artificial example here, I'm the developer as well as the business analyst. So for my example, I just arbitrarily define that two cars with different wind numbers can be seen as equal. Therefore, I will not include this field in my equals comparison later on. Now, before you think that's it, I'm sorry, there's actually some more theory to cover. In the introduction, I already told you that there is a contract of equals and hashCode we have to fulfill. First of all, there are five conditions, our equals implementation has to comply with, believe me, it looks much more scary than it actually is. Let's go through each of them slowly. reflexivity. An object must be equal to itself, so that when I call my old car equals my old car, it returns true. I think this makes sense and should be easy to understand. symmetry to objects must agree whether or not they are equal. If my old car equals some other car, then some other car equals my old car must also return true This sounds obvious and very simple, when in fact, it is not such a simple condition when it comes to inheritance. If you have a car class and a BMW class, which is extending the car class, it could happen that your BMW is equal to a car. But the same car is not equal to the BMW is every BMW is a car. But not every car is a BMW. So you see, the symmetry rule can actually lead to some nasty problems. There are quite a few interesting articles online discussing potential symmetry issues of the equals method. cover each contract condition with a dedicated unit test to make sure your class is fully compliant with a contract. Our next condition is transitivity. If one object is equal to our second, and a second is equal to a third, then the first must be equal to the third again. This rule sounds much more complicated than it actually is. If object A is equal to object B, and object b is equal to object C, they should all be equal to each other so that C is also equal to a consistency. If two objects are equal, they must remain equal for all time, unless one of them is changed. So when you repeatedly compare the same two objects with a equals method, it should always return the same result. In other words, calling the equals method should not alter the object in any way. The last rule model returns false is what Josh Bloch calls nonlocality. When knowledge is given as a parameter to any equals method, they should always return false and never throw a null pointer exception. So now, you know quite a bit about the equals method. But what is the hashCode method actually useful for? For processing similar objects are usually put into a collection. Such a collection in Java is like a more powerful array, or an array on steroids, as I often call it. Besides other things, it allows you to look up objects not only based on their index position, but also based on their specific values. This is where the equals method comes into play. To speed up this lookup process, the Java creators added specific hash based containers that will use the hash value as a grouping mechanism to reduce the number of equal comparisons needed. In the optimal case, each object that is considered unequal by the equal method will also return a different hash code. This hash code is used to group the objects in so called buckets. Now, in this optimal case, you will be able to find each object simply by a lookup based on its hash value. However, there may also be something called hash collisions, where two unequal objects will share the same hash code, in which case they end up in the same bucket. Now, if I'm looking for that scar, I have to look up the correct bucket based on the hash code minus 391. That car will return. However, as there is a hash collision, I will on top have to do an equals comparison on a list of two cars in this case, illegal but inadmissible bad performing hash code implementation could statically returned 42 for all objects. In this case, however, the whole hashCode logic would not help at all. In the end, you would have to do an equals comparison on the entire list of cars just as if the hashing logic had never existed. Okay. Now that I have talked about the general idea of the hashCode method, I have to further tell you about the contract that the hashCode method has to fulfill. The first condition that has to be fulfilled by the hashCode method is for any two objects return same hash codes when equals returns true. To achieve this, use the same idea Define attributes for both methods in the same order. Don't worry too much. Now, if you don't fully understand what I mean. As soon as I'm finished introducing you to the hashCode contract, I will jump back in my ID and show you a practical example. When hashCode is invoked more than once on the same object, it must consistently return the same int value as long as the object is not changed. This role is similar to the equals consistency rule, I introduced to before both equals and hashCode methods must return consistent results. To fulfill this contract, you should override hashCode whenever you override equals, and vice versa. Also, when you add or remove attributes from your class, you will most probably also have to adjust your equals and hashCode methods. Last but not least, aim to return different hash codes when equals returns false. This is not a hard and fast rule, but it will improve the performance of your program by minimizing the number of hash collisions. to the extreme, the hash code contract would allow to statically return 42 for all objects, as Josh block states in his book Effective Java, however, this could result in quadratic rather than linear execution time, and therefore, could be the difference between working and not working. Actually, the hashCode method is a rather complicated beast, I couldn't practically fit in all the details without risking that you would fall asleep. Therefore, I have done a follow up tutorial, that will give you an in depth view on the hashCode method, which you will need to understand to become an expert in Java programming. Below this video, there's a link, you can click to watch my follow up tutorial for the hashCode method. For now, that's all the theory, you need to be able to implement your own hashCode and equals methods. to round up this topic, let's jump back into my ID to show you some practical examples of hashCode and equals methods. So back to my ID II, you can see I've implemented both equals, and hashCode based on the fields manufacturer, engine, and color, also here and hashCode, manufacturer, engine, and color. So I've implemented them based on the decisions I made during the simulated design phase that I did during the theory session. So the car clause has fields like Vehicle Identification Number, Manufacturer, engine, color, and number of wheels. But in the design phase, I decided that number of wheels and Vehicle Identification Number are not helpful for the way I want to compare a car. Of course, this is totally arbitrary. So this is not how you would do it. I really can't stress that enough. In your case, in reality, you have to talk to the business people and find out what is important and what is not. Also totally arbitrary is the order that I've chosen. I just thought about it. And I thought that while there are millions, or however many colors that for usually for cars, there are not so many colors. I think most cars are either black or white, silver, blue, red. A few might even be green, or yellow. But that's probably it. So I thought they there are probably more different manufacturers, and also more different engines. And I want the equals method. If I compare two objects which are not equal, I want to leave the method as early as possible, because the earlier I leave the method, the faster the entire code will run. If two instances are equal, then usually it has to go till the very end. So in this case, it doesn't make a difference. But it does make a difference if it's not equal. If we can leave the method here. So for perform performance optimization I have chosen this order on. So this is what I would also ask you to do, think about a good order to improve the performance. And if the performance is important, then you should test it, because you never know for sure until you test for the performance. What is important that the order is the same hashCode and equals. And now, we should also talk about all this stuff here on top. This mostly is also a performance optimization, at least here, this equals object. So, if I compare the object to itself, I want to directly return true, because then the reference variable references the same object in memory. And so I directly know it's the same object, I don't have to compare all these things. So, this is why I have this here. If you have a specific case, where you know that you will never ever compare an object to itself, you might even leave this if a way. Yeah, this is the this depends. Generally, this is done, because such a check doesn't also cost a lot, then this object equals null return false is actually very important here. This is the last rule that we have to fulfill that when an object that we compare is now that we always return false, which is also important because otherwise object dot get class would throw a null pointer exception that this cannot happen, because now we are already, we have already left the equals method with false. Okay. And then the third, if check compares both classes. So that we make sure that the object that is coming in to all equals method is also a car. So that we're not comparing bikes and cars, for example, or cars and apples or whatever, right? Because otherwise, also, this explicit cast to car would also throw a class cast exception. But now that we have made sure that they both have the car class, we can safely caused the object to a car. And now I think this is quite interesting. Because now I can easily say manufacturer equals other dot manufacturer. This field here is private. But because we are here in car, even though that this is another instance, but it's also an instance of car, I can directly access this private field. So I don't have to use any method, I can directly access the field. This works and makes the code I think, much more readable and shorter. So if it's not equal, then I can directly leave the method and say return false. I do this with all the fields. And if I'm here, that I'm sure that all the three fields are equal. So I do not compare number of wheels as well as we equal identification number, because as I said, about them, I don't care because number of wheels, in my specific example would always be four. So would be the same anyway. And we equal identification number, that might be two different cars. But just like, if I'm only interested in the price of a car, for example, or the look, then I wouldn't care that actually, they are physically two different cars. I would just say well, this is a BMW with I don't know, that kind of engine and Lou. So for me, this is the same car. Period. Yeah. Okay, so that much for the equals method. Now the hashCode method. This is actually very complicated, I'm sorry, and it's so complicated that I've decided to do a follow up tutorial, as said before, which I really recommend you to watch. There is a link below this video, you can click to watch the follow up. So he only in short about the hashCode method. The 31 year is a prime number and a prime number he is multiplied with always the result. So this continues to take the hash code of a field, which will return some in number will edit, starting with one, and then multiply it with 31. And this for each attribute. The reason is this is an optimization to have less collisions, because I told you about the collisions, that this can decrease the performance. As you see, I'm actually not really doing something here, I'm just calling recursively hashCode for each class. And this is why now we should jump in the other classes, at least, I can show you all the classes, but I've chosen engine here in this case, to see how it's actually hashCode implemented in one example. So let's jump to engine. Okay, so the equals method is pretty much the same, or at least similar. Then in car, the only difference is here, I added something that I called optional field, because I defined that this optional field could also be now. So therefore, my check here for equals has to be a bit more complicated. Because I have to save it's now then I check if the other field is also now, if it's not now, then this field is now the other is not so it's not equal. And if it's not now, then I can compare both fields. So I'm doing all this again to prevent another pointer exception. In the other case, when I don't check for now, my assumption is that, well, this is a primitive field, so it can't be null anyway, but for car, my assumption was that a car always needs a manufacturer, engine and a color. So my assumption is, those fields will never be now, if someone would introduce a bug. And would forget to set these fields then, of course, this could produce a nullpointerexception. But checking for something that is exceptional. This is what I call rocket code. Because it's like extra safe code, this is just cluttering your code, you have to have certain assumptions, like saying mighty sign for bits that these fields, these fields can never be now. And so I trust on that. Otherwise, well, the program will crash, okay, we have to fix it. But then the problem is already fixed. And the code stays clean. And this is important, because your code should be really readable and maintainable. Okay, so only four fields where you know, they can be null at these extra null checks. Okay. So that much for the equals method, everything else here should be the same as in car. Now for the hashCode method. Here, you see there is some more stuff going on. Because here, I cannot forward to a hash code method. But instead, I have here a primitive long. And for that, because the primitive fields there, you actually have to calculate some hash code. And this is a long, and so we want to like convert a long to an int. A long has that has like 64 bits, while an int has only 32 bits. So you want to like make the long to half its size, and you want to make it in a way that will result in the least possible number of collisions. And therefore, this weird line here. This here does it. This is actually based on again, Josh blocks book Effective Java there, he explains it. One, actually, he doesn't explain it too much. If you want an in depth explanation again, watch my follow up tutorial about hash code there, I can explain you. Now here only insured. This is a shift by 32 bits. And then this is an X or Y you again, come like let's say combine this field. And last but not least, you do an exquisite cast from long to end where you throw away Half of the long, but this whole thing can't explain you in like one minute, you have to watch really the extended tutorial. But this is really a very performant good way to create an end hash code from alarm. This is the standard default way of how this is done today. And the second field here is a string as it can be now, I need this extra knowledge check. And I'm not sure if I have shown you this before. This is like in if it's just shorter, because otherwise the code would even be longer. So you have to read it as is optional field now. If true, then return zero, else return optional field dot hashCode. So this again calls the hashCode method of string. This I showed you in the beginning of this episode, where the code was like in a while loop, going over each character of the string, and then calculating an int value for the string. So as this is already done for us, we can simply call the hashCode method. Okay. So, again, you also see, I have, in this case, two fields. And in this case, I decided to use both to differentiate if an engine is equal or not. And so as I use type an optional field and equals, again, I use type an optional field and hashCode in the same order and same fields. Okay, last but not least, some class now this is this doesn't mean anything, this is really totally abstract, I just wanted to it very short, show you all the different primitive types they are plus the string object. So that you see like how the different cases of equals and hashCode could be calculated. So let's first of all look at hash code. So this with long we have already seen, same one here, float, well float has the same size 32 bits like an end. And then there is a native function, which will convert the float to an int to be used for the hashCode. Double A has the same length as a long. So this is done in two steps. First of all, it's converted, again, with a native function too long. A native function is a function that is not implemented in Java, but in machine dependent code. So I can't show you. But again, for details, watch my follow up tutorial. But anyway, so long we take and again, we do this weird line here to convert it to an end. Next one Boolean. Here again, this weird stuff here. If it's true, question mark, then 1231. And if it's not true, then take this number. All this stuff is really technical might be a bit hard for you to understand. This is just really important for performance optimization to have the least number of collisions. Um, car is just taken as it is because it can be handled like a number. For string again, we call this hashCode method. And for the other fields, everything that is as big as an end or smaller than an end, that's relatively easy because you can just take the value as it is because a byte will always fit into an end short will always fit into an end. And an end of course, should also fit into an end our K so I know this was really rough really short. I'm just not enough time to go in more details. But exactly For this reason, I have done the follow up tutorial you can watch. I hope then it will be more easy to understand. Now last but not least, let's have a look also at equals. So I think for the primitive values here, it's pretty easy because you don't have to use equals If you can just use the not equal operator. So if it's if the bytes are not equal, just looking at the variables without any objects involved, false is returned. And also see this is the order I've chosen, I start with the smallest possible values, because here checking them is probably faster than doing all this crazy stuff down here. And this is why I've chosen the order. All K, with a short end, long, this is all easy. With float, it's a bit more difficult, we have to convert it first to an end, that will has to be converted to a long, um, Boolean is, again, easy. Well, actually, if this was a real whoops, if this was a real implementation, I would have done it differently, I would have put it to the top. So this order is also based to explain you the different types. So in reality, I would ask you to really think about the order based on what the business tells you what is easy to differentiate. And like, then also you have to think, like, from the performance, what takes longer to calculate. Um, of course, it depends if you really need the performance. And if you do, then always test performance, because you might think something is fast. But when you tested, it turns out, it's not as fast as he would have thought, okay, because what I'm telling you here is just a rule of thumb, but I might be totally wrong in a specific case. So this is also what I'm doing, if I need a certain performance, I test for it. In all other cases, I just do how I feel like it. Or I just use my gut feeling to sort the values, as I think could be fitting out. Okay, so I hope you liked this episode about hashCode. And equals I'm sorry that this is all so complicated and so long. I just wanted to put in everything possible, because this is really such an important topic that he should really understand in detail. Of course, there is way more actually. So I would also ask you go to my blog, www dot Marquess minor spiel.com. I will put up some links to some extended articles on the topic on and also you might consider buying Effective Java from Drush blog, he also talks about it quite extensively. So here I will give you a high level introduction to the Java collections framework. Unfortunately, there are several overloaded uses of the word collection. Let me clarify the various meanings up front. The different use cases are a collection without any it relevance as a compilation or group of things. Second, the Java collections framework, a library of different interfaces and classes. Third, a collection as a data structure. Think of a box or container that can hold a group of objects, like an array, for example. For us, the Java collections interface, one of the two main interfaces of the Java collections framework, and fifths, Java util collections, or utility class that will help you to modify or operate on Java collections. This episode is based on chapter 11 of the OCA OCP study guide. The book is packed with knowledge. As a great fan of the author is Kathy Sierra and Bert Bates. I recommend you to read this book, even when you don't plan to get a certified programmer. So what is the Java collections framework? from a high level perspective? First of all, it's more like a library a toolbox of generic interfaces and classes. This toolbox contains Various collection interfaces and classes that serve as a more powerful object oriented alternative to arrays, collection related utility interfaces and classes that assist you in using the collections. I'm going to describe both parts in detail now. On the next slides, you will see the interface and class hierarchy for collections. Unlike arrays, all collections can dynamically grow or shrink in size. Except before a collection can hold a group of objects, a map can store pairs of objects that have some kind of relation, which ties them together, named key and value. A value does not have a specific position in this map, but can be retrieved with the key it is related to relax if you don't get it now. We will look at it in more detail later on. So here you see the hierarchy of classes and interfaces, extending or implementing the collections interface. Just try to remember some of the names listed here. This is just an overview so far. As you can see, the collection interface sits on top of a number of sub interfaces and implementing classes. A collection can hold a group of objects, the collection interface is extended by the interface of set list and queue. A set is defined as a group of unique objects. What is considered as unique is defined by the equals method of the object type the set holds. So in other words, a set cannot hold to equal objects. A list is defined as a sequence of objects. So unlike a set, a list can contain duplicate entries. Besides a list keeps its elements in the order, they were inserted into the list. A queue has two sides, entries are added to the end and removed from the top of the queue. This is often described as first in first out, which is pretty much like a waiting line in real life works. The first person queueing up will also be the first person leaving the queue. Now let's have a closer look at the interfaces and classes that extend or implement the set interface. Hash set linked hash set and three set are all implementing the set interface. Hash set is the default implementation that is used in the majority of cases. Linked hash set is like a mix of a hash set and the list as it does not allow duplicate entries like a set. But it returns its elements in the order in which they were inserted. Like your list would do. Chrisette will constantly keep all its elements in sorted order. But keep in mind, there is no free lunch. So every edit feature comes at a certain Cost Of course. After looking at the classes implementing the set interface, let's also have a look at the two extending interfaces we haven't talked about yet. As the name implies, sorted set is a set that is constantly sorted. The navigate will set interface was added which Java six, it allows to navigate through the sorted list. For example, it provides methods to retrieve the next element greater or smaller than a given element of the set. Next, let's have a closer look at the classes that implement the list interface. Every list is the default implementation of the list interface. Like any list implementation, it does allow duplicate elements and it does allow to iterate the list in the order of insertion. As it is based on arrays, it is very fast to iterate and read from an every list. But adding or removing an element at a random position is very slow, as this will require to rebuild the underlying array structure. vector is a class that exists since JDK one which is even before the collection framework, which was added with Java two. In short, its performance is sub optimal. So So please never use it. Use ArrayList or linked list instead. So let's directly remove it and forget about it. The next list implementation is linked list. As the name implies, its implementation is based on a linked list, which makes it easy to add or remove elements at any position in the list. Last but not least, let's have a look at the classes implementing the queue interface. We already talked about link list, as it also implements the list interface. However, the fact that it's based on a double linked list makes it quite easy to also implement the queue interface. linked list is the default queue implementation. priority queue is a queue implementation that keeps its elements automatically ordered. It has similar functionality like a tree set, but it does allow duplicate entries. Now let's look at the map interface. This interface has no relation to the collection interface. A collection operates on one entity, while a map operates on two entities. A unique key, for example, a vehicle identification number, and an object that is related to this key for example, a car object with the help of the key you can retrieve the object it relates to. The interface map is the root of a lot of interfaces and classes, which we'll look at now. The class hash table was the first collection in Java JDK one that was based on a data structure hash table. So the Java creators called a hash table. Unfortunately, this makes it a bit hard to differentiate between the two. Like vector the class is deprecated, because of its sub optimal performance, so let's also remove it and forget about it. Instead, use one of the other classes that implement the map interface. hashmap is the default implementation that you should use in the majority of cases. A map usually does not make any guarantees on how it internally stores its elements. An exception to this rule is linked hash map, which allows to iterate the map in the order of insertion. Last but not least, tree map is a constantly sorted map. Now let's look at the interfaces that extend the map interface. As the name implies, the interface sorted map extends the map interface and defines the contract of a constantly sorted map. navigable map again extends the sorted map interface, and adds methods to navigate through the map. This allows you to retrieve all entries smaller or bigger than a given entry, for example. Actually, there are many similarities between the map and the set hierarchy. The reason is that the set implementations are actually internally backed by a map implementation. Last but not least, you might have noticed the Java collection classes often contain the data structure there are based on in their name. To choose the best collection for a given situation, you have to compare the specific characteristics of data structures like array, linked list, hash table or tree first. In short, there is no single best option. Each one has its very own advantages and disadvantages. I promise to talk about this very exciting topic in a later episode. So stay tuned. This overview of the collection and map classes that only show you a part of the whole story. In a later episode, I will introduce you to the concurrent containers of the Java collections framework. generics is a topic at least as big as the Java collections framework. In the context of this episode, I will therefore only explain you the bare minimum you need to understand the collections framework. It's okay if you have a lot of open questions after my brief overview. Give both of us some time. I promise to explain everything one after the other I would recommend you to subscribe to my YouTube channel to be informed as soon as I upload the next episodes of the Java collections framework. Now fasten your seat belts. Here, it's going to be a bumpy ride, I promise. You see this weird stuff in angular brackets. Just relax. Actually, it's much easier than you might think. And the first line, you see I have defined a list variable my list. And with a string parameter in ANGEL brackets, I tell the compiler that my main list reference variable is supposed to be used only with strings. Then I create an object of type ArrayList. And again, I tell the compiler that this object is only supposed to be used with strings, and the compiler will ensure that no one ever tries to put anything else than a string into my list. In other words, this is what makes the container type safe. Also, note that I use the interface list for the variable and not ArrayList. This makes your code more flexible. Only at one place you create the object, but at various places in your code, he will use it. When you use list instead of error list for the reference variable. You could later replace the error list by a linked list, for example. And all you had to adjust was this one line of code. In case you don't really need to specific methods of a list, you could also use the collection interface instead. Always use the least specific interface for the reference variable. Oh, by the way, I'm sure you notice the integer 100 that I use as a constructor argument. This I have added for performance optimization. As said before, the collection classes can dynamically grow and shrink in size. However, aerialist and all hash table based collections are internally operating on arrays. When an array based collection grows in size, it will internally on the fly, create a larger array and transfer all contents from the old to the new array. This of course takes some extra time. What on hardware is so fast, that is usually should not be a problem. But on the other side, if you already know the exact, or at least the approximate size of your error based collection, this is usually better than trusting on the collections default size. In the next episodes, I will look at the data structures that the Java collections are based on, which will help you to better understand performance considerations like this one. However, to me, taking care of such small little details, makes the difference between a developer and a software craftsman. So I wanted to let you know as early as possible. Okay, enough, blah, blah, blah. Let's get back to the topic of generics. Now in the second line, you see how a hashmap is instantiated accordingly. As said before, a map is basically a relation of one identifying key to one value element. Both these elements can be of different types. Like you in my example, I use Vin, the vehicle identification number as the key and the car object as the value. This has to be added as a comma separated list in ANGEL brackets. And the compiler again will check that this holds true. If you create the instance reference variable and the object, both in one line, you can also leave the second pair of angel brackets empty, as it can be inferred from the generic type of the reference variable. This was introduced with Java seven and is called the diamond operator. Because the empty Angel brackets in a way, look like a diamond. Actually, I'm sorry. That's not the whole story. There are two parts. And what I just showed you. This was actually part two, the usage or invocation of a generic class when you lock in the contract parameter to be used. But this is only possible if the method, the interface or the class was defined to be used in a generic way beforehand. Here you see a generically defined interface. In the first line, the interface is defined as an interface operating on two separate generic types that have to be specified at a later time. However, when these types are locked in, this will automatically also specify the type, the types, interface methods we'll use. So, if you see some weird one letter types in one of the next slides, just remember it means this is a method that can be used in a generic way. Okay, now we are ready to look at some additional utility interfaces of the Java collections framework. They are implemented by classes of the collections framework or the JDK in general, but they can also be implemented by your own classes, making use of the power of the collections framework. Well, strictly speaking, the interface Java Lang iterable is not part of the framework. But more precisely, it sits on top of it. It is the super interface of Java util collection. So every class that implements Java util collection, will also implement the Java Lang iterable interface. Okay, anyway, let's now look at each interface in detail. an iterator is an object that acts like a remote control to iterate through a collection. Let's look at its methods. Boolean has next returns true if the collection has more elements. ie next returns the next element in the iteration. And void remove removes the last element returned by this iterator from the underlying Collection. This interface provides only one method, which will return an iterator every collection that implements this interface can be used on the for each loop, which greatly simplifies the usage of your homemade collection. In order to plug in your collection into the for each loop, you will have to execute two simple steps. First create an iterator that is able to iterate over your collection with methods like hasnext. And next, as we saw on the last slide. Second, you need to implement the iterable interface by adding an iterator method that will return an instance of this iterator implementing the interface Java Lang comparable defines a sort order for your entities. The interface contains only one method you need to implement which is int compared to if you want to define a natural sort order for an entity class, make it implement this interface. return a negative integer if the object is less than a given method argument, zero if the object is equal to the given method argument, and a positive integer if the object is greater than the given method argument. What means smaller or greater is for you to define. For numbers, that would probably mean that one is smaller than five, for example. But for colors, This all depends on how you want to sort your entities. When you put objects of an entity that implements the comparable interface, into a tree set or tree map, it will use your compare to method to automatically sort all elements you put into the collection. As you can see, the Java collections framework has been greatly designed for extension. It offers a lot of possibilities to plug in your own classes. This interface is very similar to the comparable interface. It allows you to define additional sorting orders like a reverse ordering. So the sorting logic is not directly implemented in your entity, but in an external sorting strategy class that can optionally be added to a collection or sorting method to the Find an alternative sorting order for your collection of entities. The rules of the interface contract are pretty much the same as for comparable. return a negative integer if the first argument is less than the second argument, zero if both arguments are equal, and a positive integer if the first argument is greater than the second. Last but not least, let's look at the two utility classes, collections and arrays, like a Swiss Army knife. They provide static helper methods that greatly enhance the general usefulness of the collection classes. Java util collections offers methods like sword shuffle, reverse search, min or max. And Java util arrays operates on areas and not on collections actually, similar to the collections class, it allows us to swap areas or to search through areas for example, I'm going to take an in depth look at ArrayList. And the second half, I'll do a practical coding session. Okay, let's get started. Error list is the default implementation of the list interface. As with any implementation of list, you can have duplicate elements in your array list. And you can go from element to element in the same order as the elements were inserted. As it is based on Aries, aerialist provides fast access, but inserting or removing an element at a random position requires more time, as this will require to reorganize the list. fast access however, is crucial for most applications, which is why ArrayList is the most commonly used collection. to store data that changes frequently. However, consider using an alternative container, for example linked list. I will talk about this as well as other containers in the upcoming episodes of my free Java video course. Okay, before I continue, let me introduce you to two different terms, which are important to understand in context with error list, size and capacity. Size is the number of elements the ArrayList currently holds. For every element you add to the list, the size will grow by one capacity or ever, it's the number of elements the currently underlying array can hold. The capacity of the array list grows in intervals. The error list starts with an initial capacity. Every time you exceed the capacity of the array, the ArrayList copies the data over to a new array that is about 50% larger than the previous one. Let's say you want to add 100 elements to an aerialist have an initial capacity of 10. As the list grows, the system will create six more areas to take the place of the first. First one area that can hold 15 elements, then one for a maximum of 22 elements. Then areas with a capacity of 3349 73 and finally 109 elements to hold the growing list. These restructuring arrangements can negatively impact performance, you can instantly create an array of the correct size to minimize these merging activities by defining the correct capacity at creation time. In case you don't know the final size of the ArrayList at creation time, estimated as close as possible. Choosing a too large capacity however, can also negatively impact performance. So choose this value carefully. I advise you to always explicitly set the capacity at creation time as a documents your intentions. For most projects, you won't have to worry about optimizing performance to too powerful hardware. But this is no excuse for sloppy design and poor implementation. Here you can see a simplified extract of the class aerialist. Keep in mind, the real class looks a bit more complicated. This is just meant to give you a more concrete idea of what the class ArrayList looks like. As you can see, error list is just a class anyone could have written. Given enough time and knowledge, there is no black magic, you can find the actual source code online. However, don't rely too much on internals that you spot them the source code as they may change any time if they're not defined in the Java language specification. Default capacity is the initial size of the array, when you don't specify it as I recommended before element data is the array used to store the elements of the ArrayList in size is the number of elements the ArrayList currently holds get add and remove are some of the many functions ArrayList provides, we will look at those methods now. So, let me give you a short overview of the methods of the ArrayList class. To make things easy for you, I have broken up the overview into methods belonging to the Java util collection interface, and methods belonging to the Java util list interface. When I talk about other containers in later episodes, implementing the list or the collection interface, I will refer back to this episode. Instead of repeating myself over and over again. Make sure you are subscribed to my YouTube channel. So you will be informed when I release episodes about these classes also. Okay, so let's start with the methods belonging to the Java util collection interface. The contract of the collection interface does not guarantee any particular order, and therefore does not provide any index or order related methods. So here you can see the first set of methods that implement the collection interface. So what I say about these methods does not only apply to ArrayList, but also to all classes that implement the collection interface. The method Boolean ad appends the element to the end of the collection to the next empty cell of the underlying array. Boolean at all appends all given elements to the end of the collection. The stuff in ANGEL brackets is related to generics. In short, it ensures that no one can call such a method with the wrong arguments. From now relax. I will tell you more in my upcoming episode about generics. Boolean remove removes the first occurrence of the element you specify from the collection. Boolean remove all removes the given elements from the collection. The iterator method returns an object usually use an a loop to move from one element to the next element of the collection. Step by step you say I iterate over the collection. Hence the name iterator. incise returns the number of elements of the collection. Boolean contains returns true if the collection contains at least one instance of the element you specify. Wide clear removes all elements from the collection. Boolean is empty. This returns true if the collection contains no elements. And to array returns an array containing all of the elements of the collection. Alright, let's move on to the methods of the Java util list interface. The methods are similar in part to the methods we just looked at, but they differ in that they require an order on the elements of the list. So here again, you should know that everything I say about these methods does not only apply to every list, but to all classes that implement the list interface. This add method with an index parameter. It's actually more like an insert method. It allows you to insert an element at any index position of the list. Instead of just adding the element to the end of the list. And the process the elements of the underlying array will be shifted to the right and migrated to a larger array if necessary. The remove index method allows to remove an element from any index position of the Similar to the Add method we just looked at, this might require to shift the remaining elements of the underlying array to the left. The get by index method returns an element from any given position of the list. The index off method takes an object and returns the index of the first occurrence of the element in the list, or minus one if the element is not found. In last index of returns the index of the last occurrence of the element in the list, and SP four minus one if the element is not found. List sub list returns a view of the list starting with the position you specify as from index and ending one possession before the one you specify as to index. Last but not least, the sword method sorts the list following the order of the given comparator. Alright, so let's end the lecture session, time to move on to some practical coding. So now I'm in my early and you can see I have prepared a little test method. So we can do some practical coding with ArrayList. I have already created an instance of ArrayList. And I've assigned it to a reference variable of type collection. Now, this might be a bit counterintuitive at first, because why is that not ArrayList? Or at least list. While there is a reason to it. And let me cite Robert C. Martin, he says, a good architecture is one that maximizes the number of decisions not made, or the number of decisions D fared. And this is such a situation, because by making this collection, I mean, you would create this instance for a reason, of course, and you probably would forward it to either other methods and or other objects. So now, if you make this an ArrayList, this will really limit all your other objects, because they all only have to work on an ArrayList. But now, the requirements of your business, I mean, requirements, usually they change very fast as you know. And if they change, like for example, an ArrayList can hold duplicate elements. But now there might be a new requirement that tells you, you cannot have duplicate elements, you have to prevent that you have duplicate elements. So you might want to use hash set here. Now, if you use list or every list everywhere in the code, it will be very tough to change your mind, you will have to touch a lot of code, which is very dangerous. But if this is a collection, a collection can be so so many things. And so it will be much easier to change your mind. Because all you will have to do is change the instantiation of the object that is actually being used. So if you can, like of course, this limits the number of functions that you can use, because the collection interface is less powerful than the list or the error list interface. But if you can, like if you only need the methods of the collection interface, well then do it like this. later on. We will switch here to a list interface because I will also show you methods that only appear in the list interface. But we'll start with a reference variable of type collection. And then you'll also see the difference. Okay, what else can you see in the single line? Besides you might spot that have used generics in the angel brackets, so we have created a collection of type string. And here, you might spot the so called diamond operator that was introduced with Java seven. Well, because we do both in one line, we do the object instantiation. And we create the reference variable in one line. The compiler directly sees this must be a string. And this is why here we can use the diamond operator. But we could also do it the old way by typing here string. This is just a bit shorter. Okay, and last but not least, you should notice here I wrote initial capacity, which is a constant, which I have defined here as private final int, initial capacity five. Now you might say well, you could have also said just five I mean, this is faster. Well, at first, it might seem so but this is a so called magic number. And this is evil, because it makes it so much harder for the next developer to know what this five actually means. Like not everyone knows that an aerialist has an initial capacity. But if you use the constant value here, you document in the code your intentions. So this is actually quite good. And I recommend you to do it also. Okay, but now let's already start using some methods. I mean, we're not doing I'm not going to properly program something, but we're just playing around with the methods, so you get a better feeling of like what aerialist is all about. And as this is now, a collection reference very Oh, of course, you'll only see all the methods of the collection interface. And we'll start simple with ADD. Of course, like one limitation that we have now is we don't see any index based methods, which was also the reason why before in my slides, I divided the methods into methods that are related to the collection interface, and methods that are related to the list interface. Because now I can also go back to the slides and compare, because now we're doing the methods of the collection interface. So this is a collection of type string, so I can add a string. So let's add B, capital B. Let's add some more. A later on, I'm also planning to sort the error list, which aerialists allows. But right now, with the collection reference variable, we will not be able to sort it. But stay tuned. I'll do it soon. Oh, okay. And I mean, even though we have a reference variable of type collection, still, the fact that we have an ArrayList influences that we can have duplicate elements. So let's do that. Maybe I should also add one eight here. Okay, and now let's count how many numbers elements I added 123456, the initial capacity or ever is five. So that means when you add the sixth element, internally, within the execution of this method, the error list will realize, well, the capacity is insufficient, will then create a new array of a larger size, and will then migrate all the existing data to the new array. Before the next element, the second he is added, which costs some extra time. But really don't worry, I mean, in the regular situation like this five, six elements, the performance difference is altra altra. Low. So never, I'm never worry, in such situations, this should really be only, like only think about this when it gets a problem. And usually, this could get a problem if you have like 1000s or 10s of 1000s, if not a million of elements. So it always depends on the amount of elements, you have the amount of iterations that you do. Okay. So and then we can also print the error list as it is now, there are two different ways ArrayList has also a two string method. So I could directly say system, out print ln elements. But I'm doing it a bit more complicated, because I want to show you how we actually iterate over the ArrayList. And this is because every list, and every collection implements the iterable interface, which is used in this new for each loop. And so we can iterate over the array list by saying string string, and then column and then elements. And what is required to iterate over this list will be done here inside and you don't see it. This is all done by the compiler for us internally. In short, I can tell you, there is an iterator method that I showed you showed Before, which will then be used. You might also check my last episode where I introduced you to the iterable. And the iterator interface, both will be used here. For now. I mean, it's enough, if you see, you can use the ArrayList and the for each loop. And now we can print out each element separately, which of course gives us a bit more flexibility. Like I could print something else here also. Okay. So this is called iteration going over the collection, element by element. And I also want to show you, let's comment this, oops, let's comment this out. I also want to show you that which is a feature of list, this order, how we added the elements, AB AC E, will be also exactly the same order as the elements are printed out, which would be different if we had a set. Okay, but enough of talking, let's already execute it and see it in action. Okay, so here you see a B, A, C, E, exactly like we added that, which is a feature of list. Okay, now that we added elements, we could also remove some elements, which is also just as easy we move. And now on the collection interface, I can't remove by index. But I can remove by stating the object that I want to be removed, which by the way, internally uses the equals method. If you don't know about the equals method, I also have a video about the equals method. So it goes over each element and checks by using equals, which is implemented in the string class. If there's a is equal to one of those elements here, and will then remove it. You might also notice I have two A's. So now it's interesting to know, like will the first a be removed will the second AB removed of or both be removed? And there is another tip I have for you. Like if you have such questions, you can look for a book for video tutorial, you can look in the API and so on and so forth. But you will never be as Sure. And probably also never be as fast if you just write a simple test like this. And you just try it out for yourself. I mean, how pragmatic How cool is that? Because the code doesn't lie. If you see it, he will be sure that it behaves like you can see it. So let's do this and check which element is removed. And here you see B, A, C E. So the first a is missing? So the answer is the first element is removed, not all A's are removed. Okay, so what else can we do? Let's check. We can also ask for the size. Let's make this a bit simpler now. To have it as short as possible. So now we have 1234 elements. I'll copy that copying some code that you will reuse is just safer not to introduce any typo, or K. And as long as you're just copying the code and not duplicating the code, it's also fine. So this supposed to give us the number of elements. Let me document this out. So we just see the number of elements. Let's also do it directly after instantiation of the object. So I expect here to see a zero, no elements included. Or I mean this would be another alternative possibility that this would throw an exception if the list is empty. So let's check that execute the test was actually not really a test. I'm just experimenting but here. So you see it return zero and the first line and then four. So this is the size method. You can even ask, Are you empty? Which should probably here say Yes, true. And here probably false. And there is true and false. Okay. So let's now switch Over to the list interface. And let's also play a bit around with that. You see, I have not a reference variable of type list. And I can use all the methods exactly like I used them before, because the list interface extends the collection interface. So it includes all the methods that the collection interface has. But on top of that, we now have more methods than just the methods of the collection interface. For example, I can insert an element by giving an index position. So I could for example, say, at index position zero, at me, I don't know T and S at index position two. And then let's use the simple fast print odd method. Let's remove this because it'll format the list in a one liner. But let me just show you what I mean. Okay, we still have the true we can also remove this. Okay, but for now it's fine. So we have T, because we added that at index position zero, which means this will be inserted where a was before. Before I added that at index zero, this was the index zero. So this, put it to where a was before and then shifted everything else to the right. And this is why now this is nice to see it like this in one line. Because you see, this is all shifted to the right, which when I remove an element, the opposite happens. Like if I remove the s, everything will be shifted to the left. But let's see this later. Okay, and we added the S at index two. So now this is index 01 and two, which again shifted the rest to the right. Okay, so let's also remove something, let's do this here. Let's say I remove index. And now let's see, I remove index one, which is which should be the B. Okay. And there, it seems I am wrong because the a is still there. And the B is still there. Let us see. Well, of course, because it's a bit confusing. As I added the T at index position zero, a is now index position one, and this one was removed. So removing by index is always not so easy. Really, I have to tell you these index based methods, I hardly ever use them. Normally, you're fine, actually with most of the methods of the collection interface, which again tells you like, often it's a good idea to use collection here. Okay, so this actually inserts an element. Okay. By the way, let's increment this a bit, just for demonstration purposes. I mean, this is not so flexible. I mean, really, as I said in my slides, you should really think carefully the number of elements that you need. Just here, it's different because we're playing around, because I want to show you the difference again in the example between the capacity and the size, because the size of the list is the number of elements. Let's do this here, and not the capacity, because my area with a capacity of 100 the area will be 100 elements big even though they're empty, but the size however, will be much smaller. And here you see the size is four and not 100. So there is a difference. Okay. Now we can also ask for the index of a certain element. Let's do this here. Index off and there is also last index off and also is empty. Yeah, this we should also use. So index off. Let's use the aim. Yeah. Which is maybe we should remove that. to not make it too confusing to keep the A where it is. So now index off gets you the first index of an element. So I would expect that to be zero now, let's see this. And they receive zero. And we can also say last index of, which should be the second a. Check that. And you might ask, Well, what do I need the index for? All you can use that to more flexible, like combine the methods now that you have the index, you could also say like, like, remove this index or so on, I don't know, might be helpful. Okay, so now I can also show you the clear method. And the is empty method. I think the is empty method we already saw. But now let's use rim clear. This method is void, so I cannot cannot print it. But I can put it here, clear, will empty the list. And then we'll ask is it empty now. And we can also print out the list. An empty list, which is also interesting, because this would be another question. Can I print out an empty list? Or will this again throw an exception maybe? Let's test it. And you see yes, it is empty. And you can print it. It's just the square brackets and there's nothing in there. So this was an empty list. Okay. So I think that's already it. A really short introduction, some practical coding, I really recommend you to do the same fire up your ID or your text editor and play around with the methods of earliest. I know there are many, many more methods of course, it just that in this video i don't have all the time. So this is just meant to give you some motivation to play around with it by yourself. Okay, that's it for this episode. If you have any questions, leave them as a comment below this video. And please remember to give me a thumbs up before you go. Thanks for watching, and see you next time.