Add files using upload-large-folder tool

.gitattributes

@@ -52,3 +52,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 05[[:space:]]-[[:space:]]Operators[[:space:]]and[[:space:]]Operations[[:space:]]with[[:space:]]primitive[[:space:]]types/004[[:space:]]Type[[:space:]]of[[:space:]]the[[:space:]]expression[[:space:]]in[[:space:]]Java.mp4 filter=lfs diff=lfs merge=lfs -text
 05[[:space:]]-[[:space:]]Operators[[:space:]]and[[:space:]]Operations[[:space:]]with[[:space:]]primitive[[:space:]]types/001[[:space:]]Operators[[:space:]]in[[:space:]]Java.mp4 filter=lfs diff=lfs merge=lfs -text
 05[[:space:]]-[[:space:]]Operators[[:space:]]and[[:space:]]Operations[[:space:]]with[[:space:]]primitive[[:space:]]types/006[[:space:]]Read[[:space:]]user[[:space:]]input[[:space:]]from[[:space:]]console.mp4 filter=lfs diff=lfs merge=lfs -text
+05[[:space:]]-[[:space:]]Operators[[:space:]]and[[:space:]]Operations[[:space:]]with[[:space:]]primitive[[:space:]]types/005[[:space:]]Compare[[:space:]]primitive[[:space:]]and[[:space:]]reference[[:space:]]types[[:space:]]&[[:space:]]Java[[:space:]]Memory[[:space:]]Model.mp4 filter=lfs diff=lfs merge=lfs -text
+05[[:space:]]-[[:space:]]Operators[[:space:]]and[[:space:]]Operations[[:space:]]with[[:space:]]primitive[[:space:]]types/010[[:space:]]Homework[[:space:]]review[[:space:]]Operators[[:space:]]and[[:space:]]Operations.mp4 filter=lfs diff=lfs merge=lfs -text
+06[[:space:]]-[[:space:]]Strings[[:space:]]in[[:space:]]Java/001[[:space:]]String[[:space:]]object[[:space:]]creation[[:space:]]and[[:space:]]main[[:space:]]methods[[:space:]]overview.mp4 filter=lfs diff=lfs merge=lfs -text
+06[[:space:]]-[[:space:]]Strings[[:space:]]in[[:space:]]Java/002[[:space:]]String[[:space:]]comparison[[:space:]][[:space:]]How[[:space:]]to[[:space:]]compare[[:space:]]Strings[[:space:]]and[[:space:]]what[[:space:]]is[[:space:]]String[[:space:]]Pool.mp4 filter=lfs diff=lfs merge=lfs -text
+06[[:space:]]-[[:space:]]Strings[[:space:]]in[[:space:]]Java/003[[:space:]]Escape[[:space:]]Sequences[[:space:]]in[[:space:]]Java.mp4 filter=lfs diff=lfs merge=lfs -text

05 - Operators and Operations with primitive types/005 Compare primitive and reference types & Java Memory Model.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa65814a0105381b8efd2e0754d45865f0cba944d1c84f5f900c366f9fa4950a
+size 182856283

05 - Operators and Operations with primitive types/010 Homework review Operators and Operations.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6113b981b8c9003eb4c3d4f46010c7bb6b48364f57b6afa30046ed2502f565f9
+size 207450063

06 - Strings in Java/001 String object creation and main methods overview.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b15ae7711f85af21a92bc9f098a73bb122ec2c99181df74a9b929846944008a0
+size 52079039

06 - Strings in Java/002 String comparison How to compare Strings and what is String Pool.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0382fc777a8b147d88218daf2590a8f1824d3feb332f77b80882436bff9b35e3
+size 50592934

06 - Strings in Java/003 Escape Sequences in Java.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e03bf9b9c615acfa82054ac6fe95d1f244912ea5bc42dca16c10236cf7c2027c
+size 15472125

13 - Object-oriented programming/002 Classes & Objects_en.srt

@@ -0,0 +1,856 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, Jim.
+
+2
+00:00:06,000 --> 00:00:08,000
+So they were going to run with you with the glasses.
+
+3
+00:00:09,000 --> 00:00:12,000
+We'll talk about what glass can contain on good examples.
+
+4
+00:00:12,000 --> 00:00:17,000
+We learn what our fields and utilization logs, constructors methods and nested classes.
+
+5
+00:00:17,000 --> 00:00:21,000
+I'm going to explain to you what getters and setters are and how we can use them.
+
+6
+00:00:21,000 --> 00:00:26,000
+We are going to create our own class and we'll create object of our custom class together.
+
+7
+00:00:26,000 --> 00:00:28,000
+Let's start from the previous lesson.
+
+8
+00:00:28,000 --> 00:00:33,000
+You already know that class is our template for objects, but what does it consist of?
+
+9
+00:00:33,000 --> 00:00:41,000
+Glass can contain constructors, fields, methods and utilization blocks and nested classes to understand
+
+10
+00:00:41,000 --> 00:00:41,000
+and better.
+
+11
+00:00:41,000 --> 00:00:43,000
+Let's jump to example.
+
+12
+00:00:43,000 --> 00:00:48,000
+Let's imagine we are implementing online store and we need to implement our virtual card for shopping.
+
+13
+00:00:49,000 --> 00:00:53,000
+You already know OPIS and you know that everything is an object.
+
+14
+00:00:53,000 --> 00:00:56,000
+Take into account we expect multiple users on our website.
+
+15
+00:00:56,000 --> 00:00:58,000
+We are going to have a lot of cards.
+
+16
+00:00:58,000 --> 00:01:01,000
+We need to have a template for card object.
+
+17
+00:01:01,000 --> 00:01:04,000
+That's why we need to create card class.
+
+18
+00:01:04,000 --> 00:01:05,000
+Here's card class.
+
+19
+00:01:05,000 --> 00:01:09,000
+I created it beforehand to save time during this video lesson.
+
+20
+00:01:09,000 --> 00:01:11,000
+I will walk you through it line by line.
+
+21
+00:01:12,000 --> 00:01:14,000
+Our goal now to understand what class can contain.
+
+22
+00:01:15,000 --> 00:01:17,000
+First of all, class can contain fields.
+
+23
+00:01:18,000 --> 00:01:19,000
+Often fields are called properties.
+
+24
+00:01:20,000 --> 00:01:25,000
+With the help of the fields we can express state of specific object fields can have different modifiers.
+
+25
+00:01:26,000 --> 00:01:30,000
+For example, fields can be static and non static, final and non final.
+
+26
+00:01:30,000 --> 00:01:35,000
+We are going to have separate lesson about static keyword and static elements in Java and we'll discuss
+
+27
+00:01:35,000 --> 00:01:36,000
+final keywords.
+
+28
+00:01:36,000 --> 00:01:40,000
+Also in separate lesson, this lesson only about classes.
+
+29
+00:01:40,000 --> 00:01:43,000
+So this is all fields which we have in our class.
+
+30
+00:01:43,000 --> 00:01:45,000
+Class also can contain initialization blocks.
+
+31
+00:01:46,000 --> 00:01:49,000
+We may have static and on static initialization blocks.
+
+32
+00:01:49,000 --> 00:01:50,000
+Why do we need them?
+
+33
+00:01:50,000 --> 00:01:55,000
+For example, I have some fields which I want to be initialized with values by default.
+
+34
+00:01:56,000 --> 00:01:59,000
+In this case, every timecards object will be created.
+
+35
+00:01:59,000 --> 00:02:05,000
+Card counter will be incremented in case cards will be created without user i.e. I know that I need
+
+36
+00:02:05,000 --> 00:02:07,000
+to sign this card to some user.
+
+37
+00:02:08,000 --> 00:02:13,000
+Let it be special user with ID one and one of the properties has tax time.
+
+38
+00:02:13,000 --> 00:02:16,000
+This is also custom type described by us.
+
+39
+00:02:16,000 --> 00:02:18,000
+I will show it to you later in this lesson.
+
+40
+00:02:19,000 --> 00:02:24,000
+But now imagine that you have this field and you don't want to leave it, not initialized.
+
+41
+00:02:24,000 --> 00:02:27,000
+What default value has all reference types of data?
+
+42
+00:02:27,000 --> 00:02:28,000
+No.
+
+43
+00:02:28,000 --> 00:02:34,000
+And according to logic that I implemented, I know that tax should not be known to avoid no pointer
+
+44
+00:02:34,000 --> 00:02:40,000
+exception because I use this variable in court below and b what stands for null pointer exception,
+
+45
+00:02:40,000 --> 00:02:44,000
+one of the most widespread exception which happens when you call method or new value.
+
+46
+00:02:45,000 --> 00:02:47,000
+That's why it's called no pointer exception.
+
+47
+00:02:48,000 --> 00:02:50,000
+We'll learn more about exceptions in separate section.
+
+48
+00:02:50,000 --> 00:02:54,000
+For now, I want at least some default value should be assigned to this variable.
+
+49
+00:02:55,000 --> 00:02:57,000
+That is exactly what I'm doing here.
+
+50
+00:02:57,000 --> 00:03:02,000
+I using this civilization look to initialize this field, the similar situation with our discount object.
+
+51
+00:03:02,000 --> 00:03:09,000
+I initialize this field to make sure it won't be no talking about starting blocks, it is worth to mention
+
+52
+00:03:09,000 --> 00:03:13,000
+that they are very narrow application domain Whiskas class example.
+
+53
+00:03:13,000 --> 00:03:16,000
+It was hard for me to come up with the example of static initialization block.
+
+54
+00:03:17,000 --> 00:03:22,000
+This block will be executed only once one class will be uploaded into GBM.
+
+55
+00:03:22,000 --> 00:03:25,000
+In this case we just write text to console.
+
+56
+00:03:25,000 --> 00:03:29,000
+Good example of static Blokland civilization usage is driver classis.
+
+57
+00:03:29,000 --> 00:03:35,000
+You always need to register driver in the system so it would be comfortable to use static initialization
+
+58
+00:03:35,000 --> 00:03:36,000
+work for this.
+
+59
+00:03:36,000 --> 00:03:41,000
+For example, once driver class is uploaded into GBM, we can register it in some services.
+
+60
+00:03:42,000 --> 00:03:45,000
+This is a real life example which we will see later in this course.
+
+61
+00:03:45,000 --> 00:03:50,000
+But now you at least understand how potentially we can use static in civilization.
+
+62
+00:03:50,000 --> 00:03:52,000
+Bloks problems it again.
+
+63
+00:03:52,000 --> 00:03:59,000
+Universalization looks let's move on may contain constructor's constructor is a special method which
+
+64
+00:03:59,000 --> 00:04:01,000
+should be called to instantiate object.
+
+65
+00:04:01,000 --> 00:04:06,000
+Important things to mention about the constructor constructor name should always be the same as class
+
+66
+00:04:06,000 --> 00:04:07,000
+name.
+
+67
+00:04:07,000 --> 00:04:12,000
+If your class name is called, then constructor is also called rule about writing.
+
+68
+00:04:12,000 --> 00:04:15,000
+Method starting from lowercase is not applied to constructors.
+
+69
+00:04:15,000 --> 00:04:17,000
+It doesn't have return type.
+
+70
+00:04:17,000 --> 00:04:21,000
+You remember that all method should have return type in constructor.
+
+71
+00:04:21,000 --> 00:04:27,000
+You should not specify return time because constructors always by default return reference to the object
+
+72
+00:04:27,000 --> 00:04:27,000
+and keep memory.
+
+73
+00:04:28,000 --> 00:04:30,000
+You always have constructor by default.
+
+74
+00:04:30,000 --> 00:04:31,000
+Let me show you this.
+
+75
+00:04:32,000 --> 00:04:36,000
+Even if I wouldn't have this constructors, I would still have default one.
+
+76
+00:04:36,000 --> 00:04:41,000
+Let me comment on this court and now let's jump to the demo file and create card object.
+
+77
+00:04:42,000 --> 00:04:45,000
+Let me declare a variable of type card and assign cards.
+
+78
+00:04:45,000 --> 00:04:46,000
+Object to it.
+
+79
+00:04:46,000 --> 00:04:48,000
+The great object I write new keyword.
+
+80
+00:04:49,000 --> 00:04:55,000
+This is a common to Java to allocate memory for object in here and after that I call constructor and
+
+81
+00:04:55,000 --> 00:04:56,000
+print cards object to cancel.
+
+82
+00:04:57,000 --> 00:04:58,000
+Let's run this program.
+
+83
+00:04:59,000 --> 00:05:05,000
+And here we are, you see that quote from Start, a conservation blog executed first, and here's our
+
+84
+00:05:05,000 --> 00:05:06,000
+character object printed to console.
+
+85
+00:05:07,000 --> 00:05:09,000
+Now let me create custom constructor.
+
+86
+00:05:09,000 --> 00:05:13,000
+Let's pretend I want to create card with specified cartridges and user aguy.
+
+87
+00:05:14,000 --> 00:05:18,000
+And when I created custom constructor, there is no default constructor anymore.
+
+88
+00:05:18,000 --> 00:05:20,000
+And here is see compilation error.
+
+89
+00:05:20,000 --> 00:05:22,000
+The constructor card is undefined.
+
+90
+00:05:23,000 --> 00:05:27,000
+That's why if you want to declare a custom constructor and keep constructor by default, you should
+
+91
+00:05:27,000 --> 00:05:32,000
+specified explicitly when I am Corman's, this constructor compilation error is gone.
+
+92
+00:05:33,000 --> 00:05:36,000
+Let's take a look how we can use custom constructor.
+
+93
+00:05:36,000 --> 00:05:42,000
+We know that our constructor can take two integers as arguments and you see that the first parameter
+
+94
+00:05:42,000 --> 00:05:48,000
+will be assigned to a property of this object in the second parameter will be assigned to user the property
+
+95
+00:05:48,000 --> 00:05:49,000
+of the current object.
+
+96
+00:05:50,000 --> 00:05:56,000
+You can see that I use this keyword to reference current object because this idea, if this property
+
+97
+00:05:56,000 --> 00:06:03,000
+in card object and ID is just a local variable of the constructor, that that makes sense.
+
+98
+00:06:03,000 --> 00:06:09,000
+So inside the class you have keywords which always reference to the specific object.
+
+99
+00:06:10,000 --> 00:06:16,000
+Now you can call your custom constructor like this new card and parse constructor arguments when we
+
+100
+00:06:16,000 --> 00:06:17,000
+bring second car token.
+
+101
+00:06:17,000 --> 00:06:22,000
+So you can see that IJI and user idea of this class is different from the first class object.
+
+102
+00:06:23,000 --> 00:06:28,000
+Now, when you know what the constructor's, you might be wondering why do we need initialization blocks
+
+103
+00:06:28,000 --> 00:06:33,000
+if they have constructor's on this example, you can see that no matter which constructor will be called
+
+104
+00:06:33,000 --> 00:06:35,000
+utilisation, LOC will be executed.
+
+105
+00:06:35,000 --> 00:06:36,000
+In both cases.
+
+106
+00:06:36,000 --> 00:06:42,000
+Knowing this, you can use initialization blocks to put their code, which you want to execute no matter
+
+107
+00:06:42,000 --> 00:06:43,000
+what constructor will be called.
+
+108
+00:06:43,000 --> 00:06:47,000
+Is it clear now what else our class can have?
+
+109
+00:06:47,000 --> 00:06:49,000
+Our class can have methods.
+
+110
+00:06:49,000 --> 00:06:51,000
+That is behavior of our object.
+
+111
+00:06:51,000 --> 00:06:54,000
+For example, our cars can add new product to the cart.
+
+112
+00:06:55,000 --> 00:06:57,000
+Let's not get deep dive into the logic here.
+
+113
+00:06:57,000 --> 00:07:03,000
+I will share with you source code of this lesson and you will be able to take a look miserably at implementation.
+
+114
+00:07:03,000 --> 00:07:09,000
+But now let's understand that methods are behavior of our object and can change state of our object.
+
+115
+00:07:10,000 --> 00:07:13,000
+And now you can understand the difference between method and function.
+
+116
+00:07:14,000 --> 00:07:17,000
+Function can exist without object independently.
+
+117
+00:07:17,000 --> 00:07:19,000
+Method is the behavior of the object.
+
+118
+00:07:20,000 --> 00:07:26,000
+That's why in Olby we call specific box of code, which can be invoked by their names methods but not
+
+119
+00:07:26,000 --> 00:07:28,000
+functions methods.
+
+120
+00:07:28,000 --> 00:07:31,000
+This is something that is always associated with an object.
+
+121
+00:07:31,000 --> 00:07:37,000
+In this particular example, our card contains an array of products and we can add product to this card,
+
+122
+00:07:37,000 --> 00:07:39,000
+namely to this array of products.
+
+123
+00:07:40,000 --> 00:07:42,000
+That is exactly what this method does.
+
+124
+00:07:42,000 --> 00:07:46,000
+It adds new product and change the state of our cart.
+
+125
+00:07:46,000 --> 00:07:51,000
+Notice that each time new product is added to the cart, other methods are called to calculate total
+
+126
+00:07:51,000 --> 00:07:53,000
+net price and total gross price.
+
+127
+00:07:54,000 --> 00:07:55,000
+These are two private methods.
+
+128
+00:07:56,000 --> 00:08:00,000
+That means nobody outside this class can call these methods.
+
+129
+00:08:00,000 --> 00:08:02,000
+I can call these methods from this class.
+
+130
+00:08:02,000 --> 00:08:07,000
+Only X modifiers will be covered in detail in encapsulation.
+
+131
+00:08:07,000 --> 00:08:10,000
+Lesson in your code method and location might look like this.
+
+132
+00:08:11,000 --> 00:08:16,000
+You created car to object and after that use its behavior to add product to the cart products is also
+
+133
+00:08:16,000 --> 00:08:17,000
+our custom class.
+
+134
+00:08:17,000 --> 00:08:22,000
+By the way, here it is, just two properties for the sake of our example.
+
+135
+00:08:23,000 --> 00:08:29,000
+And he seemed concerned that after we added two products, total net price, total gross price and total
+
+136
+00:08:29,000 --> 00:08:30,000
+tax have been changed.
+
+137
+00:08:31,000 --> 00:08:37,000
+After these methods, I have other methods that are called getters and setters, why do we need them?
+
+138
+00:08:38,000 --> 00:08:40,000
+You see that all properties of cart objects are private.
+
+139
+00:08:41,000 --> 00:08:46,000
+That is because I want to have full control over how people can interact with my object and how they
+
+140
+00:08:46,000 --> 00:08:47,000
+can change.
+
+141
+00:08:47,000 --> 00:08:51,000
+State of object was usually used to rid properties of objects.
+
+142
+00:08:51,000 --> 00:08:57,000
+You can be 100 if we are making our properties private so nobody could access them and change them,
+
+143
+00:08:57,000 --> 00:08:59,000
+then why do we need to create better sensors?
+
+144
+00:09:00,000 --> 00:09:02,000
+Let me explain you on this example.
+
+145
+00:09:02,000 --> 00:09:08,000
+You can create together and return your products array, but this means that everybody who has links
+
+146
+00:09:08,000 --> 00:09:10,000
+to your products array can change state of disarray.
+
+147
+00:09:10,000 --> 00:09:16,000
+Just using this reference, for example, having reference to products, every object I can add to more
+
+148
+00:09:16,000 --> 00:09:20,000
+products in it and state of the card will be different.
+
+149
+00:09:20,000 --> 00:09:26,000
+In this case, there would be two more products in CART, but now when you can write code of your car,
+
+150
+00:09:26,000 --> 00:09:29,000
+you can say that you want to give reference to this array.
+
+151
+00:09:30,000 --> 00:09:35,000
+Everyone who wants to investigate state of products are we can do this and you can return a copy of
+
+152
+00:09:35,000 --> 00:09:37,000
+the script by doing this.
+
+153
+00:09:37,000 --> 00:09:42,000
+You can be sure that even if in some other places reference to products that will be obtained, they
+
+154
+00:09:42,000 --> 00:09:48,000
+will get reference to the copy of your and won't be able to change state of our regional products away
+
+155
+00:09:48,000 --> 00:09:49,000
+from your car.
+
+156
+00:09:49,000 --> 00:09:54,000
+This is critical for us because based on the products from this array, we calculate total net and total
+
+157
+00:09:54,000 --> 00:09:55,000
+gross price.
+
+158
+00:09:56,000 --> 00:10:01,000
+Imagine that somebody would take the reference to products are a few more products to it without recalculate
+
+159
+00:10:01,000 --> 00:10:05,000
+total net and gross price and would just proceed to checkout with this car.
+
+160
+00:10:06,000 --> 00:10:12,000
+Customers would be happy that they got more items for free, but our management definitely won't be
+
+161
+00:10:12,000 --> 00:10:12,000
+happy.
+
+162
+00:10:13,000 --> 00:10:18,000
+And if I don't want that somebody said a completely new array of products in my car, I just don't create
+
+163
+00:10:18,000 --> 00:10:19,000
+Setar.
+
+164
+00:10:19,000 --> 00:10:19,000
+That's it.
+
+165
+00:10:20,000 --> 00:10:24,000
+But if you have Setar, you can verify arguments to make sure that they are valid.
+
+166
+00:10:24,000 --> 00:10:30,000
+According to our business logic, for example, everyone can, said Cartledge here, but nobody can
+
+167
+00:10:30,000 --> 00:10:37,000
+set a value less than zero because I wrote the code to verify this in case I'd is less than zero.
+
+168
+00:10:37,000 --> 00:10:43,000
+Just exit from this method and you can see that Rejon keyword is also used to exit method in both methods.
+
+169
+00:10:44,000 --> 00:10:50,000
+Even when you don't have intention to return some value from method or like here, for example, anybody
+
+170
+00:10:50,000 --> 00:10:51,000
+can add product to the cart.
+
+171
+00:10:51,000 --> 00:10:57,000
+But in case somebody is trying to add no into my array, I don't allow to do this and exit from method.
+
+172
+00:10:57,000 --> 00:11:03,000
+Remember that validation of all arguments which were passed to the method if the rule which you always
+
+173
+00:11:03,000 --> 00:11:04,000
+must follow.
+
+174
+00:11:04,000 --> 00:11:12,000
+By the way, if you want easily generated getters and setters, use next hotkey old shift s and select
+
+175
+00:11:12,000 --> 00:11:13,000
+generate getters and setters.
+
+176
+00:11:14,000 --> 00:11:17,000
+You can select fields for which you need getters and setters or only getters.
+
+177
+00:11:17,000 --> 00:11:23,000
+For example, if you don't want the grade setters and vice versa, press generate to generate code.
+
+178
+00:11:23,000 --> 00:11:25,000
+I already have all necessary getters and setters.
+
+179
+00:11:25,000 --> 00:11:27,000
+That is why I wouldn't press this button.
+
+180
+00:11:27,000 --> 00:11:30,000
+Now, in case you forgot hotkeys press mouse right.
+
+181
+00:11:30,000 --> 00:11:33,000
+Click select source and then generate getters and setters.
+
+182
+00:11:34,000 --> 00:11:40,000
+We have to string method here, we are going to talk about this method in details in the lesson about
+
+183
+00:11:40,000 --> 00:11:40,000
+object class.
+
+184
+00:11:41,000 --> 00:11:46,000
+But in the meantime, let me explain you what this method is about in a few words in Arkansas here we
+
+185
+00:11:46,000 --> 00:11:49,000
+see text representation of our the object.
+
+186
+00:11:49,000 --> 00:11:52,000
+That is because to string method is overridden here.
+
+187
+00:11:52,000 --> 00:11:59,000
+And you can see how the string is created from combination of fields from our car object when we pass
+
+188
+00:11:59,000 --> 00:12:04,000
+reference type to Winterland, method to string method call is invisible for us and when to string method
+
+189
+00:12:04,000 --> 00:12:08,000
+is called this code is executed and this string is returned.
+
+190
+00:12:09,000 --> 00:12:15,000
+That's why we see rideable representation of our card object to generate to string method use the same
+
+191
+00:12:15,000 --> 00:12:19,000
+hotkey as we discussed earlier, all shifts and select generate to string.
+
+192
+00:12:20,000 --> 00:12:26,000
+It says that I already have two string but still I want to show you details you can select which fields
+
+193
+00:12:26,000 --> 00:12:30,000
+methods you would like to use to create string which will be returned after the string method call.
+
+194
+00:12:32,000 --> 00:12:37,000
+Besides what we have already discussed, glasses can also contain nested glasses, nested glasses can
+
+195
+00:12:37,000 --> 00:12:44,000
+be static and non static, static nested glasses, usually called just nested static glasses and nested,
+
+196
+00:12:44,000 --> 00:12:47,000
+not static glasses, usually called inner glasses.
+
+197
+00:12:48,000 --> 00:12:53,000
+And here you see discount untax glasses we use for both of these types in our cars glass.
+
+198
+00:12:54,000 --> 00:12:59,000
+And I believe you remember the beginning reinitialize variables of these types with default values in
+
+199
+00:12:59,000 --> 00:13:03,000
+our initialization lock to not overwhelm you with information.
+
+200
+00:13:03,000 --> 00:13:07,000
+In this lesson, let's agree to learn types of classes in the separate lesson.
+
+201
+00:13:07,000 --> 00:13:09,000
+For now, let's repeat one more time.
+
+202
+00:13:09,000 --> 00:13:16,000
+One glass can contain glass, can contain fildes, initialization blocks, constructors methods, nested
+
+203
+00:13:16,000 --> 00:13:17,000
+classes.
+
+204
+00:13:17,000 --> 00:13:22,000
+And we know that nested classes could be nested static classes and in their classes.
+
+205
+00:13:22,000 --> 00:13:27,000
+I will share with you links to the source code in attachments to this lesson so you can review it one
+
+206
+00:13:27,000 --> 00:13:27,000
+more time.
+
+207
+00:13:28,000 --> 00:13:30,000
+Method classes will be discussed in the separate lesson.
+
+208
+00:13:31,000 --> 00:13:33,000
+And now let's review what we have learned today.
+
+209
+00:13:34,000 --> 00:13:38,000
+Today we learned what class can contain and how to create our custom objects.
+
+210
+00:13:38,000 --> 00:13:43,000
+Now you know the difference between a method and a function, really, of the concept of getters and
+
+211
+00:13:43,000 --> 00:13:46,000
+setters and how to generate them easily in eclipse.
+
+212
+00:13:47,000 --> 00:13:51,000
+Take a look one more time in the source code of examples which we reviewed during the lesson and be
+
+213
+00:13:51,000 --> 00:13:53,000
+prepared for the next lesson.
+
+214
+00:13:53,000 --> 00:13:56,000
+Thank you for your attention and see you in the next lesson.
+

