Pass Oracle 1z0-809 Exam in First Attempt Easily

Java Class Design

1. Introduction

Hello. This is an introduction to the Java SE 8 Programmer II exam. After passing this exam, you will become an Oracle Certified Professional JavaScript programmer. The duration of the exam is 150 minutes, or two and a half hours. You are required to answer 85 questions. In order to pass the exam, you must score at least 65%. This exam is validated against the Java Platform Standard Edition 8. All questions are multiple choice. These are exam topics that we will cover throughout the course, starting with Java Class Design and Advanced Java Class Design. Following that are generics and collections with built-in lambda functional interfaces, java streamAPI exceptions, and assertions. After that, we'll go over Java SE 8, time, API, and IO fundamentals Java File IO Java concurrency. Then you will learn how to build database applications with JDBC. The course will be concluded with localization.

2. 1.1 Implement Encapsulation

Hello everyone. In this lesson, we will focus on the first item of the Java class design topic and the Java SE programmer's exam syllabus, which is, implement encapsulation. Let's start with the definition of encapsulation. Encapsulation is one of the four fundamental object-oriented programming concepts. The other three are inheritance, polymorphism, and abstraction. Encapsulation is a mechanism of including within an object all the data it needs and doing this in such a way that other objects cannot access its internal structure. In other words, encapsulation refers to wrapping dataor variables and code acting on the dataor methods together as a single unit. When applying encapsulation, variables of a class are hidden from others and can only be accessed and operated on through methods of their own class. In the Java programming language, encapsulation can be achieved by declaring variables in a class with the private access modifier and providing public methods to work on these variables. Here are a couple of benefits that come with applying the encapsulation principle. The most important benefit of encapsulation is that it allows implementation details of an object to be modified without breaking existing clients, resulting in a more stable public API. You can easily change workflow, add processing logic, etc. while keeping the object's clients as they already are. Another advantage is that encapsulation protects an object's internal state from vulnerable situations, such as being accessed by malicious code or set to an invalid value. This can be achieved by adding some security or validation logic to assessors. You will see this feature in action shortly. assuming you have the data class. Now you want the value field to never be negative. Without encapsulation, there is no way for you to keep outside methods from setting this variable to a negative number. You can modify the class to implement the encapsulation principle by changing the access modifier over here to private and adding public getters and setters. Within the setter, you can declare a conditional statement to prevent the private field being set to a negative value. Let's see how it works. First, instantiate the data class, then set the data value to a negative number. Run the program. As you can see, an error message is shown. Let's check the data value. It is clear that the value field was not set to a negative one. Now set it to a positive number, check, and the setting was successful. Now it's time for some practise questions to go over what we have learned. Here is the first question. If you need more time, feel free to pause the video. In Class A, there is no Getter method, and the data field is effectively final. This field can only be accessed from other objects via a public Getter method. Therefore, this class follows the encapsulation principle. in class B. There is no getter method. The data field can only be manipulated by the outside world via these public methods. Thus, Class B also implements encapsulation; as a result, the correct answer is C. Now for the second question. The data field over here is declared with the static modifier. This means that it is associated with the Whis Labs class, not with any particular object. This association breaks the encapsulation principle, so the correct answer is A. In this lesson, we have gone through the encapsulation principle. Encapsulation is a mechanism that refers to rapping data and code acting on the data as a single unit.

3. 1.2 Implement inheritance including visibility modifiers and composition

