Hi there. We have come to the end of the course. Let's summarize what we learned in this course. First of all, we have learned lots of information about Java programming language and the Java platform. We know what Java is and how it works. Then we introduced the basics of Java syntax. In this section, we've learned the compiling and executing of a Java program, variables, Java keywords, basic output and input, comments, data types, operators, and Java program structure. Next, we talked about arrays, one of the most important topics in Java. In this section, we touched on many important points such as declaring and initializing arrays, sorting and searching operations in arrays, and multidimensional arrays.

Then, we introduced the decision-making statements including if statements and switch case statements. And then we learned loop statements including, for, for each, while and do while loops, and have worked on Branching statements including break, continue, and return statements. Then, we introduced methods in Java. In this section, we practiced declaration and calling of methods, types of methods, return types of methods, and method overloading. Then we introduced Object-Oriented Programming in Java. In the concept section, we have learned about object and class, access modifiers, naming conventions, constructors, packages, and package definitions, and how to use the static keyword and nested and inner classes.

In the programming section, we have learned important fundamental subjects of Object-Oriented Programming. We have used real-life examples while we define what Object-Oriented Programming is. First, we have learned the inheritance subject that includes super classes and sub-classes. And then, we worked on the method overwriting subject in detail. And then we learned when to use super and this keywords and the final keyword. And we have learned about abstract classes and interfaces and the differences between them. And then, we worked on polymorphism and encapsulation subjects. Then we have introduced one of the most used and popular subjects in Java, strings. We have learned about what string is and creating string objects. Also, we have worked on useful methods of the string class. And we have learned why string objects are immutable.

We have also introduced mutable string buffer and string builder classes, and we have practiced with methods of these classes. We have introduced the wrapper classes subject. In this section, we have learned what wrapper class is and the conversion of types. We have also worked on two beneficial subjects, conversion is automatically done in Java 5 and later versions. These subjects are auto boxing and unboxing. Then, we learned about collection framework. In this section, we have separately touched on interfaces such as list, set, Q and DQ, which inherit from the collection interface. And we also made examples about the important classes, such as ArrayList, HashSet, TreeSet, which are the most important classes that implement these interfaces. We specifically focused on the ArrayList class, because the questions and the exam are about ArrayLists.

Again, in this section, we learned about the map interface, which is outside the collection framework, but similarly simplifies our work while coding, and the classes that implement this interface. Then we introduced the exception subject in Java. In this section, we have learned what an exception is, the differences between error and exception, and the types of exceptions. We have also learned tryCatch blocks to handle exceptions and how to use them. Then we worked on the finally block and how to use it. Then we tried to understand throw and throws keywords, the differences between them, and how to use them. And last, we have worked on useful exception methods. Then we have introduced Enum types.

In this section, we have learned how to declare an enum type. Also, we have tried to understand useful key points of enum types. Later, we learned Lambda expressions that came into our lives with Java 8. In this section, we talked about what marker and functional interfaces are, how Lambda expression is defined, and how it's used. Then, we learned about the predicate interface. We also touched on the concept of static import in this section. Next, we learned the concepts of date and time in Java. We have covered the local date, local time, and local date time classes as separate lessons so that you could learn better and understand the difference. Then we learned the period class and date-time formatting operations.

Next we learned about Java Input/Output. In this section, we first tried to explain the concept of API and stream. Then we talked about how to write or read data to a file. In addition, we wrote data to an external file by making many different examples and we read the data we wrote again. Again, in this section, we also touched on the issue of serialization. Also, at the end of each section, we practiced code exercises to strengthen our coding knowledge. We have done more than 50 code exercises and seven real-life projects in this course. We also solved many sample exam questions during the course to prepare you for the exam. We touched on the tricks, we tried to show you the mistakes you can make, and finally we solved a practice exam together at the end of the course. I hope this course has made you a good Java developer, as well as getting a passing grade on the exam. Here, we end the course. Stay well.

Course Conclusion

About

SELF PACED PLATFORM

TRAINING CONTENT

JOB ROLE PATHS

CERTIFICATIONS