13 - Object-oriented programming/002 Source-code-Cart-class.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/classes/Cart.java

13 - Object-oriented programming/002 Source-code-Demo-class.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/classes/Demo.java

13 - Object-oriented programming/002 Source-code-Product-class.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/classes/Product.java

13 - Object-oriented programming/003 Different types of Classes, Abstract keyword and Abstract classes_en.srt

@@ -0,0 +1,584 @@
+1
+00:00:05,000 --> 00:00:07,000
+Hello, yes, students today.
+
+2
+00:00:07,000 --> 00:00:08,000
+We'll talk more about.
+
+3
+00:00:08,000 --> 00:00:11,000
+I'm going to tell you what types of classes we have in Java.
+
+4
+00:00:12,000 --> 00:00:18,000
+We'll talk about all types of classes can create inner nested final classes, Bodger classes, Absaroka
+
+5
+00:00:18,000 --> 00:00:19,000
+and Anonymous.
+
+6
+00:00:20,000 --> 00:00:24,000
+During the lesson, you are going to learn what is APSA key word and how you can use it with classes
+
+7
+00:00:24,000 --> 00:00:28,000
+and methods to learn this topic, it is better to start from examples.
+
+8
+00:00:29,000 --> 00:00:34,000
+Before this lesson, I created a concrete class to show you why it's called concrete because this class
+
+9
+00:00:34,000 --> 00:00:37,000
+has an implementation for all of its methods.
+
+10
+00:00:37,000 --> 00:00:40,000
+Concrete classes can have any and implemented methods.
+
+11
+00:00:41,000 --> 00:00:45,000
+Let's imagine we're implementing the e-commerce platform and we have user in it.
+
+12
+00:00:45,000 --> 00:00:52,000
+User has its own properties like Unique ID, first name, last name, email, and an array of products
+
+13
+00:00:52,000 --> 00:00:58,000
+which user bought in our online shop user can calculate personal discount based on the total amount
+
+14
+00:00:58,000 --> 00:01:03,000
+of money he or she spent in our shop in case he spent more than one thousand dollars.
+
+15
+00:01:04,000 --> 00:01:06,000
+User gets five percent discount.
+
+16
+00:01:06,000 --> 00:01:11,000
+The rest of the methods are getters and setters and you can see that all methods have implementation.
+
+17
+00:01:12,000 --> 00:01:14,000
+To create an object of a concrete class.
+
+18
+00:01:14,000 --> 00:01:16,000
+You just need to call the constructor of this type.
+
+19
+00:01:20,000 --> 00:01:26,000
+Now, let's take a look what nested classes are you already know that we can have nested static classes
+
+20
+00:01:26,000 --> 00:01:29,000
+and inner classes to explain what the nested class is?
+
+21
+00:01:29,000 --> 00:01:31,000
+Let's consider the next case.
+
+22
+00:01:31,000 --> 00:01:37,000
+Imagine we have Kaat object and we need to declare a specific class which will represent the tax.
+
+23
+00:01:37,000 --> 00:01:42,000
+But logically, we understand that tax can exist without Kaat.
+
+24
+00:01:42,000 --> 00:01:48,000
+But there is no sense to have tax without cards because if the cart is empty, then the tax for this
+
+25
+00:01:48,000 --> 00:01:50,000
+order also will be absent.
+
+26
+00:01:51,000 --> 00:01:56,000
+Then there is no reason to have this tax, but still it can exist.
+
+27
+00:01:56,000 --> 00:02:02,000
+Agree, taking into account the fact that tax is tightly coupled with the cart object, we declare a
+
+28
+00:02:02,000 --> 00:02:07,000
+new class inside cart here you see that I add Statik static modifier before class.
+
+29
+00:02:07,000 --> 00:02:10,000
+But beside that this class can contain everything.
+
+30
+00:02:10,000 --> 00:02:12,000
+What a concrete class can contain.
+
+31
+00:02:13,000 --> 00:02:17,000
+To create an instance of a tax object, you need to call constructor of tax type.
+
+32
+00:02:17,000 --> 00:02:25,000
+But with the help of car type, you have to write new laws and specify the class dot name of the nested
+
+33
+00:02:25,000 --> 00:02:27,000
+class and call a constructor.
+
+34
+00:02:27,000 --> 00:02:32,000
+You might be wondering what is the sense and declare an asset class if we can create object of nested
+
+35
+00:02:32,000 --> 00:02:35,000
+class when we need without object of court class.
+
+36
+00:02:36,000 --> 00:02:37,000
+And you will be right.
+
+37
+00:02:37,000 --> 00:02:42,000
+As we keep learning object oriented programming, you will see different examples from JDK and you will
+
+38
+00:02:42,000 --> 00:02:49,000
+feel when you need to create nested classes and very often nested classes have private modifier so that
+
+39
+00:02:49,000 --> 00:02:54,000
+you wouldn't be able to create an instance of nested class outside of the order class because of their
+
+40
+00:02:54,000 --> 00:03:00,000
+close relation in this particular case with that client of our code to create an object without cards.
+
+41
+00:03:00,000 --> 00:03:03,000
+But we are seen with our architecture here.
+
+42
+00:03:03,000 --> 00:03:05,000
+That tax is closely connected with class object.
+
+43
+00:03:06,000 --> 00:03:08,000
+On the other hand, you have inner classes.
+
+44
+00:03:08,000 --> 00:03:13,000
+They are also declared inside of classes, but they do not have static modifier.
+
+45
+00:03:13,000 --> 00:03:19,000
+Imagine that we have card and you need to describe discounts that can be applied to the card and in
+
+46
+00:03:19,000 --> 00:03:22,000
+your program, discount can't exist without a card.
+
+47
+00:03:22,000 --> 00:03:25,000
+In this case, we need to create an inner class and here it is.
+
+48
+00:03:26,000 --> 00:03:30,000
+You can create methods and fields and everything else inside the inner class.
+
+49
+00:03:31,000 --> 00:03:37,000
+Now let's take a look how we can create objects of inner class to instantiate objects of inner class.
+
+50
+00:03:37,000 --> 00:03:40,000
+You need to have a reference to the object of auto class.
+
+51
+00:03:40,000 --> 00:03:45,000
+Does that mean you can't create object of inner class without having an object of auto class?
+
+52
+00:03:46,000 --> 00:03:49,000
+That's why here a great object of the car type first.
+
+53
+00:03:49,000 --> 00:03:54,000
+And after that I create the object of the discount type and call the constructor.
+
+54
+00:03:54,000 --> 00:04:00,000
+Now I can assign reference to this object to this variable, the feel, the difference between inner
+
+55
+00:04:00,000 --> 00:04:01,000
+and nested classes.
+
+56
+00:04:02,000 --> 00:04:06,000
+Hobbs's specific examples help you to understand the difference better.
+
+57
+00:04:06,000 --> 00:04:09,000
+As always, you have the opportunity to look at the source code.
+
+58
+00:04:09,000 --> 00:04:12,000
+I will leave links to these files in the attachments to this lesson.
+
+59
+00:04:13,000 --> 00:04:16,000
+Now let's talk about what the final classes are.
+
+60
+00:04:16,000 --> 00:04:19,000
+We can make our user class final just like this.
+
+61
+00:04:19,000 --> 00:04:22,000
+Just add final keyword before class.
+
+62
+00:04:22,000 --> 00:04:23,000
+What does it mean?
+
+63
+00:04:23,000 --> 00:04:30,000
+You remember I told you about inheritance as a basic or principle when you wrote final keyword here.
+
+64
+00:04:30,000 --> 00:04:33,000
+That means you are not able to describe new classes.
+
+65
+00:04:33,000 --> 00:04:39,000
+And based on this one, that means you are not able to extend this class and add new behavior to this
+
+66
+00:04:39,000 --> 00:04:39,000
+type.
+
+67
+00:04:40,000 --> 00:04:42,000
+For example, string is also final class.
+
+68
+00:04:43,000 --> 00:04:47,000
+And let's imagine I want to extend user from Streambed for some reasons.
+
+69
+00:04:50,000 --> 00:04:57,000
+I can write extends here and string the type user cannot be a subclass of the final clustering.
+
+70
+00:04:58,000 --> 00:05:00,000
+We'll talk more about inheritance in a separate lesson.
+
+71
+00:05:01,000 --> 00:05:06,000
+But right now, I want you to understand that when we are talking about final classes, first of all,
+
+72
+00:05:06,000 --> 00:05:08,000
+women classes that we can't extend.
+
+73
+00:05:09,000 --> 00:05:15,000
+Project classes will be easy for you to understand, Bodger stands for plain old Jawa Object.
+
+74
+00:05:16,000 --> 00:05:18,000
+These are just simple Java classes.
+
+75
+00:05:19,000 --> 00:05:24,000
+For example, project classes shouldn't, first of all, extend to any other classes.
+
+76
+00:05:24,000 --> 00:05:32,000
+Secondly, implement interfaces and contain prespecified annotations like antiquing or Odos.
+
+77
+00:05:32,000 --> 00:05:38,000
+Usually people call simple classes with just getters and setters and default constructor your classes.
+
+78
+00:05:38,000 --> 00:05:42,000
+For example, this product class can be called project class.
+
+79
+00:05:42,000 --> 00:05:44,000
+So now you know the terminology.
+
+80
+00:05:44,000 --> 00:05:46,000
+As you can see, that was easy.
+
+81
+00:05:47,000 --> 00:05:53,000
+APSA classes, APSA classes exist to put their common code for the specific Iraqi.
+
+82
+00:05:53,000 --> 00:05:58,000
+For example, let's pretend that in our e-commerce solution we have product class.
+
+83
+00:05:58,000 --> 00:06:05,000
+It will be abstract, it will have such fields as an idea, name, minimum amount of order quantity
+
+84
+00:06:05,000 --> 00:06:10,000
+will also have here Flaxton in the five, whether the product is available for delivery.
+
+85
+00:06:10,000 --> 00:06:13,000
+We don't want to make product class concrete.
+
+86
+00:06:13,000 --> 00:06:18,000
+We want to keep it abstract y because in our program we don't need to instantiate product types.
+
+87
+00:06:19,000 --> 00:06:20,000
+What do we need?
+
+88
+00:06:20,000 --> 00:06:24,000
+Instead, we need to instantiate master product and waron product.
+
+89
+00:06:24,000 --> 00:06:28,000
+These are specific types of products which will be used in our online shop.
+
+90
+00:06:29,000 --> 00:06:35,000
+Kivi can be master product, Boutte's will be Verant product because we can have different sizes of
+
+91
+00:06:35,000 --> 00:06:39,000
+the same goods and different sizes of boots as in most master products.
+
+92
+00:06:40,000 --> 00:06:46,000
+Master and Vuuren products will extend abasic product type and just few properties will be added to
+
+93
+00:06:46,000 --> 00:06:47,000
+these types.
+
+94
+00:06:47,000 --> 00:06:53,000
+For example, array of master products will be added to via product because let's pretend we want to
+
+95
+00:06:53,000 --> 00:06:55,000
+sell goods, goods, a variant.
+
+96
+00:06:55,000 --> 00:06:57,000
+You can have boots of different sizes.
+
+97
+00:06:58,000 --> 00:07:03,000
+Master Product also has another property which is different from abstract product type will have boolean
+
+98
+00:07:03,000 --> 00:07:08,000
+property is available for lease to identify whether this product is available for lease.
+
+99
+00:07:09,000 --> 00:07:11,000
+Now let's try to create objects.
+
+100
+00:07:11,000 --> 00:07:17,000
+We can't create an object from an abstract class, but we can create objects of concrete glass that
+
+101
+00:07:17,000 --> 00:07:19,000
+extends our abstract class.
+
+102
+00:07:19,000 --> 00:07:21,000
+And I want to pay your attention here.
+
+103
+00:07:21,000 --> 00:07:24,000
+Take into account master product and and product.
+
+104
+00:07:24,000 --> 00:07:26,000
+Class extends product.
+
+105
+00:07:26,000 --> 00:07:30,000
+We have the same methods which we have in product class.
+
+106
+00:07:31,000 --> 00:07:38,000
+So you can understand that code which is placed here in product class is common for all child classes.
+
+107
+00:07:39,000 --> 00:07:40,000
+Does it make sense?
+
+108
+00:07:40,000 --> 00:07:43,000
+Can you see why do you need to have abstract classes?
+
+109
+00:07:43,000 --> 00:07:49,000
+For example, we'll talk more in details regarding inheritance and extends keyword in separate lesson.
+
+110
+00:07:49,000 --> 00:07:55,000
+But I decided to show you this example because it will be hard to explain the necessity of having abstract
+
+111
+00:07:55,000 --> 00:07:56,000
+classes in your program.
+
+112
+00:07:57,000 --> 00:08:01,000
+And that's a reason to have an abstract class is in case you know that your object should have some
+
+113
+00:08:01,000 --> 00:08:07,000
+specific behavior, but you don't know the exact implementation of this behavior for all child classes.
+
+114
+00:08:07,000 --> 00:08:12,000
+Let me show you this on the example, your products will be able to check whether it's available in
+
+115
+00:08:12,000 --> 00:08:18,000
+stock, but you have different implementations for this behavior in master environ product classes.
+
+116
+00:08:19,000 --> 00:08:22,000
+That's why I graded abstract methods in product class.
+
+117
+00:08:22,000 --> 00:08:25,000
+Abstract method is a method without body.
+
+118
+00:08:25,000 --> 00:08:30,000
+You see that I added abstract keyword and there is no body in this method.
+
+119
+00:08:30,000 --> 00:08:32,000
+It is just the method declaration.
+
+120
+00:08:33,000 --> 00:08:36,000
+And this method should be implemented in child classes.
+
+121
+00:08:36,000 --> 00:08:39,000
+For example, in multiproduct you will just check remaining amount.
+
+122
+00:08:40,000 --> 00:08:43,000
+If it's not zero, then you have this product in stock.
+
+123
+00:08:43,000 --> 00:08:48,000
+Yet the remaining amount and stock method is the method which will check the amount of this product
+
+124
+00:08:48,000 --> 00:08:49,000
+in stock, in database.
+
+125
+00:08:50,000 --> 00:08:56,000
+For the sake of example, I made a stop here to focus your attention on the other concept invariant
+
+126
+00:08:56,000 --> 00:08:56,000
+product.
+
+127
+00:08:56,000 --> 00:08:59,000
+You have to iterate over each variant and encase case.
+
+128
+00:08:59,000 --> 00:09:02,000
+At least one variant of the product is in stock.
+
+129
+00:09:02,000 --> 00:09:06,000
+Let's indicate to our user that this product is in stock and let's return.
+
+130
+00:09:06,000 --> 00:09:10,000
+True, and only if NIESR variance is in stock.
+
+131
+00:09:10,000 --> 00:09:11,000
+Let's return false.
+
+132
+00:09:12,000 --> 00:09:15,000
+I hope now you get clarity on what abstract classes are.
+
+133
+00:09:16,000 --> 00:09:19,000
+And last but not least for today, is anonymous class.
+
+134
+00:09:19,000 --> 00:09:24,000
+You already know that I can't create an instant of the abstract class product, but I can create an
+
+135
+00:09:24,000 --> 00:09:27,000
+instance of anonymous class that extends class product.
+
+136
+00:09:28,000 --> 00:09:34,000
+For example, here are wrote new product, curly bracket and now I can implement abstract method.
+
+137
+00:09:35,000 --> 00:09:41,000
+This definition is called abstract class because this is a definition of a new class that has no name.
+
+138
+00:09:42,000 --> 00:09:47,000
+Usually you declare anonymous class and instantiate object at the same moment of time.
+
+139
+00:09:47,000 --> 00:09:48,000
+That's it.
+
+140
+00:09:48,000 --> 00:09:51,000
+Now you know all types of classes that can exist in Java.
+
+141
+00:09:52,000 --> 00:09:54,000
+Now let's recap what we have learned today.
+
+142
+00:09:55,000 --> 00:09:59,000
+We learned what can create static nested in our final bodger.
+
+143
+00:09:59,000 --> 00:10:03,000
+Abstract and anonymous classes are after today's lesson.
+
+144
+00:10:03,000 --> 00:10:08,000
+You also know what abstract methods are and how you can use abstract modifier with classes and methods.
+
+145
+00:10:10,000 --> 00:10:11,000
+That's all what I have for you for today.
+
+146
+00:10:12,000 --> 00:10:15,000
+Thanks a lot for your attention and see you in the next lesson.
+