Hello everybody. In this lesson, we will focus on the second item of the Java class design topic. In the Java SE eight programmer-two exam syllabus, the topic is implementing inheritance, including visibility modifiers and composition. Inheritance is a mechanism allowing one type to acquire or inherit fields and methods from another. The type that inherits members from the other is called a subtype, and the type whose members are inherited is called a supertype. Although inheritance allows a subtype to inherit members from its supertype, not all members of the supertype are accessible to the subtype. Here are the visibility modifiers that can be applied to a type member. The protected modifier is a special case that was designed to facilitate inheritance. A protected member of a supertype is visible to all of its subtypes, no matter whether the subtypes are in the same package as the supertype or in a different one. The default scope to some extent and the public modifier also allow subtypes to inherit members from a supertype. But the accessibility in these cases has nothing to do with inheritance. Let's take a look at an example of inheritance. In this super class, both the text field and the print method are visible to the sub class. Therefore, both references to text and print over here are valid, and the value of the text field will be printed out on the console. Now, let's move on to composition. Composition is one of the two fundamental mechanisms for code reuse in Java that implements a hazardous relationship between classes. The other one, inheritance, has just been covered. Unlike composition, inheritance implements an ISa relationship. You may look at this example to get a better understanding of composition. This is a class with a method, get address," that is being reused in another class. The main office class over here is called the back end class, while the other that reuses the get address method is called the front end class. In this company class, or the front end class, an instance field is used to reference an object of type main office. Using the structure, you may reuse the Git address of the backend class main office by invoking it inside a method of the class company. Now you can say that method "get address of class main office" has been reused through the method "manager of the class company." Now it's time for some practise questions to go over what we have learned. Here is the first question. As always, feel free to pause the video if you need more time. In the superclass, the text field is declared with the privatescope, so it is not inherited in the sub class.Therefore, this reference fails to be compiled, so the correct answer is "C compilation fails." Now for the second question. With inheritance, a subtype inherits all protected and public members of its supertype. And if these types are in the same package, all members have the default scope as well. On the contrary, composition allows members of a back-end class to be reused via those of a front-end class. And you can do this in a selective manner. Therefore, the correct answer is f a front-end In this lesson, we have gone over two ways of reusing code in Java: inheritance and composition. Here is a quick summary: Inheritance is a mechanism allowing one type to acquire fields and methods from another. Inheritance implements an ISAF relationship. Composition is another mechanism for code reuse in Java that implements a relationship between classes.

4. 1.3 Implement Polymorphism

Hello everyone. In this lesson, we'll go over the third item on the Java class design topic and the Java SE 8 Programmer 2 exam syllabus: polymorphism implementation. Let's get started with the definition of polymorphism in Java. Polymorphism is the ability for a method to behave differently based on the actual objects it is invoked on at runtime. This is an example to demonstrate polymorphism. This is the superclass with one empty method, which is overridden in two sub classes. Subclass One. The print method in subclass one prints the string subclass one, while the method in subclass two prints subclass two. When executing this code fragment, the first print method outputs subclass one, while the second prints out subclass two. The variables My object One and My object Two have the same reference type, My class, but their print method produces different outcomes. This is an illustration of polymorphism. Now you will see how the example that has just been introduced works in action. Starting with a superclass, here are the print methods that are inherited by subclasses: subclass one, a subtype of my class, provides an overriding implementation, as does subclass two. Next comes a demonstration of polymorphism using those classes. This My Object variable is declared with type "class" and references a subclass of one object. Invoke the print method on My Object and then run the program. As a result, reassign My object to a subclass of an instance and run the program. Again, the output is different this time. You can see that the text on the console is printed from two different method implementations, although the referencing variable is of the same type in both cases. Now it's time for some practice questions to go over what we have learned. Here is the first question. As always, if you need more time, feel free to pause the video. In this scenario, the My object variable first references a lower sub instance. After that, this variable points to an upper sub object.Therefore, the print method over here is invoked on an upper sub. As a result, the string "Whiz Labs" in upper case will be printed out, and the correct answer is B. Now for the second question. Although the sub one and sub two variables are declared with the same type, they reference objects of different types at runtime. As a result, the effects of the method change value are different depending on how it is defined in the containing classes. The change value method in class plus sub raises the value of the numeric field, whereas the one in class minus sub lowers it. So the correct answer is B. In this lesson, we have gone over polymorphism in the Java programming language. Essentially, polymorphism is the ability for a method to behave differently based on the actual objects it has invoked at runtime.

5. 1.4 Override hashCode, equals, and toString methods from Object class