13 - Object-oriented programming/003 Source-code-Abstract-Product.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/classes/typesofclasses/Product.java

13 - Object-oriented programming/003 Source-code-Cart-with-Tax-and-Discount.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/classes/Cart.java

13 - Object-oriented programming/003 Source-code-Demo-class.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/classes/typesofclasses/Demo.java

13 - Object-oriented programming/003 Source-code-Master-Product.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/classes/typesofclasses/MasterProduct.java

13 - Object-oriented programming/003 Source-code-POJO-Product.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/classes/Product.java

13 - Object-oriented programming/003 Source-code-User-class.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/classes/typesofclasses/User.java

13 - Object-oriented programming/003 Source-code-Variant-product.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/classes/typesofclasses/VariantProduct.java

13 - Object-oriented programming/004 Interfaces_en.srt

@@ -0,0 +1,688 @@
+1
+00:00:05,000 --> 00:00:10,000
+Hello, dear students, in this lesson, we are going to talk with you about interfaces from this lesson,
+
+2
+00:00:10,000 --> 00:00:13,000
+you learn what interfaces are and what do they consist of.
+
+3
+00:00:13,000 --> 00:00:18,000
+Also, we'll discuss what is the difference between abstract class and interface.
+
+4
+00:00:18,000 --> 00:00:23,000
+And at the end of the lesson, I will tell you what is the difference between such terms as interface,
+
+5
+00:00:23,000 --> 00:00:24,000
+class and time.
+
+6
+00:00:25,000 --> 00:00:30,000
+Let's go as I just start and look at examples to understand what interfaces are.
+
+7
+00:00:30,000 --> 00:00:36,000
+First of all, let's come up with a definition of an interface interfaces, an abstraction which defines
+
+8
+00:00:36,000 --> 00:00:41,000
+a behavioral contract that must be followed by every class that implements this interface.
+
+9
+00:00:42,000 --> 00:00:48,000
+In other words, you specify a set of expected behavior which should be present in each class that implements
+
+10
+00:00:48,000 --> 00:00:49,000
+this interface.
+
+11
+00:00:49,000 --> 00:00:53,000
+But it don't specify how exactly this behavior will be implemented.
+
+12
+00:00:53,000 --> 00:00:56,000
+For example, have interface here for payment processor.
+
+13
+00:00:57,000 --> 00:01:03,000
+I need to have some type in my program that will be able to process payment and send information about
+
+14
+00:01:03,000 --> 00:01:04,000
+our payment to Payment Gateway.
+
+15
+00:01:05,000 --> 00:01:12,000
+That's why I want to declare what method with the name process payment, the text payment data object
+
+16
+00:01:12,000 --> 00:01:13,000
+as an argument.
+
+17
+00:01:13,000 --> 00:01:20,000
+Payment data is simple project loss that has the payment amount tax amount idea of a user who wants
+
+18
+00:01:20,000 --> 00:01:22,000
+to make a payment and currency.
+
+19
+00:01:23,000 --> 00:01:25,000
+The rest of the message here I just getters and setters.
+
+20
+00:01:26,000 --> 00:01:27,000
+Now let's get back to our interface.
+
+21
+00:01:28,000 --> 00:01:32,000
+You see that I declared method without body and without any other modifiers.
+
+22
+00:01:33,000 --> 00:01:33,000
+Why?
+
+23
+00:01:34,000 --> 00:01:39,000
+Because invisibly, all matters in interface have modifiers, public and abstract.
+
+24
+00:01:39,000 --> 00:01:44,000
+So in case I will add here public and abstract modifier, nothing will change.
+
+25
+00:01:45,000 --> 00:01:50,000
+But there is no sense in any public abstract modifiers because all methods and interfaces by default
+
+26
+00:01:50,000 --> 00:01:52,000
+are public and abstract.
+
+27
+00:01:52,000 --> 00:01:58,000
+I can say that this interface said the contract on the process payment behavior by same contract.
+
+28
+00:01:58,000 --> 00:02:04,000
+I mean, this interface clearly defines what a return type will be, how method will be called and what
+
+29
+00:02:04,000 --> 00:02:06,000
+parameters will be in it, period.
+
+30
+00:02:07,000 --> 00:02:11,000
+But this interface doesn't bother about what exact code will be written.
+
+31
+00:02:12,000 --> 00:02:17,000
+And now when I have such interface in my program, I can create time that will implement this contract.
+
+32
+00:02:17,000 --> 00:02:23,000
+I have changed payment processor and PayPal payment processor both implements payment processor interface.
+
+33
+00:02:24,000 --> 00:02:28,000
+That means these classes are obligated to implement process payment methods.
+
+34
+00:02:29,000 --> 00:02:35,000
+Since this method is abstract in the interface in our concrete class, we must implement this method.
+
+35
+00:02:35,000 --> 00:02:37,000
+If only our class will be abstract.
+
+36
+00:02:38,000 --> 00:02:40,000
+There is no need to implement this method.
+
+37
+00:02:40,000 --> 00:02:44,000
+Let me call on this method and at absolute keyword before class.
+
+38
+00:02:44,000 --> 00:02:47,000
+You see, there is no compilation error.
+
+39
+00:02:47,000 --> 00:02:52,000
+But since this class is not abstract, there will be compilation error.
+
+40
+00:02:52,000 --> 00:02:58,000
+In case we won't implement this method, you can press control plus one and select and implemented methods
+
+41
+00:02:58,000 --> 00:02:59,000
+to generate stop method.
+
+42
+00:03:00,000 --> 00:03:02,000
+I will just on existing one.
+
+43
+00:03:02,000 --> 00:03:04,000
+This method will work differently.
+
+44
+00:03:04,000 --> 00:03:07,000
+For example, chase payment processor.
+
+45
+00:03:07,000 --> 00:03:13,000
+Because of the specifics of Payment Gateway, it should obtain security token first for authorization
+
+46
+00:03:14,000 --> 00:03:19,000
+and only after that we can initialize payment page with secure token and the amount of money to pay.
+
+47
+00:03:20,000 --> 00:03:26,000
+On the other hand, let's pretend that PayPal payment processor needs to request payment for by using
+
+48
+00:03:26,000 --> 00:03:27,000
+a specific application key.
+
+49
+00:03:27,000 --> 00:03:32,000
+And after that we have to fill out this form of payment details and submit it.
+
+50
+00:03:32,000 --> 00:03:36,000
+You can notice that in both cases we have override annotation here.
+
+51
+00:03:36,000 --> 00:03:40,000
+This notation exists for the sake of a successful compilation.
+
+52
+00:03:40,000 --> 00:03:41,000
+Do not switch the topic.
+
+53
+00:03:41,000 --> 00:03:43,000
+Let's keep focus on our interfaces.
+
+54
+00:03:43,000 --> 00:03:48,000
+I will tell you more about overwrite annotation in our detailed lesson about polymorphism.
+
+55
+00:03:48,000 --> 00:03:50,000
+Do we see these two examples?
+
+56
+00:03:51,000 --> 00:03:55,000
+The behavior is the same both classes, protests, payment data.
+
+57
+00:03:55,000 --> 00:03:57,000
+But they do this in different ways.
+
+58
+00:03:57,000 --> 00:04:00,000
+What do all this look like exactly?
+
+59
+00:04:00,000 --> 00:04:06,000
+This look like implementation of polymorphism principle, one of the main or P principle?
+
+60
+00:04:06,000 --> 00:04:07,000
+Why else?
+
+61
+00:04:07,000 --> 00:04:12,000
+We need interfaces to build our application was dependency on the obstruction types, but not on the
+
+62
+00:04:12,000 --> 00:04:13,000
+concrete classes.
+
+63
+00:04:14,000 --> 00:04:15,000
+Let me show you this example.
+
+64
+00:04:16,000 --> 00:04:18,000
+You mentioned we have some client of our code.
+
+65
+00:04:18,000 --> 00:04:22,000
+It could be some other class so-called facade class or controller class.
+
+66
+00:04:22,000 --> 00:04:23,000
+That doesn't matter.
+
+67
+00:04:24,000 --> 00:04:28,000
+And this class can simply rely on the interface of payment processor type.
+
+68
+00:04:29,000 --> 00:04:33,000
+We can say that by default, variable of payment processor reference to PayPal payment processor.
+
+69
+00:04:34,000 --> 00:04:38,000
+But in fact, this client doesn't bother with implementation of payment processor.
+
+70
+00:04:38,000 --> 00:04:42,000
+We will use PayPal payment processor or chase payment processor.
+
+71
+00:04:42,000 --> 00:04:48,000
+Moreover, somebody can use Setar and that is a chase or PayPal payment process during the runtime.
+
+72
+00:04:49,000 --> 00:04:55,000
+The good thing about interfaces and they define level of abstraction and we can build our program relying
+
+73
+00:04:55,000 --> 00:04:56,000
+on this abstraction.
+
+74
+00:04:56,000 --> 00:05:01,000
+They see this method and location and checkout method no matter what implementation of payment.
+
+75
+00:05:01,000 --> 00:05:08,000
+Sir, I will have here during Zeron time, I don't need to change this code and also pay attention to
+
+76
+00:05:08,000 --> 00:05:09,000
+one more thing here.
+
+77
+00:05:09,000 --> 00:05:16,000
+I can initialize variable of interface type with a reference to an object of any other class which implements
+
+78
+00:05:16,000 --> 00:05:17,000
+this interface.
+
+79
+00:05:18,000 --> 00:05:20,000
+OK, Holmes, this is clear.
+
+80
+00:05:20,000 --> 00:05:23,000
+Now, let's take a look what our interface can contain.
+
+81
+00:05:23,000 --> 00:05:27,000
+As you already understand, our interface can contain abstract methods.
+
+82
+00:05:27,000 --> 00:05:29,000
+It can have as many methods as you wish.
+
+83
+00:05:30,000 --> 00:05:34,000
+But later we will learn other object oriented principles and you will understand that it is better to
+
+84
+00:05:34,000 --> 00:05:37,000
+have a lot of small interfaces rather than one.
+
+85
+00:05:37,000 --> 00:05:42,000
+And besides abstract methods, our interface can contain default methods.
+
+86
+00:05:42,000 --> 00:05:48,000
+Default methods are methods that have body so you can treat them like regular methods in concrete glass.
+
+87
+00:05:49,000 --> 00:05:54,000
+But the Java syntax wouldn't allow you to declare a method with body and interface without default.
+
+88
+00:05:54,000 --> 00:06:02,000
+Keyword in case iRace the default keyword compiler tells me that abstract methods don't have money because
+
+89
+00:06:02,000 --> 00:06:04,000
+compiler treats this method as abstract.
+
+90
+00:06:05,000 --> 00:06:07,000
+Also, our interface may contain static methods.
+
+91
+00:06:07,000 --> 00:06:12,000
+We are going to have a separate lesson about static keywords, but right now you can remember the static
+
+92
+00:06:12,000 --> 00:06:15,000
+methods can be called without any object.
+
+93
+00:06:15,000 --> 00:06:19,000
+So you don't need to write newcomer's and create objects.
+
+94
+00:06:19,000 --> 00:06:23,000
+You can just write type name and column method like I did here.
+
+95
+00:06:23,000 --> 00:06:28,000
+For example, I wrote the name of the interface and invoke static method on this interface.
+
+96
+00:06:29,000 --> 00:06:32,000
+Notice I didn't use variable of payment processor type.
+
+97
+00:06:32,000 --> 00:06:33,000
+I use interface.
+
+98
+00:06:34,000 --> 00:06:36,000
+It is not very object oriented approach.
+
+99
+00:06:36,000 --> 00:06:40,000
+Why wait for the in the most cited keywords and I will tell you more about it.
+
+100
+00:06:41,000 --> 00:06:45,000
+So far, you know that interface can contain abstract default and static methods.
+
+101
+00:06:45,000 --> 00:06:48,000
+What else interface can have constants.
+
+102
+00:06:49,000 --> 00:06:53,000
+For example, imagine the real life scenario in case our payment failed.
+
+103
+00:06:53,000 --> 00:06:55,000
+We need to retrieve a few more times.
+
+104
+00:06:55,000 --> 00:07:02,000
+I create variable of type retry attempts and you probably noticed that the clips for months, this variable
+
+105
+00:07:02,000 --> 00:07:06,000
+name like a constant I'm in cursive and another color.
+
+106
+00:07:06,000 --> 00:07:10,000
+That is because by default, all fields and interfaces have public static.
+
+107
+00:07:10,000 --> 00:07:17,000
+Final modifiers like all constants have public so that everyone could access it static because constant
+
+108
+00:07:17,000 --> 00:07:22,000
+should exist in a single copy and final so that nobody could override it.
+
+109
+00:07:22,000 --> 00:07:25,000
+We will talk more about constants in the lesson about static keywords.
+
+110
+00:07:26,000 --> 00:07:30,000
+And even if I would add these modifiers here, nothing will change.
+
+111
+00:07:30,000 --> 00:07:33,000
+But usually developers give this modifiers in interfaces.
+
+112
+00:07:34,000 --> 00:07:37,000
+Let me also removed important things that we didn't discuss yet.
+
+113
+00:07:37,000 --> 00:07:43,000
+If the fact that class can implement multiple interfaces at once, I'm not sure whether you notice that
+
+114
+00:07:43,000 --> 00:07:49,000
+our chase payment processor implements two interfaces, the one we discussed already, and another one
+
+115
+00:07:49,000 --> 00:07:51,000
+is payment for the data.
+
+116
+00:07:51,000 --> 00:07:56,000
+If this class implements payment for the data interface, that means this class should implement validate
+
+117
+00:07:56,000 --> 00:08:02,000
+payment methods which will validate payment to be sure that it has all necessary information for payment
+
+118
+00:08:02,000 --> 00:08:03,000
+processing.
+
+119
+00:08:03,000 --> 00:08:07,000
+In this payment gateway in Java, it is allowed to implement multiple interfaces.
+
+120
+00:08:08,000 --> 00:08:11,000
+But in one specific case, this can lead to compilation error.
+
+121
+00:08:11,000 --> 00:08:13,000
+And I want you to know this case.
+
+122
+00:08:14,000 --> 00:08:15,000
+Let's discuss it.
+
+123
+00:08:15,000 --> 00:08:21,000
+For example, in payment processor interface, you have some default method and in payment for the data,
+
+124
+00:08:21,000 --> 00:08:24,000
+you also have default method with the same signature.
+
+125
+00:08:24,000 --> 00:08:30,000
+Here it this this can lead to compilation error in chase payment processor class, because during the
+
+126
+00:08:30,000 --> 00:08:33,000
+runtime it will be unclear which default method should be used.
+
+127
+00:08:34,000 --> 00:08:37,000
+The one from payment for the data was the one from payment processor.
+
+128
+00:08:38,000 --> 00:08:44,000
+That's why it doesn't allow us to compile this code until we resolve issue was duplicated default methods.
+
+129
+00:08:44,000 --> 00:08:47,000
+So now you know really a lot about interfaces.
+
+130
+00:08:48,000 --> 00:08:53,000
+It is time to understand how good you learned interfaces and ask you what is the difference between
+
+131
+00:08:53,000 --> 00:08:55,000
+abstract classes and interfaces.
+
+132
+00:08:55,000 --> 00:08:59,000
+Absolute class we can extend with extensive keyboard interface.
+
+133
+00:08:59,000 --> 00:09:02,000
+We can implement using implements, keyboard apps.
+
+134
+00:09:03,000 --> 00:09:06,000
+A class can have properties with all possible modifiers.
+
+135
+00:09:06,000 --> 00:09:11,000
+On the other hand, all properties interfaces have public static final modifiers.
+
+136
+00:09:12,000 --> 00:09:17,000
+You can extend only one class in Java, but you can implement multiple interfaces.
+
+137
+00:09:17,000 --> 00:09:23,000
+You remember that example when our PayPal payment processor implemented two interfaces at a time?
+
+138
+00:09:23,000 --> 00:09:27,000
+Basically that the most significant difference between abstract classes and interfaces.
+
+139
+00:09:28,000 --> 00:09:33,000
+It is also worth to mention that the introduction of default and static methods and interfaces made
+
+140
+00:09:33,000 --> 00:09:36,000
+it harder to distinguish interfaces from abstract classes.
+
+141
+00:09:37,000 --> 00:09:42,000
+Based on the difference which we discussed, you can select whether you need to use abstract class or
+
+142
+00:09:42,000 --> 00:09:43,000
+interface.
+
+143
+00:09:43,000 --> 00:09:48,000
+For example, if you know that you need to list properties with private or protected access modifiers
+
+144
+00:09:48,000 --> 00:09:53,000
+that are not static, you already know that you need to use abstract class instead of interface.
+
+145
+00:09:53,000 --> 00:09:59,000
+And if you need to be able to implement specific interface together with other ones, you know that
+
+146
+00:09:59,000 --> 00:10:00,000
+you need to use interfaces.
+
+147
+00:10:01,000 --> 00:10:06,000
+Last but not the least question for today and our agenda is to define the difference between such terms
+
+148
+00:10:06,000 --> 00:10:11,000
+as class type and interface, you already know what a class is.
+
+149
+00:10:11,000 --> 00:10:13,000
+Ensure that class is a template for your future.
+
+150
+00:10:13,000 --> 00:10:19,000
+Object's interface is an abstraction which defines application programming interface and contract for
+
+151
+00:10:19,000 --> 00:10:20,000
+behavior.
+
+152
+00:10:20,000 --> 00:10:27,000
+But what is a type probably you heard during the lessons that I use type word as a synonym when I reference
+
+153
+00:10:27,000 --> 00:10:33,000
+to class interface because class is a type interface is also a type.
+
+154
+00:10:33,000 --> 00:10:39,000
+That means every type is also is a class and interface and enumeration or an array.
+
+155
+00:10:39,000 --> 00:10:43,000
+Also, each object has a time and every expression has a type.
+
+156
+00:10:43,000 --> 00:10:50,000
+If during that interview you will be asked what a typist you can answer something like this type summarizes
+
+157
+00:10:50,000 --> 00:10:53,000
+the common features of a set of objects with the same characteristics.
+
+158
+00:10:54,000 --> 00:11:00,000
+Class is a concrete data structure and group of methods that represents an implementation of the type.
+
+159
+00:11:01,000 --> 00:11:04,000
+Let's look at this example one more time attentively.
+
+160
+00:11:04,000 --> 00:11:10,000
+Payment processor variable has payment processor type, but this variable reference to the PayPal payment
+
+161
+00:11:10,000 --> 00:11:12,000
+processor object.
+
+162
+00:11:12,000 --> 00:11:15,000
+So we can say that the object has a payment processor type.
+
+163
+00:11:15,000 --> 00:11:22,000
+And you see here in the method parameters, this sector can accept any object of type payment processor.
+
+164
+00:11:22,000 --> 00:11:29,000
+That means this method can work with any object that implements this interface doesn't make sense.
+
+165
+00:11:29,000 --> 00:11:32,000
+Hope with this examples, things become clearer.
+
+166
+00:11:33,000 --> 00:11:35,000
+Let's recap what we have learned today.
+
+167
+00:11:35,000 --> 00:11:42,000
+In this lesson, we learned what interfaces are, what interfaces can contain inside, how to implement
+
+168
+00:11:42,000 --> 00:11:48,000
+interface, what default methods and interfaces are, what static methods interfaces are.
+
+169
+00:11:48,000 --> 00:11:52,000
+Now, you know what the difference between abstract class and interface is.
+
+170
+00:11:53,000 --> 00:11:56,000
+And you also learn the difference between type and object.
+
+171
+00:11:57,000 --> 00:11:58,000
+That's all what we have for today.
+
+172
+00:11:59,000 --> 00:12:02,000
+Thanks a lot for your attention and see you in the next lesson.
+