Hello everyone. In this lesson, we will go over the fourth item of the Java class design topic and the Java Seek programmer, two exam topics that are overriding hash code equals, and two string methods from the object class. Let's start with the hash code method. The hash code method of the root class object typically returns the object's memory address in hexadecimal. I say typically because this technique is not required by the Java programming language, and a Java runtime implementation is free to choose an algorithm that best suits its needs. The hash code of an object returned by the method hashcode is designed to be used as the key referencing a bucket in a hash set, hash map, or hash table. If two objects are equal according to the equals method, then the invocation of the hash code method on each of these objects must return the same integer. This requirement implies that if you override the equals method, you must also override the hash code. Notice that the hash code method does not necessarily produce distinct values when two objects are unequal. When overriding the hash code method of a class object, you must declare a method with this exact signature. Now, let's move on to the equals method. The equals method of the root class object uses the identity operator to determine if two objects are equal. That is to say, it returns true if and only if the objects compared are exactly the same. You must override the equals method to compare two objects for equality in a meaningful way. Otherwise, you will end up in a situation where an equality comparison of two objects with the same internal state evaluates to false. When overriding the equals method of a class object, you must declare a method with this exact signature. The last method covered in this lesson is to string The two string method of the root class object returns a string that is the concatenation of the name of the class of which the object is an instance, the at sign character, and the unsigned hexodecimal representation of the hash code of the object. Such a string can be denoted by this expression. When overriding the two-string method, you have a method that returns a string representation of an object, which is usually used for logging or debugging. Such a string representation should be generated based on the object's internal state and should be succinct for people to easily understand. You must declare a method with this exact signature to override the two-string method. Now, it's time for some practise questions to go over what we have learned. Here is the first question. As always, feel free to pause the video if you need more time. The my-class class overrides the hash code method but does not define an equals method. As a result, the objects referenced by variables myobject One and myobject Two are unequal based on the equals method of the root class object, and both are added to this hash set. So the correct answer is B. It prints the number two. Notice that this is valid to define a hash code method without overriding the equals method in the same class. But an implementation like this is strongly discouraged, considering all objects of a hash set or hash map will be put into the same bucket, deteriorating the performance of such a collection. Now for the second question. The equals method behaves exactly as specified, regardless of the values of its fields or the location of its containing object in memory. In this scenario, the equals method of my class always returns true, meaning that all instances of this class are equal. So this statement prints true, and the correct answer is A. Now for the third question. The hash code method must return an into value instead of a long. Like this. This method declaration has a return type incompatible with the overridden method of classobject, resulting in a compilation error. As shown here, the equals method of class object accepts an instance of the object type rather than a custom class. With this declaration, the My class has two overloaded equals methods. One is defined within it, and the other is inherited from the root class. So both the hash code and the equals methods over here do not override methods of the objectclass, and the correct answer is D. Now for the fourth question. In this question, the two-string method is declared without an access modifier. This means that it is packaged with a more restrictive scope than the overwritten method defined in the object class. Such an overwriting is forbidden in the Java programming language, so the correct answer is D. Compilation fails. Now for the fifth question. In this situation, the person class is declared with a two-string method, which overrides a method with the same name in the object class. This method defines the way a person instance is textually represented. Based on this statement, it is clear that the correct answer is C. It prints John Doe. Note that if this two-string method were not defined, option B would have been the correct answer. In this lesson, we have gone over some ofthe most commonly used methods of the object class,including hash code, equals and two string, as wellas how to override these methods. Now for a quick summary. The hash code method returns an integer used as the key, referencing a bucket in a hash set, hash map, or hash table. The equals method tests whether the two objects are equal, and the two string method returns a text representation of an object.

6. 1.5 Create and use singleton classes and immutable classes