13 - Object-oriented programming/004 Source-code-ChasePaymentProcessor.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/interfaces/ChasePaymentProcessor.java

13 - Object-oriented programming/004 Source-code-Client-class.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/interfaces/Client.java

13 - Object-oriented programming/004 Source-code-PayPalPaymentProcessor.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/interfaces/PayPalPaymentProcessor.java

13 - Object-oriented programming/004 Source-code-PaymentData.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/interfaces/PaymentData.java

13 - Object-oriented programming/004 Source-code-PaymentProcessor-interface.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/interfaces/PaymentProcessor.java

13 - Object-oriented programming/004 Source-code-PaymentValidator.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/interfaces/PaymentValidator.java

13 - Object-oriented programming/005 Inheritance_en.srt

@@ -0,0 +1,636 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, Jim.
+
+2
+00:00:06,000 --> 00:00:11,000
+In this lesson, we are going to learn more about one of the key principles of the object oriented programming
+
+3
+00:00:11,000 --> 00:00:12,000
+approach.
+
+4
+00:00:12,000 --> 00:00:13,000
+I'm talking about inheritance.
+
+5
+00:00:14,000 --> 00:00:16,000
+And they will talk not only about inheritance.
+
+6
+00:00:16,000 --> 00:00:23,000
+Well, on super keyword and you operator instance of I will show you how we can extend classes and what
+
+7
+00:00:23,000 --> 00:00:25,000
+rules should be followed during inheritance.
+
+8
+00:00:25,000 --> 00:00:27,000
+So let's start.
+
+9
+00:00:27,000 --> 00:00:32,000
+I believe you remember theoretical part which we discussed in lesson about inheritance.
+
+10
+00:00:32,000 --> 00:00:37,000
+So now it is time for practical code examples demo to understand this topic better.
+
+11
+00:00:38,000 --> 00:00:42,000
+I always try to create real life example for you so that you could understand how this works for real
+
+12
+00:00:43,000 --> 00:00:44,000
+in this lesson.
+
+13
+00:00:44,000 --> 00:00:46,000
+Imagine that you have product type in your program.
+
+14
+00:00:46,000 --> 00:00:50,000
+I didn't create too many fields to not distract attention from inheritance topic.
+
+15
+00:00:51,000 --> 00:00:54,000
+Just imagine that product can have multiple fields and methods.
+
+16
+00:00:55,000 --> 00:00:56,000
+And we also have the phone type.
+
+17
+00:00:57,000 --> 00:00:59,000
+Phone is also a product in our online shop.
+
+18
+00:01:00,000 --> 00:01:03,000
+It will have similar fields and behavior as product has.
+
+19
+00:01:03,000 --> 00:01:09,000
+But besides that, it has also some phone specific behavior like ring method, for example.
+
+20
+00:01:10,000 --> 00:01:15,000
+Now let's create phone object I a product variable and initialize it with foreign object.
+
+21
+00:01:15,000 --> 00:01:22,000
+Take into account for an object is also a type product and you can see that our product variable has
+
+22
+00:01:22,000 --> 00:01:24,000
+own methods that are declared in product type.
+
+23
+00:01:25,000 --> 00:01:31,000
+I have said gather and calculate remaining amount method which is not declared in phone but declared
+
+24
+00:01:31,000 --> 00:01:32,000
+in product.
+
+25
+00:01:32,000 --> 00:01:39,000
+So the idea of inheritance is to describe new types based on existing one from technical side.
+
+26
+00:01:39,000 --> 00:01:46,000
+This allows us to reuse already written code, which is also pretty cool because let's imagine you need
+
+27
+00:01:46,000 --> 00:01:49,000
+to change the logic how remaining amount in stock is calculated.
+
+28
+00:01:50,000 --> 00:01:56,000
+Instead of changing this method in all classes where this method is used, I can just do change in one
+
+29
+00:01:56,000 --> 00:02:01,000
+place in product class and behaviour will become different in old child classes.
+
+30
+00:02:01,000 --> 00:02:07,000
+And you also see that foreign object doesn't have name field, but somehow I can set the value for name
+
+31
+00:02:07,000 --> 00:02:09,000
+property of the form.
+
+32
+00:02:09,000 --> 00:02:12,000
+That is because inheritance of this field from product object.
+
+33
+00:02:13,000 --> 00:02:15,000
+OK, but let's try to ring right now.
+
+34
+00:02:16,000 --> 00:02:21,000
+Unfortunately, we have compilation error because Renk method is not defined for the type product,
+
+35
+00:02:21,000 --> 00:02:26,000
+but we see here that we created for an object and we still don't have that Renk method available.
+
+36
+00:02:27,000 --> 00:02:27,000
+Why?
+
+37
+00:02:28,000 --> 00:02:30,000
+Because Java is not mahzarin.
+
+38
+00:02:30,000 --> 00:02:33,000
+What object will be here in this line during the runtime?
+
+39
+00:02:34,000 --> 00:02:40,000
+You can initialize the variable with any object of this type and Java doesn't want to guess what object
+
+40
+00:02:40,000 --> 00:02:41,000
+is there for real.
+
+41
+00:02:41,000 --> 00:02:47,000
+What Java knows that in case code is compiler, that means object which was assigned to this variable
+
+42
+00:02:47,000 --> 00:02:50,000
+has the same interface as this type for sure.
+
+43
+00:02:50,000 --> 00:02:56,000
+That's why we don't see any matters from form type here, because we have variable of type product.
+
+44
+00:02:57,000 --> 00:03:03,000
+When I create variable or form that I can invoke Renk method without compilation error.
+
+45
+00:03:03,000 --> 00:03:08,000
+But what if my class or method works with product type and I want to call Remarque method?
+
+46
+00:03:09,000 --> 00:03:12,000
+I will be able to do that only in case during the runtime.
+
+47
+00:03:12,000 --> 00:03:14,000
+I have phone object here.
+
+48
+00:03:15,000 --> 00:03:21,000
+But how I can understand this now I will show you a new keyword and operator which you will be able
+
+49
+00:03:21,000 --> 00:03:23,000
+to use in your programs.
+
+50
+00:03:23,000 --> 00:03:25,000
+Here is an instance of operator.
+
+51
+00:03:26,000 --> 00:03:29,000
+It allows you to check the type consistency with the object.
+
+52
+00:03:30,000 --> 00:03:33,000
+It is a binary operator which works with two operands.
+
+53
+00:03:34,000 --> 00:03:38,000
+Let me show you how you can use it if object behind the product variable.
+
+54
+00:03:38,000 --> 00:03:41,000
+This one is instance of phone type.
+
+55
+00:03:41,000 --> 00:03:44,000
+The result will be true in terms of returns.
+
+56
+00:03:44,000 --> 00:03:51,000
+Is a true or false and if instance of returns true, I can cast this variable to type the remember how
+
+57
+00:03:51,000 --> 00:03:53,000
+Wikus primitive types.
+
+58
+00:03:53,000 --> 00:03:56,000
+We can just reference types in a similar way.
+
+59
+00:03:56,000 --> 00:03:57,000
+Right.
+
+60
+00:03:57,000 --> 00:03:59,000
+Phone and variable name.
+
+61
+00:03:59,000 --> 00:04:04,000
+Now put the type name in parentheses and name of the variable you want to cast.
+
+62
+00:04:05,000 --> 00:04:11,000
+Now you can invoke Renk method instance of the return false in case variable reference to object is
+
+63
+00:04:11,000 --> 00:04:15,000
+incompatible with the type you specified as a second operand.
+
+64
+00:04:16,000 --> 00:04:20,000
+OK, you know what is instance of and when you can use it.
+
+65
+00:04:20,000 --> 00:04:24,000
+Let's proceed with inheritance topic in your child class.
+
+66
+00:04:24,000 --> 00:04:26,000
+You always have a reference to a parent class.
+
+67
+00:04:27,000 --> 00:04:32,000
+You might want to have the reference to the parent class, for example, to call some parent methods.
+
+68
+00:04:32,000 --> 00:04:33,000
+Let's take a look here.
+
+69
+00:04:34,000 --> 00:04:40,000
+Product Class has a message that returns the least of all variant products associated with the current
+
+70
+00:04:40,000 --> 00:04:40,000
+product.
+
+71
+00:04:40,000 --> 00:04:46,000
+And our phone object overrides this behavior and throws and supports the separation exception.
+
+72
+00:04:46,000 --> 00:04:51,000
+This exception indicates that this behavior is not supported in this class.
+
+73
+00:04:52,000 --> 00:04:57,000
+Later in this course, we will learn that this implementation violates one of the design principles
+
+74
+00:04:57,000 --> 00:04:59,000
+in the object oriented programming.
+
+75
+00:04:59,000 --> 00:05:02,000
+But you would face with similar cases many in.
+
+76
+00:05:02,000 --> 00:05:09,000
+Times, believe me, and now what will happen if in another method calculate the amount of variance
+
+77
+00:05:09,000 --> 00:05:17,000
+I will call least variance method of this object will be called and program will stop execution because
+
+78
+00:05:17,000 --> 00:05:18,000
+of the exception?
+
+79
+00:05:18,000 --> 00:05:20,000
+Let me run this program to show you this.
+
+80
+00:05:21,000 --> 00:05:22,000
+What do you have to do right now?
+
+81
+00:05:22,000 --> 00:05:27,000
+You already know that in each class you have reference to a parent class who is super keyword.
+
+82
+00:05:28,000 --> 00:05:34,000
+So let's call math at least reference not from this class, but let's call method list variants of the
+
+83
+00:05:34,000 --> 00:05:34,000
+parent class.
+
+84
+00:05:35,000 --> 00:05:38,000
+This one just right super.
+
+85
+00:05:38,000 --> 00:05:43,000
+This is a reference to the parent type Dorte and invoke the same method.
+
+86
+00:05:43,000 --> 00:05:47,000
+What we have now left me around this program one more time.
+
+87
+00:05:47,000 --> 00:05:54,000
+We won't have any error because this method was called you can always use super keyword to reference
+
+88
+00:05:54,000 --> 00:05:56,000
+methods or properties of a parent class.
+
+89
+00:05:57,000 --> 00:05:59,000
+Now imagine the next scenario.
+
+90
+00:05:59,000 --> 00:06:04,000
+Imagine you don't have the full constructor in your parent object because you can create products only
+
+91
+00:06:04,000 --> 00:06:05,000
+with names.
+
+92
+00:06:06,000 --> 00:06:10,000
+How this will impact your phone that you're going to have compilation error.
+
+93
+00:06:10,000 --> 00:06:11,000
+Why?
+
+94
+00:06:11,000 --> 00:06:20,000
+Because the grade child object GBM invokes constructor of all parent classes and now you can call constructor
+
+95
+00:06:20,000 --> 00:06:23,000
+of parent classes because it doesn't know what should be passed.
+
+96
+00:06:23,000 --> 00:06:28,000
+As a constructor argument, the full constructor often looks like this.
+
+97
+00:06:29,000 --> 00:06:35,000
+So what we need to do to remove this compilation error, we need to explicitly call constructor of parent
+
+98
+00:06:35,000 --> 00:06:42,000
+class and pass a string parameter to it that's type super parentheses and pass some string argument
+
+99
+00:06:42,000 --> 00:06:43,000
+to it.
+
+100
+00:06:43,000 --> 00:06:48,000
+Here we call parent constructor and you see that now compilation error is gone.
+
+101
+00:06:49,000 --> 00:06:56,000
+Now Joram will be able to create an object of the form type one more important common here call of the
+
+102
+00:06:56,000 --> 00:06:59,000
+parent constructor always should go first in child constructor.
+
+103
+00:07:00,000 --> 00:07:03,000
+I mean you can't call any other methods before super.
+
+104
+00:07:03,000 --> 00:07:05,000
+Here, let me show you.
+
+105
+00:07:06,000 --> 00:07:10,000
+If I write here some code, it doesn't matter what exactly are right here.
+
+106
+00:07:11,000 --> 00:07:11,000
+Let me cancel.
+
+107
+00:07:11,000 --> 00:07:14,000
+Output will have again compilation error.
+
+108
+00:07:14,000 --> 00:07:20,000
+You need to remember that invocation of Ben constructor and using of super keyword should always go
+
+109
+00:07:20,000 --> 00:07:22,000
+first in shall constructor.
+
+110
+00:07:22,000 --> 00:07:23,000
+I will make a post now.
+
+111
+00:07:24,000 --> 00:07:27,000
+Is it clear if this is clear, let's move on.
+
+112
+00:07:28,000 --> 00:07:30,000
+I told you that OP is fun.
+
+113
+00:07:31,000 --> 00:07:37,000
+Now you know that to create a child's object constructor of a parent type is called what else happens
+
+114
+00:07:37,000 --> 00:07:39,000
+during child object initialization.
+
+115
+00:07:39,000 --> 00:07:44,000
+Here is a quick exercise for you that will help you to remember for the rest of your lives what happens
+
+116
+00:07:44,000 --> 00:07:46,000
+during child object construction.
+
+117
+00:07:47,000 --> 00:07:49,000
+Here is the code of our exercise.
+
+118
+00:07:49,000 --> 00:07:50,000
+So let's start.
+
+119
+00:07:51,000 --> 00:07:53,000
+We have parent type here.
+
+120
+00:07:53,000 --> 00:07:57,000
+You can see static initialization lock installation, lock constructor.
+
+121
+00:07:58,000 --> 00:08:03,000
+We have console output everywhere here and it's clearly specified that this output belongs to the parent
+
+122
+00:08:03,000 --> 00:08:07,000
+type and we have child types that extends parent class.
+
+123
+00:08:08,000 --> 00:08:14,000
+The child class has the same things that parent has static, initialization block, initialization lock
+
+124
+00:08:14,000 --> 00:08:15,000
+and constructor.
+
+125
+00:08:16,000 --> 00:08:19,000
+And you see the text and console output is different.
+
+126
+00:08:19,000 --> 00:08:24,000
+The question is what will be printed to console when I will create child object?
+
+127
+00:08:25,000 --> 00:08:30,000
+And another question, what will be printed to console when I will create child object the second time?
+
+128
+00:08:31,000 --> 00:08:34,000
+Press pause and try to answer this question.
+
+129
+00:08:35,000 --> 00:08:36,000
+OK, let me answer this.
+
+130
+00:08:37,000 --> 00:08:42,000
+I will run the program and we will investigate console output and let's see what we have here.
+
+131
+00:08:43,000 --> 00:08:49,000
+Static initialization block of the parent is executed and after that static installation lock of the
+
+132
+00:08:49,000 --> 00:08:51,000
+child type is executed.
+
+133
+00:08:51,000 --> 00:08:59,000
+Why static blocks are executed when classes uploaded into GBM parent class was uploaded first and after
+
+134
+00:08:59,000 --> 00:09:05,000
+that child class was uploaded after the JVM wants to initialize parent fields first.
+
+135
+00:09:05,000 --> 00:09:08,000
+That's why it executes parent installation block.
+
+136
+00:09:08,000 --> 00:09:15,000
+And after that parent constructor and only after that JVM starts to create child object and executes
+
+137
+00:09:15,000 --> 00:09:19,000
+child and installation work and child constructor home.
+
+138
+00:09:19,000 --> 00:09:20,000
+This example is clear.
+
+139
+00:09:20,000 --> 00:09:24,000
+What happens when I try to create child objects a second time?
+
+140
+00:09:24,000 --> 00:09:28,000
+Everything the same beside the execution of static initialization locks.
+
+141
+00:09:29,000 --> 00:09:29,000
+Why?
+
+142
+00:09:30,000 --> 00:09:35,000
+Because everything what is followed by static keyword, including initialization blocks, is associated
+
+143
+00:09:35,000 --> 00:09:39,000
+not with the object of this class, but with the class itself.
+
+144
+00:09:39,000 --> 00:09:44,000
+So when classes are uploaded into GBM, these blocks are executed.
+
+145
+00:09:44,000 --> 00:09:48,000
+They won't be executed two times in a row home.
+
+146
+00:09:48,000 --> 00:09:54,000
+Now with this example, it has become clearer what is initialization order during the construction of
+
+147
+00:09:54,000 --> 00:09:55,000
+a giant object.
+
+148
+00:09:55,000 --> 00:10:01,000
+The last thing you need to know about inheritance is that in Java, multiple inheritance is not supported
+
+149
+00:10:01,000 --> 00:10:02,000
+that.
+
+150
+00:10:02,000 --> 00:10:08,000
+Means you can't define new type on the basis of two or more opposite types after extensive keyword.
+
+151
+00:10:08,000 --> 00:10:14,000
+You can specify only one class, but in some other languages, multiple inheritance is supported.
+
+152
+00:10:15,000 --> 00:10:17,000
+That's all what we have in our agenda for today.
+
+153
+00:10:18,000 --> 00:10:20,000
+Let's recap what we have learned today.
+
+154
+00:10:20,000 --> 00:10:24,000
+We learned what inheritance is and how we can extend the time.
+
+155
+00:10:24,000 --> 00:10:31,000
+Now, you know, two more key words, super and instance of you learn some specific constraints while
+
+156
+00:10:31,000 --> 00:10:32,000
+extending classes.
+
+157
+00:10:33,000 --> 00:10:39,000
+And today you learned what initialization order is of new objects that is extended from another class.
+
+158
+00:10:39,000 --> 00:10:40,000
+That's all.
+
+159
+00:10:41,000 --> 00:10:44,000
+Thank you for your attention and see you in the next lesson.
+

13 - Object-oriented programming/005 Source-code-Demo.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/inheritance/Demo.java

13 - Object-oriented programming/005 Source-code-Object-initialization-order.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/inheritance/ObjectInitializationOrder.java

13 - Object-oriented programming/005 Source-code-Phone.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/inheritance/Phone.java

13 - Object-oriented programming/005 Source-code-Product.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/inheritance/Product.java

13 - Object-oriented programming/006 Polymorphism and 'final' keyword_en.srt

@@ -0,0 +1,556 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, Jim.
+
+2
+00:00:06,000 --> 00:00:11,000
+In this lesson, we'll discuss principle of the object oriented programming approach polymorphism,
+
+3
+00:00:11,000 --> 00:00:14,000
+they will talk about what polymorphism is.
+
+4
+00:00:14,000 --> 00:00:16,000
+I will tell you what method of writing this.
+
+5
+00:00:17,000 --> 00:00:21,000
+You will learn what is the difference between method of writing and method of reloading hope.
+
+6
+00:00:21,000 --> 00:00:25,000
+After this lesson, you will understand what dynamic Bindon is.
+
+7
+00:00:25,000 --> 00:00:31,000
+Also on different examples, I will show you how final key words works and what does it mean.
+
+8
+00:00:31,000 --> 00:00:32,000
+So let's start.
+
+9
+00:00:33,000 --> 00:00:35,000
+We have a lot of things to learn today.
+
+10
+00:00:35,000 --> 00:00:38,000
+Polymorphism literally means many forms.
+
+11
+00:00:38,000 --> 00:00:39,000
+Many forms of what?
+
+12
+00:00:40,000 --> 00:00:41,000
+Many forms of behavior.
+
+13
+00:00:42,000 --> 00:00:47,000
+Often we can see how polymorphism works when we extend any class or implement any interface.
+
+14
+00:00:47,000 --> 00:00:48,000
+Let me show you one example.
+
+15
+00:00:49,000 --> 00:00:54,000
+Imagine that we have abstract class user and we have content manager and admin user classes.
+
+16
+00:00:54,000 --> 00:00:59,000
+Both extensive user user has methods named validate access rights.
+
+17
+00:01:00,000 --> 00:01:04,000
+This method should check permissions of the user to perform some actions in our system.
+
+18
+00:01:04,000 --> 00:01:10,000
+You can see that in user class we have default console output where it is set that there are no specific
+
+19
+00:01:10,000 --> 00:01:12,000
+permissions in content.
+
+20
+00:01:12,000 --> 00:01:15,000
+Manager with the console output was indication of the permissions.
+
+21
+00:01:15,000 --> 00:01:21,000
+Content manager can't withdraw money and for admin user we see a completely different message.
+
+22
+00:01:22,000 --> 00:01:26,000
+Now let me declare two variables of type user and create two objects.
+
+23
+00:01:26,000 --> 00:01:30,000
+Object of content manager type an object of admin user type.
+
+24
+00:01:30,000 --> 00:01:35,000
+After that I want to invoke validate access rights methods on these objects.
+
+25
+00:01:35,000 --> 00:01:42,000
+What will be printed to cancel text from user class, from content manager class or from admin user
+
+26
+00:01:42,000 --> 00:01:42,000
+class.
+
+27
+00:01:43,000 --> 00:01:45,000
+Take a few seconds to think about this.
+
+28
+00:01:45,000 --> 00:01:51,000
+Let me run this program and we use it for content manager object method from content manager class was
+
+29
+00:01:51,000 --> 00:01:55,000
+invoked and for admin user method from admin user class was invoked.
+
+30
+00:01:56,000 --> 00:02:02,000
+This is polymorphism user type has the one behavior, the data user access rights.
+
+31
+00:02:02,000 --> 00:02:05,000
+But there are different forms of this behavior.
+
+32
+00:02:06,000 --> 00:02:08,000
+Type of the reference can't be changed.
+
+33
+00:02:08,000 --> 00:02:15,000
+The object of the reference can be of different type, but object type should be compatible with type
+
+34
+00:02:15,000 --> 00:02:16,000
+of the reference.
+
+35
+00:02:16,000 --> 00:02:22,000
+And in the runtime, Java identifies what methods should be called based on the object here during the
+
+36
+00:02:22,000 --> 00:02:23,000
+runtime.
+
+37
+00:02:23,000 --> 00:02:27,000
+That's why we see that methods of specific objects are called.
+
+38
+00:02:28,000 --> 00:02:35,000
+This is called dynamic binding method that should be invoked is identified during the runtime and as
+
+39
+00:02:35,000 --> 00:02:36,000
+a real life example.
+
+40
+00:02:36,000 --> 00:02:40,000
+Imagine we have interface to describe type that can archive files.
+
+41
+00:02:40,000 --> 00:02:47,000
+We can name it archive and says a contract for one method archive files which takes variable argument
+
+42
+00:02:47,000 --> 00:02:52,000
+parameter of type file, will run this type a little bit later in our course.
+
+43
+00:02:52,000 --> 00:02:55,000
+And we have different implementations of this interface.
+
+44
+00:02:55,000 --> 00:03:02,000
+Zakharova and RA archive and again during the runtime, Java will identify the object which stands behind
+
+45
+00:03:02,000 --> 00:03:05,000
+the reference and we'll call method of this exact object.
+
+46
+00:03:10,000 --> 00:03:17,000
+You can notice this override annotation, this is just the information for a compiler, your code will
+
+47
+00:03:17,000 --> 00:03:19,000
+work just awesome without this annotation.
+
+48
+00:03:19,000 --> 00:03:22,000
+Let's remove it and run program one more time.
+
+49
+00:03:22,000 --> 00:03:23,000
+There you see this.
+
+50
+00:03:24,000 --> 00:03:25,000
+Everything is the same.
+
+51
+00:03:25,000 --> 00:03:27,000
+Then why do we need it at all?
+
+52
+00:03:27,000 --> 00:03:32,000
+Imagine that either by mistake or your colleague just added the method parameter here.
+
+53
+00:03:32,000 --> 00:03:36,000
+You want to have compilation error, but what would you see in console?
+
+54
+00:03:37,000 --> 00:03:40,000
+You're going to see a console output from the parent class.
+
+55
+00:03:41,000 --> 00:03:41,000
+Why?
+
+56
+00:03:42,000 --> 00:03:48,000
+Because you are calling validate access rights method but not validate access rights within the parameter.
+
+57
+00:03:49,000 --> 00:03:51,000
+Do you remember topic about methods?
+
+58
+00:03:51,000 --> 00:03:54,000
+These two methods have different signature.
+
+59
+00:03:54,000 --> 00:03:58,000
+Jeff, I didn't know that you want to override behavior of this method.
+
+60
+00:03:59,000 --> 00:04:03,000
+To tell the compiler that you want to override method just adds the sanitation.
+
+61
+00:04:04,000 --> 00:04:08,000
+We'll talk about annotations and how to create them in the separate lesson about annotations.
+
+62
+00:04:09,000 --> 00:04:15,000
+So now you can see that I have the compilation error because now I told the compiler that I want to
+
+63
+00:04:15,000 --> 00:04:17,000
+override this method.
+
+64
+00:04:17,000 --> 00:04:22,000
+And that tells me that if I want to override this method with new behavior, I need to have the same
+
+65
+00:04:22,000 --> 00:04:25,000
+signature of the method as parent class has.
+
+66
+00:04:25,000 --> 00:04:28,000
+And also my return type has to be compatible.
+
+67
+00:04:29,000 --> 00:04:30,000
+Let's take a look at another example.
+
+68
+00:04:30,000 --> 00:04:35,000
+Imagine we have abstract method in our user class to retrieve profile information.
+
+69
+00:04:35,000 --> 00:04:39,000
+And when I will override this method in admin user class, I will return the instance of an account
+
+70
+00:04:39,000 --> 00:04:40,000
+information.
+
+71
+00:04:41,000 --> 00:04:42,000
+Will I have compilation error?
+
+72
+00:04:43,000 --> 00:04:48,000
+No, because I build my application relying on abstractions, profile information.
+
+73
+00:04:48,000 --> 00:04:55,000
+It is an interface, my abstraction, and I can return any object which is compatible with profile information
+
+74
+00:04:55,000 --> 00:04:58,000
+that that will not violate any Java rules.
+
+75
+00:04:58,000 --> 00:04:59,000
+One more thing.
+
+76
+00:04:59,000 --> 00:05:06,000
+Imagine that according to interface get profile information accepts parameter of profile type during
+
+77
+00:05:06,000 --> 00:05:08,000
+the method and location you can pass in the method.
+
+78
+00:05:08,000 --> 00:05:15,000
+Any object of type profile, for example, user profile type is compatible with profile type because
+
+79
+00:05:15,000 --> 00:05:21,000
+profile is an interface and user profile is a concrete class that implements this interface.
+
+80
+00:05:21,000 --> 00:05:27,000
+Here you can see that I can call the method was instance of user profile class and there are no errors.
+
+81
+00:05:27,000 --> 00:05:33,000
+So what you need to remember is that when you overwrite method, behavior, return type and method arguments
+
+82
+00:05:33,000 --> 00:05:38,000
+that you pass to the method during invocation should be compatible with Stipe's declared in parent class
+
+83
+00:05:39,000 --> 00:05:39,000
+hope.
+
+84
+00:05:39,000 --> 00:05:42,000
+Now you understand how you can override methods.
+
+85
+00:05:42,000 --> 00:05:45,000
+One more item which I wanted to discuss with you.
+
+86
+00:05:45,000 --> 00:05:49,000
+General developers often mix up to germ's override and overload.
+
+87
+00:05:50,000 --> 00:05:52,000
+We already know what this method override means.
+
+88
+00:05:53,000 --> 00:05:57,000
+Overload it is when you have masses with the same name, but with different signature.
+
+89
+00:05:58,000 --> 00:06:03,000
+For example, in Zipper Kiva archive files, Masset is overridden and overloaded.
+
+90
+00:06:03,000 --> 00:06:06,000
+Shit is overridden and here it is overloaded.
+
+91
+00:06:06,000 --> 00:06:08,000
+As you can see, overloaded.
+
+92
+00:06:08,000 --> 00:06:12,000
+Macit has the same name but the different method signature.
+
+93
+00:06:12,000 --> 00:06:16,000
+Now you know the difference between Macit override and overloading.
+
+94
+00:06:16,000 --> 00:06:17,000
+Let's move on.
+
+95
+00:06:17,000 --> 00:06:21,000
+And last but not the least topic for today is a final keyword final.
+
+96
+00:06:21,000 --> 00:06:24,000
+Kimura's can have different meaning based on the context.
+
+97
+00:06:25,000 --> 00:06:29,000
+It can be used with classes, methods, variables and parameters.
+
+98
+00:06:29,000 --> 00:06:31,000
+Let's look at final class first.
+
+99
+00:06:32,000 --> 00:06:37,000
+If the class is final like string class, for example, you can't extend new types from it.
+
+100
+00:06:38,000 --> 00:06:40,000
+Let me try to extend my user class from string.
+
+101
+00:06:45,000 --> 00:06:51,000
+And you see, I have the compilation error, so if you want to close your tab for extension, just add
+
+102
+00:06:51,000 --> 00:06:57,000
+final keywords and you already understand that in case, I forbid, client of my code to extend my type
+
+103
+00:06:57,000 --> 00:07:00,000
+in some degree, this violates polymorphism principle.
+
+104
+00:07:01,000 --> 00:07:08,000
+Final verbals can't be initialized with any value after they were declared here in admin user class,
+
+105
+00:07:08,000 --> 00:07:11,000
+a final variable user group of type string.
+
+106
+00:07:11,000 --> 00:07:17,000
+If I have final variable, I can't assign any other value to it after its declaration.
+
+107
+00:07:17,000 --> 00:07:22,000
+For example, if I would try to change value of this variable in the scope of this method, I will get
+
+108
+00:07:22,000 --> 00:07:23,000
+compilation error.
+
+109
+00:07:23,000 --> 00:07:27,000
+And we see here that the clips tells us about compilation error.
+
+110
+00:07:28,000 --> 00:07:34,000
+Final feels should be initialised is instantly after declaration like I have here or in constructor
+
+111
+00:07:34,000 --> 00:07:35,000
+or in installation.
+
+112
+00:07:35,000 --> 00:07:43,000
+Look, if you want initialize final variable with any value, there will be compilation error like this.
+
+113
+00:07:44,000 --> 00:07:46,000
+Similar behavior was final parameters.
+
+114
+00:07:47,000 --> 00:07:50,000
+Usually it is a rule of thumb to make parameters final.
+
+115
+00:07:50,000 --> 00:07:53,000
+That means you can't reassign this argument.
+
+116
+00:07:53,000 --> 00:07:56,000
+What is helpful, in my opinion, you want to use that.
+
+117
+00:07:56,000 --> 00:08:01,000
+People very often declare local variables of methods with final modifier.
+
+118
+00:08:01,000 --> 00:08:03,000
+But this is considered to be a good practice.
+
+119
+00:08:04,000 --> 00:08:07,000
+Final key word can be used with a method in a case.
+
+120
+00:08:07,000 --> 00:08:08,000
+Method is final.
+
+121
+00:08:08,000 --> 00:08:10,000
+It is can't be overridden.
+
+122
+00:08:10,000 --> 00:08:16,000
+For example, in case I will add final modifier to validate access rights method in user class, I will
+
+123
+00:08:16,000 --> 00:08:19,000
+receive compilation error in my admin user class.
+
+124
+00:08:19,000 --> 00:08:20,000
+Let's check.
+
+125
+00:08:21,000 --> 00:08:27,000
+Here's our compilation error, so if you don't want to give opportunity for anyone to override behavior
+
+126
+00:08:27,000 --> 00:08:29,000
+of your method, you can make it final.
+
+127
+00:08:30,000 --> 00:08:35,000
+But again, it doesn't look like object oriented approach because this violates polymorphism principle.
+
+128
+00:08:36,000 --> 00:08:41,000
+And probably you already understand that you can't use final and observe keywords together because they
+
+129
+00:08:41,000 --> 00:08:43,000
+can't exist simultaneously.
+
+130
+00:08:44,000 --> 00:08:47,000
+It looks like that's all what we have in our agenda for today.
+
+131
+00:08:47,000 --> 00:08:50,000
+Let's recap one more time what we have learned today.
+
+132
+00:08:50,000 --> 00:08:56,000
+Today, we have learned with you what polymorphism is now you know, how you can override behavior and
+
+133
+00:08:56,000 --> 00:08:59,000
+what rules we have to follow when we overwrite methods.
+
+134
+00:08:59,000 --> 00:09:02,000
+Also, you learned what dynamic Bindon is.
+
+135
+00:09:02,000 --> 00:09:06,000
+We discussed what is the difference between method overload and mycetoma.
+
+136
+00:09:06,000 --> 00:09:06,000
+Right.
+
+137
+00:09:06,000 --> 00:09:12,000
+And now you know how to use final keywords, which properties, classes, methods and method arguments.
+
+138
+00:09:12,000 --> 00:09:13,000
+That's it.
+
+139
+00:09:14,000 --> 00:09:16,000
+Thank you for your attention and see you in the next lesson.
+