Hello everybody. We will cover the fifth item of the Java class design topic in the JavaSe, a programmer-two exam syllabus, which is creating and using singleton classes and immutable classes, in this lesson. The definition of a singleton class is simple. Basically, it is a class that allows only a single instance to be created. These are common components of a singleton class. A private function Object() { [native code] } is mandatory for all singleton classes to prevent them from being instantiated from outside. The second important member is a public static method that returns the only instance of the class. A singleton class may also contain other members, depending on business requirements. In this lesson, we'll cover several implementations of a singleton class, including lazy initialization, initialization on demand with a holder idiom, eager initialization, and an implementation using enums. Notice that they are not the only ways to create a singleton class. You can write it your own way, as long as no more than one instance can be constructed from such a class. These implementations are the most commonly used in the Java world. This is a singleton class implementation using lazy initialization. It is called lazy because the class is not instantiated when it is loaded into memory. Instead, the only object of the class is created when this static factory method is first called. This singleton implementation is simple and thread safe.Its downside is that the factory method must be synchronised to avoid thread interference. However, the cost of making such a method synchronised is not high for most applications. Therefore, if you do not see a deterioration in performance, this implementation is a good choice. Here is another singleton implementation that makes use of lazy initialization. This pattern is called initialization on demand. Holder ID was introduced by computer scientist Bill Pugh at the University of Maryland. The pattern maintains the benefits of lazyloading while avoiding the synchronisation issue. Although this holder idiom is a bit more complicated than the simple lazy implementation shown before, due to the use of a static nested class, it is probably the most commonly used singleton pattern in Java. This is the simplest singleton implementation. It is called Eager since the singleton object is created when the containing class is loaded. The semantics of Java, however, ensure that the class is only loaded when it is referenced for the first time. Since we're using a singleton class without instantiating it, it makes almost no sense. Its single object is usually created when the static factory method is invoked. As a result, this implementation is also lazy. You can refactor the Eager initialization implementation this way, with the private static field and public static method being replaced by a public static field. This is the internal structure of an Enum type. Therefore, the singleton class can be rewritten as an enum, just like this singleton implementation was first introduced by Joshua Block in 2008 and is arguably the best way to implement a singleton class. However, notice that this implementation cannot extend any class other than enum. An immutable class is essentially a class whose objects' state cannot be modified after they are created. Here is a strategy for defining an immutable class. The first step is to make all fields final and private. You must not provide any methods that mutate fields. You must define the class in such a waythat does not allow subclasses to override its methods. The simplest way to do this is to declare the class as final. Another solution is to make the function Object() { [native code] } private and create its instances in factory methods. If instance fields of the class include references to mutable objects, do not directly expose those objects. This means that you should never store references to external Mutable objects that were passed to the function Object() { [native code] } or return references to internal Mutable objects. If necessary, store copies of those objects passed in the constructor or return copies of Mutable objects referenced by internal fields. Notice that you don't necessarily follow all of these steps. If you have a reason to believe that objects in your class will never be changed after construction, you are free to go with your own design. This is an example of a Mutable class. Both fields are final and private. No get-or-pay methods are provided. The class is declared as final, so it cannot be inherited and no methods can be overridden. When an instance of the Person class is constructed, it stores a copy of the mutable object argument and returns a duplicate of such a stored object when requested. Because the elements of the nicknames list in a Mutable class are of type string, the person class is also immutable. If this is not the case, you must make deep copies of those elements when storing them in the containing class and when returning from the getter method. Now let's move on to the advantage and disadvantage of immutable classes. The most important advantage of an immutable class is that its objects cannot be corrupted by thread interference or observed in an inconsistent state. This feature may help free you from writing code to protect objects in a multi-threaded environment. The biggest problem with using immutable classes is that a new object must be created each time you need an object with a different state. However, the cost of this creation is often exaggerated and should be offset by the benefits of using those classes. Now it's time for some practise questions to go over what we have learned. Here is the first question. As always, feel free to pause the video if you need more time. In this declaration, the static modifier cannot be removed as doing so will result in a compilation error. In the static factory method, the final modifier should not be removed either, since the instance field might be assigned another object by other methods. This access modifier, however, can be left out because even if the code outside of the class can access the instance variable, there is no way for such external code to set another object to this field. And this static factory method still returns the same object all the time. As a result, the correct answer is A. Now for the second question. In the given class declaration, the function Object() { [native code] } is not private. As a result, any number of instances of this class can be created. So, the correct answer is B. Now for the third question. In this question, the Whiz Labs class is not declared as final, nor is its function Object() { [native code] } private. As a result, the class may be extended and a subclass might hide or override its members, breaking the immutable model. So, the correct answer is B. Now for the fourth question. In the given scenario, when this list object is passed in the constructor, it is copied, and the internal field references the duplicate, not the original. When the member list is requested by this Getter method, an unmodifiable view of the internal state is returned. This design seems to make the class immutable. However, notice that the element type of those lists is "person," a Mutable class. Although code outside of the group class cannot modify the list referenced by this field, it can change elements of such a list. This potential modification makes the group class no longer immutable. As a result, the correct answer is B. In this lesson, we have gone over Singleton and Immutable classes. Taken at face value, these concepts are simple. However, when it comes to implementation, the patterns become much more complicated. To sum up, a Singleton class is a class that allows only one instance to be created. An immutable class is a class whose objects' state cannot be modified after creation.