13 - Object-oriented programming/006 Source-code-Account-Information.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/AccountInformation.java

13 - Object-oriented programming/006 Source-code-Admin-User.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/AdminUser.java

13 - Object-oriented programming/006 Source-code-Archiver.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/Archiver.java

13 - Object-oriented programming/006 Source-code-Content-Manager.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/ContentManager.java

13 - Object-oriented programming/006 Source-code-Demo.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/Demo.java

13 - Object-oriented programming/006 Source-code-Profile-Information-Data.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/ProfileInformationData.java

13 - Object-oriented programming/006 Source-code-Profile.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/Profile.java

13 - Object-oriented programming/006 Source-code-Rar-Archiver.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/RarArchiver.java

13 - Object-oriented programming/006 Source-code-User-Profile.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/UserProfile.java

13 - Object-oriented programming/006 Source-code-User.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/User.java

13 - Object-oriented programming/006 Source-code-Zip-Archiver.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/polymorphism/ZipArchiver.java

13 - Object-oriented programming/007 'static' keyword_en.srt

@@ -0,0 +1,440 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello.
+
+2
+00:00:06,000 --> 00:00:09,000
+Students, in this lesson, we'll learn what is a static key word.
+
+3
+00:00:09,000 --> 00:00:12,000
+We'll talk about where we can you start a keyboard.
+
+4
+00:00:12,000 --> 00:00:15,000
+I will explain how we can use static methods, static fields.
+
+5
+00:00:15,000 --> 00:00:20,000
+In this lesson, you are going to learn what a static impulse and what is the difference between static
+
+6
+00:00:20,000 --> 00:00:22,000
+and dynamic binding.
+
+7
+00:00:22,000 --> 00:00:23,000
+Let's start.
+
+8
+00:00:23,000 --> 00:00:25,000
+I truly believe that this topic matter.
+
+9
+00:00:25,000 --> 00:00:27,000
+We can jump to the examples.
+
+10
+00:00:27,000 --> 00:00:32,000
+So first of all, where you can use static keyboard, you already saw in previous lessons that you can
+
+11
+00:00:32,000 --> 00:00:38,000
+use static a keyboard during class declaration with initialization locks, with methods and with properties.
+
+12
+00:00:38,000 --> 00:00:41,000
+Static keyword controls, variable lifetime.
+
+13
+00:00:41,000 --> 00:00:46,000
+I believe you remember static nested classes and we even discussed how to create object of static nested
+
+14
+00:00:46,000 --> 00:00:47,000
+classes.
+
+15
+00:00:47,000 --> 00:00:50,000
+Let's understand what static is on this simple example.
+
+16
+00:00:50,000 --> 00:00:52,000
+You have the user class.
+
+17
+00:00:52,000 --> 00:01:00,000
+It has such properties as and name and one property has static modifier counter field is static during
+
+18
+00:01:00,000 --> 00:01:03,000
+the utilization of each new object and command counter.
+
+19
+00:01:04,000 --> 00:01:09,000
+Now let's try to create two objects of user type and investigate what will be the value of counter energy
+
+20
+00:01:09,000 --> 00:01:10,000
+fields.
+
+21
+00:01:10,000 --> 00:01:16,000
+Here you see a created user number one and user number two and get user aguy and counter value from
+
+22
+00:01:16,000 --> 00:01:18,000
+the first and the second user.
+
+23
+00:01:18,000 --> 00:01:21,000
+Let me run this program and we will investigate with you.
+
+24
+00:01:21,000 --> 00:01:21,000
+Console output.
+
+25
+00:01:22,000 --> 00:01:29,000
+You see that most users have IJI with zero value because zero is the default value for int variable.
+
+26
+00:01:29,000 --> 00:01:32,000
+But counter is not the same as the beginning.
+
+27
+00:01:32,000 --> 00:01:33,000
+Counter is equal to one.
+
+28
+00:01:34,000 --> 00:01:36,000
+And after we see that counter is equal to two.
+
+29
+00:01:37,000 --> 00:01:43,000
+And even more interesting things, if I would call get counter message on the user one object I will
+
+30
+00:01:43,000 --> 00:01:51,000
+get two Y because static variable exists in the single copy and it belongs not to the object but to
+
+31
+00:01:51,000 --> 00:01:52,000
+the whole class.
+
+32
+00:01:52,000 --> 00:01:59,000
+Each time new object is created, this counter variable is incremented and take into account that it
+
+33
+00:01:59,000 --> 00:02:00,000
+exists in single copy.
+
+34
+00:02:00,000 --> 00:02:04,000
+Each time the object is created, the value become more and more.
+
+35
+00:02:04,000 --> 00:02:10,000
+You know that class is a template for future object and each new object will have a new ID property.
+
+36
+00:02:10,000 --> 00:02:13,000
+But static fields are not connected with objects.
+
+37
+00:02:14,000 --> 00:02:15,000
+They are connected with the class.
+
+38
+00:02:16,000 --> 00:02:21,000
+That's why each object knows about class properties and when I call, get the counter method for the
+
+39
+00:02:21,000 --> 00:02:24,000
+second user and get counter message for the first user.
+
+40
+00:02:24,000 --> 00:02:26,000
+I receive the value of the same variable.
+
+41
+00:02:27,000 --> 00:02:27,000
+That's more.
+
+42
+00:02:28,000 --> 00:02:34,000
+Imagine that our user has a child class employee, both user and employee have static method with the
+
+43
+00:02:34,000 --> 00:02:37,000
+same name do any static action.
+
+44
+00:02:37,000 --> 00:02:41,000
+The only difference is that console output is different here.
+
+45
+00:02:41,000 --> 00:02:45,000
+Print the user class name to console and here print the employee.
+
+46
+00:02:45,000 --> 00:02:52,000
+Now let's create object of employee type and let's call the static method what will be printed to console.
+
+47
+00:02:52,000 --> 00:02:58,000
+If you answer in that user class name will be printed to console then you are right why it works this
+
+48
+00:02:58,000 --> 00:02:58,000
+way.
+
+49
+00:02:58,000 --> 00:03:00,000
+This is called static binding.
+
+50
+00:03:00,000 --> 00:03:04,000
+The method which will be called is already known during the compilation time.
+
+51
+00:03:05,000 --> 00:03:11,000
+It is known because I call static method something what belongs to the class but not to the object.
+
+52
+00:03:11,000 --> 00:03:18,000
+That's why if I have a variable of type user here, static method of the type user will be invoked and
+
+53
+00:03:18,000 --> 00:03:23,000
+you see that the clips highlights for us, this method quote, it tells me that static methods shouldn't
+
+54
+00:03:23,000 --> 00:03:30,000
+be accessed in a different way in which we in different usually to access any static entities you use
+
+55
+00:03:30,000 --> 00:03:31,000
+class name.
+
+56
+00:03:31,000 --> 00:03:36,000
+I like this user class and after that you call any static method you wish.
+
+57
+00:03:36,000 --> 00:03:40,000
+Let's call static method of user type and employee type.
+
+58
+00:03:40,000 --> 00:03:46,000
+The example which we discussed in polymorphism when we have tried some method called Dynamic Bindon,
+
+59
+00:03:46,000 --> 00:03:52,000
+because the method which should be executed will be identified during the runtime based on the object
+
+60
+00:03:52,000 --> 00:03:54,000
+that will be behind the reference.
+
+61
+00:03:54,000 --> 00:03:59,000
+And I believe now you understood the dynamic binding is not possible with static methods.
+
+62
+00:03:59,000 --> 00:04:06,000
+You can't override static methods, static, often considered as a bad thing and object oriented programming
+
+63
+00:04:06,000 --> 00:04:13,000
+y because it violates such basic or p principle as polymorphism, it doesn't allow to override behavior,
+
+64
+00:04:13,000 --> 00:04:15,000
+which is the key for orby.
+
+65
+00:04:15,000 --> 00:04:21,000
+Also, during building of a class Iraqi, it is not recommended to have static methods and fields do
+
+66
+00:04:21,000 --> 00:04:28,000
+not get confused that multiple objects share in similar properties, also sometimes static behaviour
+
+67
+00:04:28,000 --> 00:04:30,000
+and static state harder to test.
+
+68
+00:04:30,000 --> 00:04:35,000
+But you will understand this later when we will learn how to write integration and unit tests.
+
+69
+00:04:35,000 --> 00:04:41,000
+Obviously you can use static methods in your code and you can find in the case that static methods are
+
+70
+00:04:41,000 --> 00:04:42,000
+pretty widespread thing.
+
+71
+00:04:43,000 --> 00:04:49,000
+But be prepared that when you will be on your workplace, your team won't be happy to see all static
+
+72
+00:04:49,000 --> 00:04:50,000
+methods in your code.
+
+73
+00:04:50,000 --> 00:04:56,000
+During this course, I will share with you architecture and design approach, which relies on the or
+
+74
+00:04:56,000 --> 00:04:59,000
+principles where static entities are not used.
+
+75
+00:05:00,000 --> 00:05:01,000
+But now you know what?
+
+76
+00:05:01,000 --> 00:05:02,000
+Static keywords.
+
+77
+00:05:02,000 --> 00:05:08,000
+Means knowing this, you can understand why constants have modified static and final, that is because
+
+78
+00:05:08,000 --> 00:05:14,000
+static means that this field exists in a single copy and final means that nobody can change the value
+
+79
+00:05:14,000 --> 00:05:17,000
+of this variable after this variable was declared.
+
+80
+00:05:17,000 --> 00:05:23,000
+So here you can see that I have the compilation error when I try to assign new value to the final variable.
+
+81
+00:05:24,000 --> 00:05:28,000
+I believe you remember a lot about final keywords from the lesson about polymorphism.
+
+82
+00:05:29,000 --> 00:05:32,000
+For now, you already understand why constants have static.
+
+83
+00:05:32,000 --> 00:05:38,000
+Final modifier will not discuss static initialization blocks in this lesson because we discussing the
+
+84
+00:05:38,000 --> 00:05:39,000
+inheritance topic.
+
+85
+00:05:39,000 --> 00:05:43,000
+When I showed you example of all the initialization of an object.
+
+86
+00:05:43,000 --> 00:05:44,000
+Feel free to check that lesson.
+
+87
+00:05:44,000 --> 00:05:50,000
+If you want to recall information about static initialization, luks the last but not the least thing
+
+88
+00:05:50,000 --> 00:05:50,000
+for today.
+
+89
+00:05:50,000 --> 00:05:53,000
+What I wanted to discuss with you is a static Kimber's.
+
+90
+00:05:53,000 --> 00:05:55,000
+It is pretty simple.
+
+91
+00:05:55,000 --> 00:05:57,000
+For example, do you remember our class?
+
+92
+00:05:57,000 --> 00:06:03,000
+It contains only static methods and to call any static method you need to write our race class name
+
+93
+00:06:03,000 --> 00:06:05,000
+and then call any method you would like.
+
+94
+00:06:06,000 --> 00:06:12,000
+But what if you don't want to write arrays every time you can import all static entities from a race
+
+95
+00:06:12,000 --> 00:06:12,000
+class?
+
+96
+00:06:13,000 --> 00:06:15,000
+How to do that on the top of your file?
+
+97
+00:06:15,000 --> 00:06:15,000
+Right.
+
+98
+00:06:15,000 --> 00:06:22,000
+This inpart, static java, which you are, is not an asterisk.
+
+99
+00:06:22,000 --> 00:06:29,000
+This symbol means that you want to import all static entities that exist in this class by saying all
+
+100
+00:06:29,000 --> 00:06:30,000
+I mean methods, fields.
+
+101
+00:06:30,000 --> 00:06:32,000
+That is what you will use.
+
+102
+00:06:32,000 --> 00:06:37,000
+And now you can call, for example, source method without writing our class name.
+
+103
+00:06:38,000 --> 00:06:40,000
+It looks like that it according to our agenda.
+
+104
+00:06:40,000 --> 00:06:42,000
+Let's recap what we have learned today.
+
+105
+00:06:43,000 --> 00:06:47,000
+Today we learned how static keyboard works with fields and methods.
+
+106
+00:06:47,000 --> 00:06:50,000
+We discuss what is static and dynamic binding.
+
+107
+00:06:50,000 --> 00:06:56,000
+And now you know why static considered to be a bad thing in or B hope you understood how to declare
+
+108
+00:06:56,000 --> 00:06:57,000
+your own constants variables.
+
+109
+00:06:58,000 --> 00:07:01,000
+Also, you learned how to improve static in your Java file.
+
+110
+00:07:02,000 --> 00:07:06,000
+That's said thank you for your attention and see you in the next lesson.
+