7. 1.6 Develop code that uses static keyword on initialize blocks, variables, metho

Hello, everyone. In this lesson, we will go through the last item of the Java class design topic in the Java SE 8 programmer two exam syllabus, which is developing code that uses the static keyword on initialise blocks, variables, methods, and classes. The static keyword is declared on classmembers that are associated with the class itself rather than with any object. Fields that have the static modifier in their declaration are static fields, also called static variables or class variables. Here is a code example. We have a class declaration with an instance field and a static field. The change of the instance field of data one is not reflected in data two, but the change of the static field is. Therefore, the first print statement outputs the number zero, while the second prints the number one. Notice that static variables should be referenced by the class name. The access using object references shown here is used for demonstration only and should be avoided in your real-world projects. Now let's move on to static methods. Methods that have the static modifier in their declarations are static methods, also called class methods. The only difference between a static method and an instance is the use of the static keyword in its declaration. Similar to static variables, static methods should be invoked with the class name without the need to create an instance of the class. Static methods can also be referred to using object references, but such usage is discouraged since it does not make it clear that the method belongs to a class, not an instance. Static methods cannot directly access instance variables or call instance methods. In order to do so, those static methods must use object references. Therefore, static methods are usually used to access and mutate static fields. A static initialization block is a normal block of code enclosed within curly braces preceded by the static keyword. Here is the structure of such an initialization block. A class can have any number of static initialization blocks, and they can appear anywhere in the class body. These blocks are guaranteed to be called exactly once when the enclosing class is loaded into memory and in the order that they appear in the source code. Static initialization blocks do not have access to instance variables and instance methods of the enclosing class. A static class must be declared inside another class and have access to static members of the enclosing class, including private ones. This is an example of such a static class. Even a private static member of the outer class, like this field, can be accessed from the static nested class. A static class cannot refer directly to instance variables or methods of its containing class. Instead, it must use object references to access those members. If the outer VAR variable over here is an instance field, the static nested class must access the variable using an object reference, as shown here, from outside of the outer class. A static nested class must be referenced using the name of such an outer class as this. If the static class is referenced from inside the enclosing class, the name of the outer class may be left off. Now, let's see how static members of a class interact. Notice that static methods, static initialization blocks, and static classes cannot access instance members of the enclosing class. Therefore, if you remove the static keyword over here, you'll end up with these compilation errors. Likewise, if the print method is changed to nonstatic, a compilation error also occurs. Let's see the result of the program. When executing the main method, the function Object() { [native code] } of the nested class was executed, whereas that of the mainapp class was not, as shown here. This is clear, since only the function Object() { [native code] } of the nested class was invoked. This string was printed from the print method, which was invoked in this initialization block. The invocation happened because when the mainapp class was loaded, its static initialization block was executed automatically right after the initialization of this static field. Now, it's time for some practise questions to go over what we have learned. Here is the first question. As always, feel free to pause the video if you need more time. In this question, the main method makes a static reference to a nonstatic field. This operation is not allowed resulting in a compilation error, so the correct answer is A. Now for the second question. In this situation, this static field is shared among all instances of the class. So the increment here is reflected in all other objects of the main app class. As a result, the number one will be printed out, and the correct answer is C. Now for the third question. In the given scenario, the static initialization block is executed after this field is initialized. These initializations occur when the main appclass is loaded into memory prior to the execution of the main class. So the string Whizlabs will be printed out, and the correct answer is D. Now for the fourth question. When the main app class is loaded into memory, the static VAR field is first initialised to its default value of zero. Next, this static initialization block is executed, increasing the value of static VAR to one. When the nested class is instantiated, a static VAR is raised again. Therefore, the value of field static VAR is two after this statement is executed, and the correct answer is D. In this lesson, we have gone over static members of a class, including static variables, static methods, static initialization blocks, and static nested classes. Here is a summary of what we have learned. Remember, static variables and static methods are associated with the containing class and shared among all class instances. Static initialization blocks are normal codeblocks that are called once. When the classes are loaded into memory, static classes must be nested inside another class and have access to all static members of such an outer class.

Hide