13 - Object-oriented programming/007 Source-code-Demo.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/staticdemo/Demo.java

13 - Object-oriented programming/007 Source-code-Employee.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/staticdemo/Employee.java

13 - Object-oriented programming/007 Source-code-User.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/oop/staticdemo/User.java

13 - Object-oriented programming/008 Encapsulation_en.srt

@@ -0,0 +1,384 @@
+1
+00:00:05,000 --> 00:00:11,000
+Hello, dear students, in this lesson, we'll talk about encapsulation and we'll learn what is the
+
+2
+00:00:11,000 --> 00:00:15,000
+role of encapsulation principle in the object oriented programming.
+
+3
+00:00:15,000 --> 00:00:17,000
+In this lesson, we'll talk with you.
+
+4
+00:00:17,000 --> 00:00:22,000
+Why do we need encapsulation and how we can implement encapsulation in our programs?
+
+5
+00:00:22,000 --> 00:00:28,000
+We'll learn with your access modifiers and on real court examples, I will show you how you can use
+
+6
+00:00:28,000 --> 00:00:28,000
+them.
+
+7
+00:00:28,000 --> 00:00:34,000
+I will share with you my practical experience when to use which modifier and will learn the rules which
+
+8
+00:00:34,000 --> 00:00:36,000
+we need to follow during overwriting.
+
+9
+00:00:36,000 --> 00:00:40,000
+So let's jump to examples to understand this topic better.
+
+10
+00:00:41,000 --> 00:00:42,000
+What is an observation?
+
+11
+00:00:43,000 --> 00:00:48,000
+Encapsulation is a principle that teaches us to group data and behavior those our fields and methods
+
+12
+00:00:49,000 --> 00:00:49,000
+together.
+
+13
+00:00:49,000 --> 00:00:56,000
+As a single unit, we can control access to interfaces, classes, fields, methods to control access.
+
+14
+00:00:56,000 --> 00:00:58,000
+We have four main access modifiers.
+
+15
+00:00:59,000 --> 00:01:04,000
+They are public protected package, private or default private.
+
+16
+00:01:05,000 --> 00:01:10,000
+Let's start one by one to understand the difference on the specific examples, to not show you how access
+
+17
+00:01:10,000 --> 00:01:13,000
+modifiers work with classes, fields and methods.
+
+18
+00:01:13,000 --> 00:01:19,000
+Separately, I will show you how Access Modifier works with methods, because these modifiers control
+
+19
+00:01:19,000 --> 00:01:25,000
+access to elements and the way how they work are similar, no matter whether you're trying to get access
+
+20
+00:01:25,000 --> 00:01:26,000
+for field or method.
+
+21
+00:01:27,000 --> 00:01:34,000
+OK, so imagine we have some class, let's call it Class A. And inside this class we have the method
+
+22
+00:01:34,000 --> 00:01:35,000
+with public access modifier.
+
+23
+00:01:36,000 --> 00:01:39,000
+That means you can access it from any point of your program.
+
+24
+00:01:39,000 --> 00:01:44,000
+For example, here you can see them a class which is outside of our package.
+
+25
+00:01:44,000 --> 00:01:44,000
+No.
+
+26
+00:01:44,000 --> 00:01:49,000
+One, I can create the instance of Class A and call the public method on it.
+
+27
+00:01:50,000 --> 00:01:53,000
+Now imagine I have protected MassArt.
+
+28
+00:01:53,000 --> 00:01:57,000
+Do something to will I be able to call it from them a class?
+
+29
+00:01:57,000 --> 00:02:04,000
+Unfortunately, no way, because I can get access to protected entities only inside the same package
+
+30
+00:02:04,000 --> 00:02:06,000
+or in a child class.
+
+31
+00:02:06,000 --> 00:02:12,000
+If only I had them a class inside the package, no one I would be able to call method to do something
+
+32
+00:02:12,000 --> 00:02:14,000
+to see here.
+
+33
+00:02:15,000 --> 00:02:19,000
+I can call this method when demo class is in the same package with class A.
+
+34
+00:02:20,000 --> 00:02:28,000
+Also here I have a class of the class A, package number two and inside the do something class B I can
+
+35
+00:02:28,000 --> 00:02:29,000
+call protective measures.
+
+36
+00:02:29,000 --> 00:02:30,000
+Do something too.
+
+37
+00:02:30,000 --> 00:02:37,000
+So now you understand that I can access protected entities in case they're in the same package or in
+
+38
+00:02:37,000 --> 00:02:38,000
+child classes.
+
+39
+00:02:39,000 --> 00:02:41,000
+Our next modifier is package private.
+
+40
+00:02:42,000 --> 00:02:43,000
+You can see that do something.
+
+41
+00:02:43,000 --> 00:02:47,000
+Class B doesn't have any access modifier specified.
+
+42
+00:02:47,000 --> 00:02:48,000
+That is not true.
+
+43
+00:02:49,000 --> 00:02:54,000
+When we don't specify access modifiers, that means that access to this entity is a default.
+
+44
+00:02:55,000 --> 00:02:58,000
+So usually absence of any keywords are associated with access.
+
+45
+00:02:58,000 --> 00:03:02,000
+Modifier is called package primary or just default access.
+
+46
+00:03:02,000 --> 00:03:04,000
+So let me get back to them.
+
+47
+00:03:04,000 --> 00:03:10,000
+A class and package number one in scope of this package, I will create the object of the Class B type.
+
+48
+00:03:10,000 --> 00:03:17,000
+And on this object I call do something Class B method and you see that I have a compilation error.
+
+49
+00:03:17,000 --> 00:03:24,000
+But if I create object of Class B type inside the package number two and call the same method, it is
+
+50
+00:03:24,000 --> 00:03:28,000
+possible because default access is only within the same package.
+
+51
+00:03:29,000 --> 00:03:33,000
+Take into account this demo class and Class B in the same package.
+
+52
+00:03:33,000 --> 00:03:39,000
+We don't have compilation error and last but not least, modifier is private modifier.
+
+53
+00:03:39,000 --> 00:03:41,000
+Everything is easy here.
+
+54
+00:03:41,000 --> 00:03:44,000
+You can access private entities only in scope.
+
+55
+00:03:44,000 --> 00:03:49,000
+When it was declared, for example, I have private method declared in this class and I can call this
+
+56
+00:03:49,000 --> 00:03:56,000
+private method wherever I want in this class, but I can't call this method outside of the class, even
+
+57
+00:03:56,000 --> 00:03:58,000
+in the same package.
+
+58
+00:03:58,000 --> 00:04:01,000
+If I will try to do so, I see compilation error.
+
+59
+00:04:02,000 --> 00:04:05,000
+So now you understand the difference between modifiers.
+
+60
+00:04:05,000 --> 00:04:11,000
+I believe you understood that encapsulation in all AP language can be implemented with the help of access
+
+61
+00:04:11,000 --> 00:04:14,000
+modifiers and you know how they work.
+
+62
+00:04:15,000 --> 00:04:19,000
+Knowing this during the planning of architecture, you can choose access modifier, which works the
+
+63
+00:04:19,000 --> 00:04:20,000
+best for you.
+
+64
+00:04:21,000 --> 00:04:27,000
+I want to share with you, which modifies you will use most of the times in 99 percent of cases you
+
+65
+00:04:27,000 --> 00:04:29,000
+will use is a private or public.
+
+66
+00:04:29,000 --> 00:04:35,000
+This is because you may have very few business cases when you want to keep something visible only in
+
+67
+00:04:35,000 --> 00:04:39,000
+scope of the package or only in scope of the package and child class.
+
+68
+00:04:40,000 --> 00:04:44,000
+Most likely you will implement interfaces and would like to keep the behavior public.
+
+69
+00:04:45,000 --> 00:04:50,000
+Sometimes you will have methods which are needed only for this class and you will keep them private.
+
+70
+00:04:50,000 --> 00:04:56,000
+Usually all fields have the private access modifier because you want to control interaction with your
+
+71
+00:04:56,000 --> 00:04:57,000
+object.
+
+72
+00:04:57,000 --> 00:05:03,000
+So now you understand that default and protected modifiers are not used very often.
+
+73
+00:05:04,000 --> 00:05:09,000
+And last thing for the day, which I wanted to discuss with you, is the rules for access modifiers
+
+74
+00:05:09,000 --> 00:05:09,000
+during that method.
+
+75
+00:05:09,000 --> 00:05:12,000
+Overriding the rule is simple.
+
+76
+00:05:12,000 --> 00:05:17,000
+When you override the method, you can't reduce the visibility of the inherited method.
+
+77
+00:05:17,000 --> 00:05:21,000
+For example, in class a way of do something method.
+
+78
+00:05:21,000 --> 00:05:27,000
+Class B extends class A and class C extends class B, is that clear?
+
+79
+00:05:27,000 --> 00:05:35,000
+And now I want to do something method and I override it was protected to modify it just to recall it
+
+80
+00:05:35,000 --> 00:05:37,000
+was public and parent class.
+
+81
+00:05:37,000 --> 00:05:43,000
+And I have a compilation error here because we can't narrow access.
+
+82
+00:05:43,000 --> 00:05:46,000
+On the other hand, in Class B, do something.
+
+83
+00:05:46,000 --> 00:05:49,000
+Class B method has default access modifier.
+
+84
+00:05:49,000 --> 00:05:50,000
+I can increase access level.
+
+85
+00:05:53,000 --> 00:05:59,000
+And you can see here that I overwrite my head with public modifier and there is no compilation error
+
+86
+00:05:59,000 --> 00:06:03,000
+because you can extend access now, that's it.
+
+87
+00:06:04,000 --> 00:06:06,000
+Now, let's recall what we have learned today.
+
+88
+00:06:07,000 --> 00:06:09,000
+Today, we learned what an encapsulation is.
+
+89
+00:06:09,000 --> 00:06:13,000
+We know that access modifiers can help us to implement encapsulation.
+
+90
+00:06:13,000 --> 00:06:20,000
+Principle in our code also will learn the difference between public protected default and private access
+
+91
+00:06:20,000 --> 00:06:21,000
+modifiers.
+
+92
+00:06:21,000 --> 00:06:27,000
+We discussed which modifiers developers use more often, and we saw specific rules which we need to
+
+93
+00:06:27,000 --> 00:06:29,000
+follow during override.
+
+94
+00:06:29,000 --> 00:06:32,000
+And that's all what I had in my agenda for today.
+
+95
+00:06:32,000 --> 00:06:34,000
+Thanks a lot for your attention.
+
+96
+00:06:34,000 --> 00:06:35,000
+And see you in the next lesson.
+

13 - Object-oriented programming/008 Source-code-All-examples-from-the-lecture.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/oop/encapsulation

13 - Object-oriented programming/009 Object, JNI and Object class overview_en.srt

@@ -0,0 +1,532 @@
+1
+00:00:06,000 --> 00:00:11,000
+Hello, dissidents, today we have a very important topic that they will discuss with you what object
+
+2
+00:00:11,000 --> 00:00:13,000
+this will review object class.
+
+3
+00:00:13,000 --> 00:00:19,000
+We are going to discuss what methods object class has this really important for us because each class
+
+4
+00:00:19,000 --> 00:00:21,000
+in Java implicitly extends object.
+
+5
+00:00:21,000 --> 00:00:23,000
+Class will join with you today.
+
+6
+00:00:23,000 --> 00:00:26,000
+What is Jeani and Nucleate Native?
+
+7
+00:00:26,000 --> 00:00:28,000
+So let's us look at the source code.
+
+8
+00:00:28,000 --> 00:00:32,000
+Learn the source code is the best way to learn any programming language.
+
+9
+00:00:33,000 --> 00:00:36,000
+So you already know that everything in Java is an object.
+
+10
+00:00:36,000 --> 00:00:43,000
+Object is a virtual entity that has its own behavior and state which can distinguish it from other objects.
+
+11
+00:00:43,000 --> 00:00:47,000
+That means each object will inherit methods of object class.
+
+12
+00:00:47,000 --> 00:00:54,000
+Our goal in this lesson to review these methods and to understand what therefore you can press control
+
+13
+00:00:54,000 --> 00:01:00,000
+plus shift pastie to search for any specific type, I'd like to open source code of the object class.
+
+14
+00:01:00,000 --> 00:01:06,000
+Now this class is from Java Lank package and you remember the Java land packages interested in each
+
+15
+00:01:06,000 --> 00:01:08,000
+Java file by default.
+
+16
+00:01:08,000 --> 00:01:13,000
+So you never have to import object class into Java files.
+
+17
+00:01:13,000 --> 00:01:18,000
+First of all, you can find a new keyword native to understand what is it?
+
+18
+00:01:18,000 --> 00:01:21,000
+Let's discuss with you what Jeani stands for.
+
+19
+00:01:21,000 --> 00:01:28,000
+Java Native Interface is a foreign function interface programming framework that enables Java code running
+
+20
+00:01:28,000 --> 00:01:34,000
+in Java Virtual Machine to call and be called by native applications and libraries written in other
+
+21
+00:01:34,000 --> 00:01:37,000
+languages such as C or C++.
+
+22
+00:01:38,000 --> 00:01:45,000
+To simplify this, you can see native keyword with the methods that are written on C or C++ language.
+
+23
+00:01:45,000 --> 00:01:48,000
+Native keyword can be used only with methods.
+
+24
+00:01:48,000 --> 00:01:51,000
+Sure, you see native method registered natives.
+
+25
+00:01:52,000 --> 00:01:55,000
+You need to register all native functions.
+
+26
+00:01:55,000 --> 00:02:01,000
+You see that you have static in your blog, which executes only once during your program execution.
+
+27
+00:02:01,000 --> 00:02:05,000
+This static unit block calls register native method.
+
+28
+00:02:05,000 --> 00:02:09,000
+This method has a private modifier so you will never use it.
+
+29
+00:02:09,000 --> 00:02:13,000
+Let's focus our attention on the public interface of that class object.
+
+30
+00:02:14,000 --> 00:02:16,000
+Here is the default constructor.
+
+31
+00:02:16,000 --> 00:02:17,000
+Nothing special.
+
+32
+00:02:17,000 --> 00:02:25,000
+Here's a good class method and you can notice that it also native so each object can return us its class.
+
+33
+00:02:26,000 --> 00:02:30,000
+Class is a separate type which will learn in detail during the lesson about reflection.
+
+34
+00:02:31,000 --> 00:02:38,000
+In short, this is Stack which describes objects of a class type, so each class during the runtime
+
+35
+00:02:38,000 --> 00:02:45,000
+has an object associated with it and the class object knows all about fields, methods, annotations,
+
+36
+00:02:45,000 --> 00:02:47,000
+constructors, everything.
+
+37
+00:02:47,000 --> 00:02:51,000
+You can invoke methods on objects using getters.
+
+38
+00:02:51,000 --> 00:02:53,000
+You can get whatever you need.
+
+39
+00:02:53,000 --> 00:02:58,000
+For example, here's a getter that returns array of fields declared in the class.
+
+40
+00:02:58,000 --> 00:02:59,000
+But let's not switch.
+
+41
+00:02:59,000 --> 00:03:04,000
+The topic will return this class in detail later in our course.
+
+42
+00:03:04,000 --> 00:03:08,000
+What else do we have in our object class Hedgcock method?
+
+43
+00:03:09,000 --> 00:03:14,000
+A hash code is an integer value that is associated with each object in Java.
+
+44
+00:03:14,000 --> 00:03:20,000
+Its main purpose is to facilitate hash in hash tables, which are used by data structures like hash
+
+45
+00:03:20,000 --> 00:03:26,000
+map really learn how to override this method and how to use it when done with your Java collections
+
+46
+00:03:26,000 --> 00:03:27,000
+framework.
+
+47
+00:03:27,000 --> 00:03:34,000
+Because as I already mentioned, we can benefit from this method when we use collections equals method
+
+48
+00:03:34,000 --> 00:03:40,000
+will tell you if the current object is equal to another object or no, it returns only true or false.
+
+49
+00:03:41,000 --> 00:03:43,000
+And you see that by the fall, this matter.
+
+50
+00:03:43,000 --> 00:03:44,000
+Check the references.
+
+51
+00:03:45,000 --> 00:03:52,000
+So in case we need to be able to check equality of our objects in our classes, we have to override
+
+52
+00:03:52,000 --> 00:03:52,000
+this method.
+
+53
+00:03:53,000 --> 00:03:58,000
+When we will override this method, will check the state of each field to make sure that this is not
+
+54
+00:03:58,000 --> 00:04:01,000
+the same object like we do when we compare references.
+
+55
+00:04:02,000 --> 00:04:06,000
+But to say that this object is logically equal to the one in method argument.
+
+56
+00:04:07,000 --> 00:04:14,000
+For example, you have Mercedes s class and your friend has Mercedes has class, most of them have the
+
+57
+00:04:14,000 --> 00:04:19,000
+same color, the same engine displacement, the same color of laser.
+
+58
+00:04:19,000 --> 00:04:20,000
+Inside the car.
+
+59
+00:04:20,000 --> 00:04:28,000
+You have two cars, but do they equal they're still two separate cars, but they are logically equal
+
+60
+00:04:28,000 --> 00:04:29,000
+to each other.
+
+61
+00:04:29,000 --> 00:04:34,000
+That's why sometimes we need to override the equals method in our court.
+
+62
+00:04:35,000 --> 00:04:38,000
+How to override the equals method will be covered in the separate lesson.
+
+63
+00:04:39,000 --> 00:04:42,000
+Now let's briefly discuss Klown method.
+
+64
+00:04:42,000 --> 00:04:47,000
+The goal of this method is to create new object on the basis of already existed one.
+
+65
+00:04:47,000 --> 00:04:54,000
+But what you need to remember is that there is a deep and shallow cloning clone method by default,
+
+66
+00:04:54,000 --> 00:04:55,000
+thus shallow cloning.
+
+67
+00:04:55,000 --> 00:04:56,000
+What does that mean?
+
+68
+00:04:57,000 --> 00:05:00,000
+That means that all references are copied.
+
+69
+00:05:00,000 --> 00:05:04,000
+It doesn't cause a problem when we clone fields of primitive types.
+
+70
+00:05:04,000 --> 00:05:11,000
+But this does cause problems when we are cloning reference types because only references are cloned
+
+71
+00:05:11,000 --> 00:05:18,000
+by the true objects behind those references are not cloned to clones at all fields of the objects we
+
+72
+00:05:18,000 --> 00:05:22,000
+need to override clone method and to implement deep cloning.
+
+73
+00:05:22,000 --> 00:05:28,000
+What I would recommend us to do right now is to keep overview of the object methods and we'll have separate
+
+74
+00:05:28,000 --> 00:05:32,000
+lessons to learn how to overwrite clone method to support the cloning.
+
+75
+00:05:33,000 --> 00:05:37,000
+Also, pay attention to this method has protected access modifier.
+
+76
+00:05:37,000 --> 00:05:40,000
+I believe you are already aware how the string method works.
+
+77
+00:05:40,000 --> 00:05:43,000
+This method returns string representation of the object.
+
+78
+00:05:43,000 --> 00:05:46,000
+Probably in your production code.
+
+79
+00:05:46,000 --> 00:05:51,000
+You want to use this method very often, but you are going to use it very often during your learning
+
+80
+00:05:51,000 --> 00:05:53,000
+process for debugging purposes.
+
+81
+00:05:53,000 --> 00:05:58,000
+Often you would like to print the object, to consult, to check its state, or to interact with your
+
+82
+00:05:58,000 --> 00:06:02,000
+user in console applications by default.
+
+83
+00:06:02,000 --> 00:06:08,000
+To string method creates a string which comprises of class name at sine and hexadecimal representation
+
+84
+00:06:08,000 --> 00:06:09,000
+of the hash code.
+
+85
+00:06:09,000 --> 00:06:13,000
+We already understand that we can easily override this method in our classes.
+
+86
+00:06:14,000 --> 00:06:17,000
+Usually we want to bring state of the object in the console.
+
+87
+00:06:18,000 --> 00:06:24,000
+Probably you remember that in one of our lessons we review source code of the card class and the string
+
+88
+00:06:24,000 --> 00:06:26,000
+method was overridden there.
+
+89
+00:06:27,000 --> 00:06:33,000
+You can see here that we used the fields to bring their values to console, to not override this method
+
+90
+00:06:33,000 --> 00:06:34,000
+by yourself.
+
+91
+00:06:34,000 --> 00:06:36,000
+You can ask Leap's to generate this method for you.
+
+92
+00:06:37,000 --> 00:06:41,000
+Just press old plus shift plus s and select generate the string method.
+
+93
+00:06:42,000 --> 00:06:46,000
+You will be able to specify fields which you want to use in your to string method.
+
+94
+00:06:47,000 --> 00:06:54,000
+The next method, identifying the all over overloaded wait method and methods to control interaction
+
+95
+00:06:54,000 --> 00:06:54,000
+with objects.
+
+96
+00:06:54,000 --> 00:06:59,000
+Monitor this topic is closely connected with multi topic.
+
+97
+00:06:59,000 --> 00:07:05,000
+To explain how this method works, I need to explain first what Monteith's readiness and how synchronization
+
+98
+00:07:05,000 --> 00:07:07,000
+of multiple threads happens.
+
+99
+00:07:07,000 --> 00:07:10,000
+That's why I suggest to park this question.
+
+100
+00:07:10,000 --> 00:07:15,000
+Promise you to give details overview of these methods during mulches writing topic.
+
+101
+00:07:15,000 --> 00:07:21,000
+For now, you can learn that each object in Java has special methods to control interaction with objects.
+
+102
+00:07:21,000 --> 00:07:21,000
+Monitor.
+
+103
+00:07:22,000 --> 00:07:27,000
+And the last method, which I would like to mention today, is finalized, originally this method was
+
+104
+00:07:27,000 --> 00:07:33,000
+created to serve as a distracter method, special message, which always will be invoked during the
+
+105
+00:07:33,000 --> 00:07:35,000
+object destruction in Java.
+
+106
+00:07:35,000 --> 00:07:41,000
+We have automated memory management and one of the tools which ensure efficient memory management is
+
+107
+00:07:41,000 --> 00:07:42,000
+the garbage collector.
+
+108
+00:07:43,000 --> 00:07:48,000
+We are going to have separate lessons regarding garbage collector, but in short, this tool removes
+
+109
+00:07:48,000 --> 00:07:52,000
+from heap objects that don't have strong references in the program anymore.
+
+110
+00:07:53,000 --> 00:07:59,000
+You know that objects are stored in the heat of memory and it is not endless, that means that time
+
+111
+00:07:59,000 --> 00:08:01,000
+to time we have to remove objects.
+
+112
+00:08:01,000 --> 00:08:08,000
+And when a garbage collector removes objects from the memory, finalized method is invoked that was
+
+113
+00:08:08,000 --> 00:08:14,000
+needed to perform critical and important actions like resource closure or something else before objects
+
+114
+00:08:14,000 --> 00:08:15,000
+will be completely destroyed.
+
+115
+00:08:16,000 --> 00:08:20,000
+It also has to modifier and can be overridden in the class.
+
+116
+00:08:20,000 --> 00:08:25,000
+But another important thing you need to know about this method is that it is deprecated.
+
+117
+00:08:26,000 --> 00:08:32,000
+It is marked as deprecated because finalization mechanism is problematic and in some specific cases
+
+118
+00:08:32,000 --> 00:08:34,000
+can lead to memory leaks and deadlocks.
+
+119
+00:08:35,000 --> 00:08:38,000
+That's why it is not recommended to use this method anymore.
+
+120
+00:08:39,000 --> 00:08:45,000
+In Java, a lot of deprecated methods are not removed just to ensure a backwards compatibility to make
+
+121
+00:08:45,000 --> 00:08:50,000
+sure that application, which was written with Java version first, will be successfully executed on
+
+122
+00:08:50,000 --> 00:08:52,000
+Java version 14 and later.
+
+123
+00:08:53,000 --> 00:08:57,000
+But this annotation means that this method should no longer be used.
+
+124
+00:08:57,000 --> 00:09:00,000
+It looks like we reviewed all methods from the object class.
+
+125
+00:09:01,000 --> 00:09:03,000
+Let's recall what we have learned today.
+
+126
+00:09:04,000 --> 00:09:04,000
+Today, billions.
+
+127
+00:09:04,000 --> 00:09:07,000
+What is the object and what is the object class with it?
+
+128
+00:09:07,000 --> 00:09:12,000
+Overview of all methods which exist in the object class and which are present in each object.
+
+129
+00:09:13,000 --> 00:09:20,000
+You learn new keyword, native keyword and you know what it is for today we discussed what Jeani is
+
+130
+00:09:21,000 --> 00:09:24,000
+really one that we can easily overwrite methods in our class.
+
+131
+00:09:25,000 --> 00:09:28,000
+Also, we discussed what does deprecated annotation mean.
+
+132
+00:09:29,000 --> 00:09:31,000
+That's all what I have for you for today.
+
+133
+00:09:31,000 --> 00:09:34,000
+Thanks a lot for your attention and see you in the next lesson.
+

13 - Object-oriented programming/010 Quiz Object-oriented programming - Check yourself.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Quiz Object-oriented programming - Check yourself</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">Quiz Object-oriented programming - Check yourself</div>
+                <div class="article-asset-container"><p><strong>Quiz Link: </strong><a href="https://forms.gle/NZmCGDrFk2hfCQLs5" rel="noopener noreferrer" target="_blank"><strong>https://forms.gle/NZmCGDrFk2hfCQLs5</strong></a></p><p>The quiz doesn’t require you to log in or submit any personal information. Your data privacy is my priority.</p><p>The Quiz covers content from the following lessons:</p><ul><li><p>Object-Oriented Programming: Basics</p></li><li><p>Classes &amp; Objects</p></li><li><p>Different types of Classes, Abstract keyword and Abstract classes</p></li><li><p>Interfaces</p></li><li><p>Inheritance</p></li><li><p>Polymorphism</p></li><li><p>Static in Java - ‘static’ keyword</p></li><li><p>Encapsulation</p></li><li><p>Object, JNI and Object class overview</p></li></ul><p><strong>Quiz Instructions:</strong></p><p>This quiz is designed to help you check your understanding of the content from the previous lessons. All questions are based only on material covered in the lessons you've already watched, so there’s no need to worry about unfamiliar topics.</p><ul><li><p>Each question has one correct answer. Select the best answer and click "Submit" when you're ready.</p></li><li><p>After submitting, you'll see your score. For each question, you earn 1 point.</p></li><li><p>Click "View Results" to see the explanations for each correct answer. Reviewing these explanations can help reinforce your understanding.</p></li><li><p>If you score below 70%, I recommend revisiting the previous lessons. However, if the explanations make sense and you’re confident in your understanding, feel free to move on.</p></li><li><p>If any explanations are unclear, please don’t hesitate to post questions in the Q&amp;A section—I’m here to help!</p></li></ul></div>
+            </div>
+        </div>
+    </body>
+</html>