Download "5. (09/25) Value-returning methods (Irina Z Java)"
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FaaKoNsEynFU%252Fmaxresdefault.jpg&w=3840&q=75)
Please wait. We're preparing links for easy ad-free video watching and downloading.
Similar videos from our catalog
13:49
世界最好的多功能工具瑞士軍刀工廠，每天生產60000把折疊刀，製造一把刀需要450道工序
Channel: 大脑洞记事
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FHX_91btsfTk%252Fmaxresdefault.jpg&w=3840&q=75)
8:34
世界上最大的洗車場，每天要洗4000輛車，洗一輛車從8歐元到40歐元不等
Channel: 大脑洞记事
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FOJXmJ2a3gXo%252Fsddefault.jpg&w=3840&q=75)
9:29
Что за столяр без шила!
Channel: Столярная Кухня
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FPuLESTj68AA%252Fsd2.jpg%253Fsqp%253D-oaymwEoCIAFEOAD8quKqQMcGADwAQH4AbYIgAKAD4oCDAgAEAEYOSBXKHIwDw%253D%253D%2526rs%253DAOn4CLDT42OLoIFyIFSD1luWs8x9eYbZdg&w=3840&q=75)
1:00
Why not place the cockpit inside the transparent nose but on top instead? #shorts
Channel: Beyond Explained
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FR9an1i56cMQ%252Fmaxresdefault.jpg&w=3840&q=75)
14:30
走進美國最大的造幣工廠，探秘硬幣的製造過程與流通應用
Channel: 大脑洞记事
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FnnJb7r1Np60%252Fmaxresdefault.jpg&w=3840&q=75)
17:34
美國最大鑄幣工廠，探秘美鈔的製作流程，每天印製6億5千萬美元
Channel: 大脑洞记事
4:16
FILMORA X, TUTORIEL COMPLET MOTION TRACKING EN FRANÇAIS.
Channel: Francois Carment
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FvMZiCuWnFhE%252Fmaxresdefault.jpg&w=3840&q=75)
51:54
Немецкая СТЕЛС - технология. Субмарина - невидимка U-480 Альберих. Охота в Ламанше
Channel: Подводные лодки и ВМФ
%3Aformat(webp)%2Fi.ytimg.com%252Fvi%252FxJXgfLXiWyI%252Fmaxresdefault.jpg&w=3840&q=75)
9:49
Обзор "Перст-2": распаковка, юстировка, органы управления
Channel: Зенитка
12:47
СУПЕР-яхта за МИЛЛИАРД рублей — обзор!
Channel: 808
Video tags
0925
value-returning
methods
irina
z
java
Subtitles
Russian
00:00:01
Yes Welcome everyone to the recording And today00:00:05
we have such a fairly extensive lesson00:00:08
Even though we have a new topic00:00:11
a small one is planned Well, that is, I think00:00:14
Well, it won't take that much00:00:17
time but you still want00:00:19
show more code today and to00:00:22
here's how to delve into this even more00:00:25
topic of separating code into methods and so that00:00:29
you seem to have put it off more and more00:00:31
I don’t know if we’ll have time to get there today00:00:35
such an important big part let's see how00:00:38
everything will go like this and we'll see how00:00:42
I wonder how it will all be, but I hope something00:00:45
let's go again the important part00:00:47
which I planned today she00:00:50
today for those who will start from scratch00:00:52
more as a reminder00:00:55
you will have no homework for this00:00:58
part of the lesson if we get to it here00:01:02
it will be greater for those who already00:01:04
seems to have gotten the hang of it and can easily complete the first one00:01:07
part of the work Here are homework and how00:01:12
would be ready for the big ones00:01:14
experiments Well, from the next lesson00:01:18
we will completely switch over to that00:01:21
most of the second part that I am today00:01:23
I plan to also want to say that00:01:28
first of all I really really want to00:01:30
please emphasize everything a lot00:01:33
Dear Beginners Who came with00:01:36
absolute zero please keep in00:01:39
I see that for you it’s like your main00:01:42
the goal is to make the first part homemade00:01:45
work, everything else is still up to you00:01:49
grew up for you to just watch so you00:01:52
we understood that it was like being in a car00:01:55
testing there is a task not only00:01:58
from the first part but the first part This is00:02:00
minimum00:02:01
You must master to prepare for00:02:04
auto testing here's what else00:02:07
I would like to say that if any of you00:02:10
is far behind the program there00:02:13
on time or joined later00:02:16
please keep in mind that now00:02:19
our topics will be just like boom-boom-boom00:02:22
one after another and you have to keep up and what00:02:25
you might be here just this week00:02:28
it remains for you to catch up00:02:30
my idea of how to catch up with this00:02:34
I would like to watch all the videos and try00:02:38
complete the first part of each homework00:02:41
which you have not yet completed00:02:42
second third If you're late Bye00:02:45
don't even touch it, that is, you can00:02:48
see analysis But honestly not even yet00:02:51
waste time because you just don't00:02:54
you will have time to build for testing That is00:02:56
if you sit down like this, you won't00:02:59
you have time and you fall behind, you are no longer00:03:02
you will have time to integrate into the project because00:03:04
well, everything will be very active now00:03:08
and we have more important topics that00:03:11
you need to master that is, very, very00:03:13
I advise you to spend more time If you00:03:16
still want to integrate into the project If00:03:19
If you don't want anything bad, then go00:03:21
at your own pace If you want it, it’s not like that00:03:24
a lot of time for catching up and00:03:28
lag and how you need to take yourself00:03:31
in your hands you will literally have this00:03:34
perhaps one more week to00:03:36
have time to catch up, swing and, as it were,00:03:40
it’s better to keep up further because there00:03:42
right here Well, really, we’ll start to have something like this00:03:45
topics that are absolutely necessary at least00:03:48
listen at least a little00:03:49
practice and then it will begin00:03:57
stranded these are all the topics that00:04:00
definitely for you definitely need00:04:03
get in step with the whole group here00:04:06
because otherwise you'll miss it00:04:09
the moment of integration into the project will come later00:04:11
very difficult to fit in00:04:13
And what else did I want to say? oh well00:04:18
still concentrate on00:04:20
first part of homework today I00:04:23
I will try to give you much more00:04:25
examples as if to perform the first00:04:27
parts of homework that is, so that these00:04:30
the examples were similar to the task from the first00:04:33
parts so you can do something00:04:35
navigate When you do the first00:04:38
some of the homework is also very00:04:40
I hope that all of you who wanted to get00:04:42
groups got here if we let’s say00:04:46
there are a huge number of people who would00:04:49
I wanted to get into the group but at the same time00:04:51
Let's say there's no place in the groups anymore, you're not00:04:54
got it, let's discuss it on telegram00:04:56
maybe we can come up with something there00:04:58
But if there are a few such people00:05:02
Well there maybe however how they be extra00:05:05
the group will be full Well, let's do it00:05:08
We'll discuss everything after the lesson on telegram.00:05:10
yes this is not the topic of today's lesson00:05:13
Well, what do we start with? I mean first00:05:17
I still want to00:05:18
to put together a little bit of everything that we are00:05:22
we went through this before and it’s like00:05:26
let's try it out a little bit00:05:30
it seems like there were a lot of topics and00:05:33
it seems like we talked about each other separately00:05:36
a lot of things, but I want this00:05:38
Today00:05:40
together And now you will have a week for this00:05:43
mastering So let me start right away00:05:48
right away, that is, I’ll expand the screen now00:05:55
So00:05:57
everything seems to be ready00:06:01
so I neck the screen00:06:06
yes yes yes yes this is our task00:06:12
the next ones will be for now, I'll remove you so they00:06:16
they weren’t embarrassed by it, as if on the next00:06:19
topics and now I would like to still00:06:23
I looked at it a little today00:06:25
analysis of homework and here's one task for me00:06:28
I was very confused and didn’t make it onto the recording00:06:32
code How I would like it to hit00:06:35
So now let's go straight00:06:38
I'll go here, open my homework and let's00:06:43
together we will write this code at the same time00:06:46
Let's remember what methods are and how they are all00:06:48
it's written like that and it confused me 1400:06:55
here she is00:06:58
and now we’ll try to write together00:07:02
I don't know, saw, didn't see, but I just00:07:06
when I went and copied the task like this00:07:09
now let's try to write together00:07:11
this code firstly let's see00:07:16
to the conditions of the problem That is, we have00:07:19
some expressions and some KLM parameters and00:07:24
look at our expression, that is, here00:07:27
you always have to look very carefully00:07:29
on what you need to print and what you00:07:33
need to be printed so here is ours00:07:36
expression they are almost identical00:07:39
each other, that is, absolutely identical00:07:42
according to00:07:43
and according to the actions that need to be displayed by00:07:47
results of actions that need to be taken00:07:49
display everything that seems different between us00:07:52
these are the parameters that is the name00:07:55
parameters and, as it were, accordingly00:07:58
the parameters that we will put into this method00:08:00
send and print but really to00:08:05
print each of these phrases We need00:08:08
only two parameters00:08:10
you see only two parameters at the same time00:08:13
it can be either Key or00:08:20
that is, these are just two parameters00:08:24
which00:08:26
work, that is, in which we must00:08:30
calculate the result of division and remainder00:08:34
So let's now make a method00:08:39
so that we already have it00:08:42
and as it were, we write methods in the house00:08:47
here I'll start writing here and there00:08:51
let's make a public by the way method for now00:08:54
all our methods were public Static howls00:08:58
then today that's what we will be00:09:02
do Let's call him there not00:09:05
I know00:09:07
lla principle It doesn’t matter what it’s called00:09:10
that is, the main thing for us is that KLM is here00:09:15
let's actions00:09:16
we will take some action00:09:18
performing actions is action00:09:23
And as we already said, actually for printing00:09:27
of each expression We only need two00:09:29
parameter and I think we had them there00:09:36
we do that is, we essentially00:09:39
needed00:09:40
one parameter and a parameter00:09:47
times two that is exactly the meaning00:09:55
By the way, I highly recommend that Java can do it00:09:58
check here showing through and on through and00:10:02
to naturally through and here and Yes too00:10:06
screw parameter 2 That is, we will have00:10:09
only two numeric parameters because00:10:11
in one sentence We only need two00:10:15
We don’t have a parameter to print it00:10:19
you need to put all phrases into one method00:10:22
because they are absolutely identical to us00:10:25
you need to print each phrase separately00:10:27
method 4 times So that's two times00:10:32
parameter but look at us in this phrase00:10:35
we still have to How would the name of these00:10:38
parameters prints that is, their value00:10:40
namely the name, that's why we'll do it00:10:44
two more parameters 300:10:46
and accordingly we will allow this00:10:50
there will be some take there was one00:10:57
and we’ll make the same string I believe 2 that is00:11:03
two names of parameters that00:11:06
we have to insert this into this phrase Well00:11:09
that's all, that's what it is00:11:11
will come to us at the entrance and what we need00:11:13
to print one phrase Here you go00:11:17
accordingly we need to divide the first00:11:20
parameter to the second Yes and count the remainder00:11:24
from dividing the first parameter by the second00:11:27
parameter Well, here's all we'll do00:11:30
do we will print our phrase not00:11:34
I always like to print like this00:11:36
because to me but these are purely mine00:11:38
preferences00:11:39
you can see better what's inside me00:11:43
Although I will repeat your future work again00:11:47
You won't be printing anything at all.00:11:50
today it’s as if we already have00:11:52
there will be a task00:11:55
Once upon a time, do your homework00:11:58
tests without printing the result00:12:01
and printing the result00:12:04
testing which is a little different but00:12:06
today we'll talk about it So that's it00:12:09
we will print here The first one is with us00:12:12
the result of division comes00:12:15
we actually do the division result00:12:18
next we have to insert the name00:12:21
first parameter00:12:26
Next we have the word on00:12:32
like this with two spaces so that00:12:36
everything was separated further the name of the second00:12:40
parameter and equal00:12:47
here And here we must insert the result00:12:50
I'll go straight to the new one here00:12:53
line means where we can get the result00:12:55
In principle, we can stick it right here00:12:59
calculation But we can00:13:02
and separately calculate that, but let me not00:13:07
I know, in principle, let's do it separately00:13:09
just to understand the result00:13:12
calculations we will have some00:13:14
parameter one Well, let's say division is y00:13:18
we have quotas00:13:30
big problems00:13:33
[music]00:13:34
That is, this is the result of division00:13:38
first parameter by 2 and required00:13:40
you need to divide exactly the first parameter00:13:43
which came on the second parameter00:13:47
This is exactly what we are00:13:52
paste it here and that's what it will be00:13:56
the result of dividing the first parameter by 200:13:59
whichever 1 2 came with whichever00:14:02
the names they came we will be just00:14:04
divide the first ones by the second ones00:14:07
account 1 which comes to the second method00:14:11
and accordingly the remainder of the division we00:14:15
let's do one more calculation00:14:17
[music]00:14:20
That's exactly the same way we do parameter 100:14:26
we'll be through00:14:30
percentage sign divided by parameter 2 and00:14:36
respectively00:14:38
here we inserted the result exactly00:14:41
division, that is, next we need00:14:44
insert this comma and actually00:14:48
that's right up to00:14:51
Ellipsis we need to insert the following00:14:55
I will insert the phrase on separate lines00:14:58
just like that00:15:01
let's do it so that00:15:04
two different phrases and accordingly00:15:12
so that's it, that's basically it, look at it00:15:18
that is, now our method will accept00:15:21
two clock parameters and accordingly00:15:23
two us bytes00:15:26
it will print both the title and00:15:30
the results of some calculations and00:15:33
this is actually his00:15:36
like a destination Here we are00:15:40
we call, that is, let us first00:15:43
Let's create some parameters, that is, Us00:15:46
you need the parameter kay Well, let's say 2000:15:49
parameter00:15:53
Let him be there 1000:15:56
parameter N or M00:16:01
here are our three parameters, come on00:16:05
let's make it five to make everything beautiful00:16:07
was So and accordingly we are now00:16:13
we print, that is, we call our method00:16:17
here he is00:16:19
and we hand over first from us we hand over00:16:23
options00:16:25
that is, we convey what lies00:16:28
the Key variable is what is in the variable00:16:32
Name00:16:36
and the name of the variable L is output here00:16:43
this is all to print and see what00:16:46
it turns out00:16:48
and we see the result of dividing kei by L00:16:51
is equal to 2 and the remainder of the division is 0 Well00:16:55
yes, in principle everything is correct then exactly00:16:58
so what do we need Kane there?00:17:02
call the same method you see like this00:17:05
as the action is the same we don’t need00:17:07
write as if there are many actions in one No00:17:10
one just call one four times and00:17:13
the same method that works with these00:17:16
actions and again I forgot what was there00:17:19
there was a movie, that is, we pass on what lies00:17:23
the variable Key is what the variable m lies in00:17:26
name kay and title00:17:31
and print00:17:35
So please see the answer, and00:17:40
accordingly, and so on. That is, he sat down00:17:42
on m that is, the idea is clear that we, as it were,00:17:47
need to00:17:48
lose our actions which we00:17:52
must be performed on such point00:17:55
small methods00:18:00
So call these methods many times00:18:05
so that we can complete some00:18:09
the same actions, well, and accordingly00:18:13
so we won’t print further then00:18:16
is there any on this part? Are there any00:18:18
questions00:18:19
turn on the microphone directly asks No00:18:23
all clear00:18:24
Yes, I just wanted it to be exactly like this00:18:27
a piece of the year was recorded so that you00:18:30
as if you saw that when we have00:18:33
absolutely the same actions00:18:35
repeated many times only change00:18:38
parameters let's see how many parameters there are in00:18:41
one action and, accordingly, all this00:18:44
we take out exactly in one small00:18:46
action and call it four times00:18:48
instead of writing a big method00:18:52
where the same thing is done four times00:18:55
we need to select small No it is00:18:58
always call it four times00:19:00
we prefer the small point method00:19:03
This is also correctly called a single00:19:05
press pants on the ticket, that is, single00:19:09
responsibility and that's if we have00:19:11
some action that is absolutely00:19:13
the same thing is done many times, here's how00:19:16
once this action takes out the method we00:19:20
we try to make a huge method00:19:22
which inside which will be very00:19:24
a lot of repeating things but in the future00:19:28
we'll be like the rest of the time00:19:32
we will only learn to work with that00:19:35
how to correctly render methods like00:19:38
correct how to design How00:19:40
that's right, this one00:19:42
responsibility to do that00:19:45
accordingly this is what ours will be about00:19:48
testing including project plus00:19:51
there are still some additional things00:19:54
So let's move on then if everything is clear00:19:57
If there are no Questions, Move on, that means00:20:02
Now00:20:03
let's move on to the presentation00:20:12
and today00:20:15
[music]00:20:18
went there Where is my presentation Here it is00:20:22
visible yes presentation00:20:26
today we will expand a little00:20:31
concepts of methods that is first00:20:33
theoretically then practically that is00:20:36
so far, as I said, we had methods00:20:39
All00:20:40
public Static your static is not for that00:20:44
so that we can then in the Main method00:20:47
call that is, we take it out as a method00:20:50
Main by the way means that they are starting00:20:53
they belong to some class00:20:57
I don’t know a certain object or there00:21:00
they are written simply inside the method00:21:03
inside the method there are other methods to write and00:21:07
it’s impossible, that is, we take them outside00:21:10
we and For this we need to do Static and00:21:13
then we can call them inside00:21:15
method so that they give us something00:21:18
calculated, that is, the word statics00:21:20
means that a method or variable00:21:23
belong to the public class word public00:21:28
this is a word that means that our method00:21:32
or the variable will be absolutely visible00:21:34
everywhere inside our project And as if from00:21:39
we'll talk about other options later00:21:41
while we are all doing no public00:21:43
we worry about it later00:21:46
let's use a different concept at least00:21:49
one thing and then we’ll see what else and00:21:55
the next word is public statics00:21:57
you already understand what public is00:21:59
so that you can see it everywhere Static is so00:22:02
the method began to belong to the class and00:22:06
so that we can call it inside00:22:08
execution method00:22:10
So now as for the word Voight00:22:15
now we are going to our presentation then00:22:20
there is this is our little plan Yeah well here we go00:22:22
we see that the method is some blocks of code up to00:22:27
which00:22:28
run when they just run that code00:22:32
inside which we write only then00:22:35
when we call this method That is00:22:38
while the method was written, we did not call it in00:22:41
method May it doesn't work at all This00:22:44
just a piece of code we wrote00:22:47
for future use but it doesn't00:22:50
doesn't work but as soon as we get it00:22:53
call inside the method we it starts00:22:55
work count there or do those00:22:59
actions that are written inside him00:23:02
this method This is how it will be in the future00:23:06
look almost always Our tests00:23:09
or ours it will be some kind of chain00:23:13
sequentially calling some00:23:15
methods, that is, mainly ours00:23:18
programs Our tests will look like00:23:20
exactly like this, that is, we will just00:23:23
call some methods sequentially00:23:26
to be00:23:27
solely responsible for implementation00:23:30
small actions and we will be these00:23:33
methods to collect00:23:34
our future code is like this00:23:38
Lego constructor when we string here00:23:42
these Lego blocks one on top of the other on top of the other00:23:45
and in the end we get some kind of figure00:23:48
or like the bricks that we customize00:23:51
one on top of the other and we get a house there00:23:55
that is, take out one brick of the whole house00:23:59
will also fall apart here as if to pull it out00:24:02
marks and in the end we won’t go as if00:24:05
there's nowhere else to go, so let's talk first00:24:08
a little about methods00:24:10
and now our task is to understand the difference00:24:13
between the word Voight and other words00:24:16
which can be in place of the word then00:24:19
there is a public page by the way, yes And now00:24:21
we'll talk about how there are such methods00:24:24
which00:24:26
they don’t return anything there is such a concept00:24:30
as if they don’t return any pouring here00:24:33
In Java this concept is denoted by the word00:24:37
howl and Until today we seem to00:24:41
spent a whole week writing the methods we have00:24:44
didn’t return any money, that is,00:24:48
all our methods were wars, they were nothing00:24:51
returned Why Because everything00:24:54
we simply printed the results inside00:24:57
the method itself, that is, we simply took00:25:00
some calculations and printed them again00:25:03
took some calculations and printed00:25:05
The maximum we could with this method00:25:08
let's say there is inside a method00:25:11
some value of the variable which00:25:13
visible from outside the method and then we called00:25:17
the value of this variable which we00:25:19
changed inside the method and accordingly we00:25:22
saw a new value and checked it but00:25:25
anyway, we have the method itself00:25:27
didn't return anything, that is, he just00:25:30
something inside believed he appropriated something new00:25:33
the value of another variable and, as it were, Everything00:25:36
that's where its function ended00:25:39
now we will study first00:25:42
distinguish between methods that are something00:25:44
returns methods that have nothing00:25:47
return and secondly how to write00:25:49
such a method that will already be something00:25:53
return So let's say we have00:25:56
some task to go to00:25:59
that is, this task is like a task00:26:03
from life we will try to divide into some00:26:06
methods and on certain parameters So00:26:09
let's let the back go to and we have, as it were,00:26:14
the parameter guests parameter is substituted in00:26:17
grandmothers are there to visit grandmother in the village00:26:20
and that is, something like this00:26:23
definition of this problem go to and here00:26:27
accordingly we can00:26:29
divide into some tasks then00:26:32
there are some small methods00:26:34
which we can highlight these methods00:26:38
will00:26:39
responsible for a certain part00:26:41
logic for example First we select00:26:45
the task of getting on the train00:26:48
get off the train Well at your destination00:26:55
stay at grandma's house with all my heart00:26:59
given there are pies, that’s another task and00:27:03
then we get on the train again and drive through those00:27:06
800 kilometers from home and we go to00:27:08
destination stations00:27:10
if please note that this is00:27:12
the task is absolutely identical to this task00:27:16
We're just going in the other direction, but we00:27:19
in the same way we get on the train and pass00:27:21
the same 800 kilometers and we leave How00:27:24
just getting to our station00:27:27
destinations That is and If we talk about00:27:31
symbol of the press card, that is, about00:27:34
single responsibility then we have00:27:36
the task is to get somewhere from somewhere00:27:40
and the task of visiting, that is, two different00:27:44
tasks that don't overlap00:27:46
with each other and, accordingly, these00:27:49
here are the tasks the first task is to get somewhere00:27:52
we call twice just change00:27:56
parameter that we are not going from point B A00:28:01
let's say we're going back already We're going from point B00:28:03
point, but at the same time we have the same00:28:07
the task is to change only the parameters00:28:10
Well, here’s the task of visiting, we call her00:28:13
once because yes we arrived00:28:15
stayed for a while and went back, it’s already bigger00:28:17
not at a party, but at home, let’s say further00:28:21
the same similar task to go on a visit00:28:24
we can let her in with her friends00:28:28
supplement with some other tasks00:28:31
in particular, look, we get into the car00:28:34
we drive 50 kilometers and get off at the point00:28:37
destinations next, we are guests at the dacha00:28:40
friends and get back into the car00:28:43
we drive quietly for 50 kilometers and get out00:28:45
but please note that we are on the train00:28:49
we were driving in a car, that is, the actions themselves00:28:53
we have absolutely identical, that is, the same00:28:57
the task is to board the train that we allocated00:29:00
here we can apply it here00:29:04
only with a different machine parameter like00:29:07
we call the vehicle00:29:10
So we travel another distance and00:29:13
accordingly, destinations can00:29:15
be different Yes, but the task itself remains00:29:18
one and the same, that is, we can definitely do it00:29:21
we can also reuse it only00:29:23
we must understand that we are different here00:29:26
parameters train car Here or there00:29:30
any kind of transport at all, that is00:29:32
here it is, it’s the same task, that is00:29:35
which takes parameters as input00:29:38
transport and distance Well, maybe still there00:29:41
points A and B are precisely defined from where00:29:45
we're going where we're going00:29:48
and accordingly the whole task is00:29:51
is that we are sitting down somewhere00:29:54
we drive the distance and leave our00:29:57
vehicle like this00:30:00
we will highlight the universal task in00:30:04
future00:30:05
that is, it is the task of life to go to00:30:09
some kind of transpo Here But exactly the same in00:30:13
in Java we will look for these00:30:16
small subtasks that we can00:30:18
use many times they are logical00:30:21
are responsible for only one action00:30:26
accordingly, these are the tasks we00:30:28
we will separate them into separate methods and00:30:31
we will call these methods a lot00:30:33
times Then inside the program only changing00:30:37
the parameters are exactly the same as us00:30:39
Now we have done this with our method00:30:41
here is the calculation of the remainder first, or rather00:30:45
first the division results and then00:30:47
remainder from division only with different00:30:49
parameters This was our task00:30:52
which was logically combined and00:30:57
was responsible for a specific unit00:31:00
responsibility we caused this task00:31:02
four times just changing the parameters00:31:05
variable name Exactly the same00:31:08
visit00:31:10
In what place and with what owners Yes it is00:31:13
maybe we're visiting grandma's village00:31:16
or let's say we're visiting friends' cottage00:31:19
or there is a sanatorium I don’t know from the owners00:31:23
We are also guests of this sanatorium00:31:25
even though we pay money, but this00:31:29
some kind of task to visit or00:31:31
to visit there to stand there in some00:31:34
place Yes, how we stood there, and00:31:37
accordingly we can highlight there00:31:39
separate for tasks, that is, to relax00:31:41
to eat we can put them in one00:31:45
We can take care of the common task separately00:31:47
there are still some actions to perform and00:31:50
separate methods for these small ones00:31:52
to the task Well, the main thing is to understand that00:31:55
the task of rest is different00:31:59
logically the task is to eat if we00:32:02
you need to somehow define it separately00:32:05
Let's say the task is to eat. Eat what's there.00:32:08
borscht or cutlets or eat there00:32:12
I don't know, some kind of grandma cake00:32:14
baked That is, accordingly this00:32:17
her other task may change00:32:19
we can separate the parameters into separate00:32:21
method but this task has nothing to do with00:32:25
another task which is to relax00:32:26
relax is more like taking a walk there Yes there00:32:29
sit somewhere I don't know relax00:32:32
sleep in the end, that is, and in00:32:36
in the end, we seem to be creating some kind of00:32:39
method We are going Yes and there We are transferring00:32:43
certain parameters that we00:32:45
generally needed to do everything00:32:47
action that is, please note the general00:32:50
a method that collects many small00:32:56
that is, the general method that we collect00:32:59
we have these little methods00:33:02
does not accept as parameters00:33:05
only those parameters that are needed for00:33:07
one task but all the parameters are00:33:10
needed for all the small subtasks inside00:33:13
this one big method, that is, we00:33:15
unite we do some we can00:33:18
combine our small methods into one00:33:21
a big method that will logically00:33:24
be responsible for some kind of general00:33:28
the task of how to arrive somewhere something there00:33:32
do it and go back, that is,00:33:35
accordingly, here you go, ours00:33:37
small task to travel which includes00:33:41
there are machine parameters and 80000:33:45
kilometers, let's say stay at home00:33:48
grandmothers go back to the car 80000:33:53
kilometers but the same general method00:33:56
We are traveling with the parameters, let's say the train00:34:00
thousands of kilometers00:34:03
Don't know00:34:05
what are distant relatives like, their home?00:34:09
and Here accordingly with these parameters00:34:11
we can already use it as if with00:34:15
by others for another task, a common one00:34:18
big but still small00:34:20
subtasks will be sorted out by these00:34:22
parameters that are needed for execution and00:34:26
will sort of fulfill their little00:34:28
actions at the right moment from above00:34:32
down from left to right in the code we have everything00:34:35
carried out that is, at the right moment They00:34:37
will launch execution of some kind00:34:40
subtasks this will take away under tasks00:34:44
parameters that are necessary and will00:34:47
perform this general action00:34:49
there's somewhere to go far there's something there00:34:52
go stay and come back00:34:54
back00:34:55
But this is such a slightly funny example00:34:59
there will be another funny thing in life now00:35:01
example, that is, an example of preparation00:35:03
sandwiches here Maybe we're like00:35:06
Let's understand more what the difference is exactly how00:35:09
not how we formulate methods, but00:35:13
exactly00:35:14
tasks that return something from tasks00:35:18
which return nothing So the recipe00:35:21
sandwich with sausage which is taken from00:35:23
Internet, here's even a link00:35:25
It turns out that people even have such recipes00:35:28
they write, well, and accordingly we have00:35:30
some ingredients bread one piece00:35:33
sausage one piece So there is something00:35:36
Description of action Take a piece of bread00:35:38
cut a piece of sausage, put the sausage00:35:41
ready for bread That is, this is real00:35:44
recipe from the internet let's try it00:35:47
translate into code Here, accordingly, we have00:35:50
there is some class00:35:52
we immediately remember that in general Now we00:35:56
can only write in class Here we are00:36:00
creating some kind of Layer where we will be00:36:02
create some methods and that's it00:36:05
accordingly, let's say there is a class there00:36:07
sandwich or eye make a sandwich everything00:36:10
depends on that there I don’t know what you are00:36:13
do Yes And look, there is a method00:36:17
take We take some ingredient Yes and00:36:21
actually Well, that is, we convey some00:36:23
ingredient in this method and that's it00:36:26
everything we do we take this00:36:28
ingredient inside this method00:36:31
went to the refrigerator and took the ingredient00:36:34
which is necessary00:36:35
applied to life, the method of cutting something off00:36:39
yes, let's say we send some kind of stuff there00:36:41
the ingredient is bread or sausage, it doesn’t matter And00:36:44
what's there? We cut, that is, not only do we00:36:47
we then took this ingredient and00:36:50
cut off a piece thanks to this00:36:53
cut further method00:36:55
guess that is, we take one00:36:58
cut off ingredient and place on another00:37:01
cut off ingredients as if yes00:37:04
depends on the order and the application of these00:37:08
ingredients00:37:10
Matroskin the cat would rather have that sandwich00:37:13
which is sausage down here But usually00:37:15
accepted like this, sausage side up00:37:17
fold but everything seems to be very strong00:37:20
it depends and in the end here we have00:37:24
some small subtasks that00:37:27
then we can use it for different00:37:30
ingredients in certain00:37:32
in a certain order and ultimately receive00:37:35
a specific sausage sandwich and here it is00:37:38
please let's make a sandwich with00:37:40
sausage is a certain general method that00:37:43
in the end it accepts let's say it's written that00:37:47
Yes, he still accepts entry00:37:49
ingredients bread sausage Yes and what we00:37:53
we do we take00:37:55
cut off the sausage and place the bread on00:37:59
sausage let's say we already have a piece of bread00:38:02
cut we don't need to cut it What if00:38:05
if we had to cut it, we would have done it twice00:38:07
let's say they would use it, well, take the bread00:38:11
cut off the bread take the sausage by the way too00:38:16
Yes, this piece was missed. Well, that is, If00:38:20
let's dig into the order of action then we00:38:22
we see that if we painted according to00:38:25
if all these actions are correct then we need00:38:27
there would be much more, that is, we should00:38:29
were Take bread take sausage cut00:38:33
bread cut off the sausage and put the bread on00:38:37
sausage or put sausage on bread00:38:40
depending on the order of the ingredients and00:38:43
what will we end up with if everyone00:38:46
one of us will now become his own00:38:48
the refrigerator will perform these actions we00:38:51
we get nothing more than normal00:38:53
Sausage sandwich if we take it00:38:56
real ingredients and let's go to00:38:59
real refrigerator that is us00:39:01
we'll get a sandwich with sausage00:39:03
Likewise we can get a sandwich00:39:06
with cheese only we will have others00:39:08
caviar sandwich ingredients please00:39:11
red black Yes Who has Which one00:39:14
I have it lying around in the fridge please00:39:15
let's get up Here we already00:39:18
there is no need to cut anything off, let's say00:39:21
Crimea is no longer cut out, we are not cut off00:39:23
yes yes but we can do it as a separate action00:39:27
create there take a spoon and put well00:39:31
let's measure out a spoonful of caviar, that is00:39:35
but accordingly, with different00:39:37
ingredients with some like this00:39:39
with small actions we get00:39:41
real sandwich with caviar00:39:44
here's a sandwich with jam, let's go too00:39:47
opening grandma's favorite jam and how00:39:50
would you like it with butter please?00:39:52
bread Yes, we just want it with jam in00:39:55
in general, who is salivating for something like this00:39:58
that is, here is the difference between the methods00:40:01
which return something and which00:40:03
nothing is returned in this case00:40:06
we take specific ingredients for something00:40:09
we create this and return the result00:40:13
what we did that is what we get00:40:16
specific sandwich and we return it00:40:19
result as concrete00:40:22
sandwich you can eat That's what00:40:26
different methods that do nothing00:40:30
they return with the word inside00:40:33
howl let's say read the recipe00:40:38
took and read the sandwich recipe00:40:41
would get a specific sandwich After00:40:43
reads No did not receive any00:40:46
the ingredients were not taken to the refrigerator00:40:49
got up We didn’t cut anything there00:40:51
No knife at each other00:40:54
added up that is, we just read00:40:56
recipe That is, but nothing00:40:58
happened on the one hand00:41:00
read-before-receive action occurred00:41:04
on the other hand, we have no new information00:41:07
got no result that is00:41:10
read read sandwich from this00:41:12
did not appear Or let's say the howl method00:41:15
look at the picture of the sandwich too00:41:19
Well, we looked at this picture.00:41:22
some action also happened00:41:23
watch our brain at the same time00:41:26
some information, that is, something there00:41:29
something has changed inside us somewhere, but00:41:32
but we don’t have a real sandwich00:41:36
it happened, that is, there was no action on00:41:38
production of some real00:41:40
sandwich and we don’t return it then00:41:43
there is no anything to return That's either there00:41:47
print the sandwich recipe is similar00:41:50
our sisa is not enough Print that is from that00:41:53
that we are printing some kind of recipe or00:41:56
we print what should be the result of this00:42:00
we'll get the recipe when it's here00:42:03
we don’t have the sandwich itself00:42:05
appears out of nowhere that is when00:42:08
we use System Of inside no then00:42:12
we don't return anything, that is, we don't00:42:15
we return some kind of pouring with which00:42:18
you can take it and continue to work with it here00:42:21
I'll pour this sandwich that we take and00:42:24
then we work with it, sit down and eat it00:42:26
so we get some kind of Well, I don’t know anymore00:42:30
the next product won't be so much00:42:33
how to clarify Which Well, that is, we00:42:36
took one product that we received in00:42:39
the result of one method was made00:42:42
there is something else with him and accordingly00:42:45
got some more product further here00:42:49
that is, in this case we are something00:42:51
we return and when we just print00:42:54
sandwich recipe as we wrote before00:42:57
methods and everything we printed as if there was nothing00:43:00
at the same time we don’t get Well, there’s something there00:43:03
they counted it, they just took it, they printed it out, but00:43:06
this something has gone nowhere, that is, she told us00:43:09
nothing produced anything here00:43:13
naturally all methods that do something00:43:16
print the result of the work these are methods00:43:18
Void here and here are the methods that return00:43:22
value as real or00:43:25
which we can then take there too00:43:27
some other method, for example a method00:43:30
we can eat a sandwich there00:43:32
pass there to this method eat00:43:34
our sandwich there is a specific sandwich with00:43:37
sausage as a parameter or there00:43:39
two sandwiches one with sausage one00:43:42
cheese as two parameters Here we go00:43:45
accordingly we were these then00:43:49
we can reuse for some00:43:51
other actions so this is the method00:43:54
which make a sandwich he returns00:43:57
specific sandwich or method there00:44:00
make with other ingredients00:44:02
he will also return the sandwich00:44:05
concrete sandwich And here are the methods00:44:09
which seemed to have done the result went to00:44:11
nowhere00:44:12
It’s as if nothing comes of it00:44:16
there was no pouring out to use we00:44:19
this or you then we can’t do it anywhere00:44:21
such methods use the word Void and how00:44:26
would that mean they don't refund00:44:28
no value again wrong00:44:31
talk a lot later in the future00:44:33
they will say that I myself sometimes00:44:35
I'm getting lost, it's howling, it's nothing00:44:38
returns no Java works like this00:44:41
that howl is the same thing he returns00:44:44
returns00:44:45
some kind of altered state that is00:44:48
our state before we read00:44:51
sandwich recipe and after we00:44:55
read the recipe it's not the same but00:44:59
our lives are no longer the same, we are gone00:45:02
at their point there they jumped onto00:45:04
some new stage of development, that is00:45:07
the state that was before is different00:45:10
state Something that was the meaning of that00:45:13
is inside this method anyway00:45:15
something happened but in This means that00:45:19
we do not return any money, that is00:45:22
that there is no pour out which we then00:45:24
we can pass it on and on with him00:45:27
somehow work, that is, in this00:45:29
the difference is that methods that are something00:45:32
return some kind of pour we can from00:45:35
take them away, I'll pour a new one and with it00:45:39
work further and methods that do not00:45:42
they return nothing or that is, we write00:45:44
they still change the word00:45:48
state something they return00:45:50
altered state but at the same time they are not00:45:53
they return no money and we can't00:45:55
methods with the word will be reused00:45:59
there let's say the next action is taken from00:46:01
them it was to use the following00:46:04
actions These are the examples so far from00:46:07
life Yes, but what we need to remember00:46:10
in relation to the code, this is what is in the underwear00:46:14
returning method that is a method that00:46:17
returns to some extent I'll pour it out here00:46:20
just like that Well, here it is from the JAVA documentation00:46:23
yes, that is, it’s just some kind of method00:46:26
which returns some kind of pour out00:46:28
there it is called Welly returning00:46:30
Non value Return method That is, it's all00:46:35
it returns something, it's just not00:46:38
I’ll pour it out. That is, it’s not some kind of you or00:46:40
which can then be reused00:46:42
I don’t know the meaning of the state00:46:46
which can be used there some00:46:49
a set of some values That is, but00:46:52
he's flying out00:46:54
a method is a method that does not return00:46:59
this is what you need to remember like, well00:47:02
as if in relation to the future00:47:04
these are important concepts for interviews00:47:07
So yes, they speak Russian very often00:47:11
that they are not there does not return anything00:47:13
we write Void but this is not true, that is00:47:15
after all, this is Non belurittering That is00:47:18
it returns something, you need to remember00:47:21
because in English there is no such thing00:47:23
they say it always returns nothing00:47:25
they say it's non-bye00:47:28
here you go, and accordingly, here you go again00:47:32
for comparison, that is, the method This is new00:47:35
or Cherning method That is, it returns00:47:38
changed state but it doesn't return00:47:40
dust and the method that returns00:47:43
I'll pour this sandwich or not And that's it00:47:47
returns the sandwich and in Java in the code we00:47:50
so we’ll write something like Return00:47:53
I'll pour it out which we can later00:47:55
use for other methods or there00:47:58
for other actions or where we00:48:00
we can also print, but already00:48:03
I’ll pour it as a separate one and not just like this00:48:06
here we print we print and it’s gone00:48:10
to nowhere In the end because the method is nothing00:48:13
didn’t return it So that’s how it will all be00:48:17
in practice it is written in code that is, we00:48:20
we already know the public Static will be we wrote00:48:22
Well, Static is not a necessary word.00:48:26
that is, in our case, the words Static00:48:29
it is very necessary that we can use this method00:48:32
call in the Main method in the same00:48:34
class but in the future we have the word Static00:48:37
will not always be needed more often not necessary then00:48:41
there are only in certain cases we00:48:43
we'll make a method by the way, so here's the method00:48:46
maybe just a public thing but also a method00:48:49
maybe it’s not even public, it’s just a howl00:48:52
Then simply instead of the word public there will be00:48:56
default value about this is needed00:48:59
speak Well, that is, we can write00:49:01
just the Void method without any public00:49:03
By the way, Well, in this case, While We00:49:07
worked with public methods by the way for us00:49:09
it was necessary already starting I hope00:49:12
that today we will get to the Big Topic Well00:49:15
that is, it’s like it’s not like that with us00:49:17
we must definitely pass00:49:19
So it is advisable to familiarize yourself with00:49:24
this topic and we'll see how it goes00:49:27
Well, as the lesson progresses, so we can00:49:31
this new theme is easy to use00:49:33
public will be methods without a word by the way00:49:36
because we will have different conditions00:49:39
but according to how they are written00:49:42
methods, that is, we do some kind of00:49:45
we use the word that is, particular XS00:49:49
this is how access to if we write Public00:49:53
then this means that this method or00:49:55
variable we can have public what00:49:58
this is a variable they will be visible on00:50:01
throughout the project from any00:50:03
class from anywhere, that is, they will00:50:07
visible because they are not visible to the public00:50:09
open access we will talk about this later00:50:12
we'll talk in more detail for now00:50:14
just need to remember the word public00:50:16
further This is Treten Tai That is, he00:50:21
exactly Return Type if it’s a novella00:50:24
returning we always write the word howl if00:50:28
the method will return something then we00:50:31
we will write the data type that this00:50:34
the method returns in this example00:50:37
us method returns data type00:50:39
it can return any type, that's it00:50:43
data types that we know method can00:50:46
return if we need this00:50:49
the method returned some data type00:50:52
please we write that this is the method00:50:55
which will return this data type00:50:58
now for the best we'll see further00:51:01
Each method must have00:51:04
name and must be returing00:51:07
Type in this case it can be non-value00:51:10
lapped or value Return Type But here00:51:14
these are two required parameters for00:51:17
method, that is, the method can be either00:51:19
Voight and some name or some00:51:23
data type and name but without these00:51:26
we cannot write two parameters in00:51:29
method here, and accordingly we can00:51:33
brackets or pass some00:51:35
parameters one several Here either00:51:39
do not pass any parameters either00:51:41
We already have such methods00:51:45
without parameters but but the main thing is that00:51:49
we must indicate these brackets, that is00:51:52
required things to create a method00:51:54
this is to write little rivers this is to write this00:51:59
name of the method and put round00:52:01
parentheses Well, let it be Yes, well, plus as00:52:05
we always say that there is a method00:52:07
there is a badi body which is curly00:52:10
we write in brackets that is, inside00:52:13
of this body we write some code that00:52:15
this method will execute that is00:52:19
in principle an example of a method here is also an example00:52:22
a method that does not have the word public or00:52:25
there is another word, that is, there will be access00:52:29
determined by default we're talking about it00:52:32
we'll talk later but at the same time00:52:34
The return type must be specified in00:52:37
in this case the method name is Total there00:52:40
some kind00:52:41
is calculated there is a parameter and Number well00:52:46
and accordingly some00:52:48
value this value is returned and so on00:52:51
what is the meaning of this00:52:54
this is actually the data type But00:52:57
here we write we are returning it00:53:00
the value in the method in practice it will be00:53:03
it's more clear just showing you00:53:05
presentation Yes00:53:08
on the previous slide please Yes00:53:12
in the lower right corner of this squares00:53:16
it appears that this is one of the methods00:53:18
example00:53:23
may be a parameter00:53:31
this is the return type this is not a parameter this00:53:35
returned as we are here here00:53:38
they said that we have methods that00:53:40
return to Ilya and methods that are not00:53:44
they return like this if the method returns00:53:47
value We definitely have to be here00:53:51
indicate what data type this method is00:53:54
will return00:53:56
Yes, this is not a parameter, this is a data type00:54:00
which method will return javi is00:54:03
a little bit like I would say not at00:54:07
that place is written in other languages00:54:10
written to me in a little different place00:54:13
for example, it’s easier to perceive differently00:54:15
But this is Java. This is how we will learn00:54:18
understand but now in practice it will be00:54:21
more clear That is, while I'm talking00:54:23
in words, perhaps many things are incomprehensible00:54:26
The main thing is to understand that the parameter is what00:54:28
written in parentheses next to the method And this is00:54:32
These are not parameters This is the return type00:54:35
data00:54:36
further00:54:38
and then further in parentheses00:54:41
we can there and Navy and recruitment00:54:46
to whom we transfer00:54:48
internal with which in the method we will00:54:51
work, that is, this is exactly the parameter00:54:54
Naturally, yes, the parameter is different here00:54:57
type and we pass it inside the method but00:55:01
At the same time, this is what we think In the end00:55:04
Yes, we took some parameter in00:55:06
this particular method just to it00:55:08
10 added and put in some00:55:11
I'll add a variable and this is the variable we have00:55:14
has a data type and we want to return that00:55:17
what happened as a result of calculations and00:55:20
because what happened as a result00:55:23
calculation has a data type and we have it00:55:27
we return this data type to the method00:55:30
we write here before the name of the method00:55:33
but now in practice it will be more00:55:35
It's clearer than when I'm like a fairy tale00:55:38
they tell00:55:40
It’s completely unclear yes What’s here00:55:43
it's happening now we'll just see it00:55:46
I show you presentations so that you00:55:48
they definitely opened it and looked at it00:55:50
these are definitely the words we will00:55:53
write for us now the word public we00:55:56
we will use mandatory everywhere00:55:58
the word further here in the green square we00:56:02
will write00:56:03
return data type and everyone has one00:56:06
method may be your own and also if we00:56:10
We do not accept parameters at all as input00:56:12
it is certain that in the end we will00:56:14
return them that is, this is the data type00:56:17
parameters does not depend at all on00:56:20
the type of data that we return00:56:22
because always Here we write00:56:25
depending on what we write after00:56:28
the words Return and the methods that return00:56:31
must have the word Return00:56:34
in our body, too, in practice, we are all of this00:56:39
we'll see better, but how about you00:56:42
when we were looking for tips on how to00:56:45
methods are compiled, do not forget about00:56:47
went to the presentation and saw what00:56:50
each method must have00:56:52
Return Type method name next00:56:56
public we will be like a beginner00:56:58
it is always necessary to register00:57:01
understand that this word exists Even00:57:03
if we don't write it it's still there00:57:05
some word exists, we just use it00:57:08
we don’t see the parameter sheet further00:57:12
we can pass parameters, that is, to00:57:15
round brackets and accordingly00:57:18
By the way, Hindu style of writing code00:57:20
when these curly braces00:57:22
they write as if not the way we write here00:57:26
here and they write here here but we don’t00:57:30
we teach this style just here are the pictures in00:57:34
Yes, you come across such people on the Internet because00:57:36
mostly materials and Indians everywhere00:57:40
Well, what if you see something like this? No00:57:43
be scared, yes this is so Indian00:57:46
style writing of the year so yeah And here it is00:57:50
here we have just these curly00:57:52
in parentheses the body of the Body of META method and00:57:56
accordingly, here we write our code and00:57:59
We must write the word Return if ours00:58:02
the method returns something, some kind of pour and00:58:05
this is the type of guy we are00:58:08
return or type ex which we00:58:11
we return dependencies on actions00:58:13
should be written here further00:58:16
what I wanted to say is that today you still have00:58:19
there will be an additional topic for00:58:22
studying is class00:58:25
now we will go to the documentation about00:58:27
let's look at this Plast literally00:58:30
I don’t know, let’s look superficially but00:58:33
at home you will definitely need this00:58:37
link open documentation for the class00:58:40
learn the techniques the way you did it with00:58:44
other reference classes, that is00:58:46
where you have a capital letter00:58:49
in the same way you will need to Study00:58:52
plastic and you will have several00:58:56
well, these are links to Oracle documentation00:59:00
but you will have several videos for00:59:04
class to study the class these videos are for you00:59:08
will help to study, as it were, methods00:59:10
class and there will be two short videos on00:59:14
five minutes for those who Well, in general00:59:15
there is no time and in general it’s not like that00:59:18
Everyone already knows Here are 4 more detailed ones00:59:21
video, that is, in my opinion I’m already there for sure00:59:25
I don’t remember. According to me there is part of the video on00:59:28
English part is in Russian but still00:59:30
I highly recommend it even if the video00:59:32
completely in English you are nothing at all00:59:34
don't understand anyway look because00:59:37
that a cat is a cat Yes, he is a cat in Africa00:59:40
That is, you will still see here00:59:42
as there00:59:43
the man who shows it all00:59:46
Shows some method some Method00:59:49
how it works in this class Well, that's a plus00:59:52
documentation plus a lot of experiments00:59:55
home with your code That is what you have00:59:59
there will be a lot of homework to use01:00:01
class methods because we have it01:00:03
This is a topic for self-study01:00:06
that is, there is nothing complicated there, just01:00:08
I would like to work with you more01:00:10
the documentation was again collected together01:00:13
this is kind of the concept that we have01:00:16
there is a built-in Java class and01:00:20
this class has methods and these methods01:00:23
may be static, that is, we them01:00:25
call from the class itself Let's go01:00:28
Let's look at the documentation, that is, well, yes01:00:31
traditionally the last part will contain the code01:00:34
term on the last slide so far here as01:00:37
if there was no link that's all from the presentation01:00:40
as you saw, our topic seems to be very01:00:42
little one let's go to the documentation01:00:45
let's see where the class We are in the package hierarchy01:00:49
javalaning01:00:51
putting together everything we've learned01:00:53
Previously, the code of the Java language is very similar to01:00:58
the cat that we ourselves write that he is01:01:01
is divided into some packages in particular01:01:04
Right now we're mostly working with the package01:01:07
Java lang which contains the main01:01:10
Java language built-in classes and what we01:01:14
getting like ours this Jay is wild01:01:17
which we then use01:01:19
we can call Java language classes and01:01:26
use them as if we ourselves01:01:28
they wrote that they are available to us from anywhere01:01:31
our custom code, that is01:01:34
we create some of our own classes01:01:36
packages but at the same time what already comes with01:01:40
Java language is available to us everywhere we can01:01:43
use and here we are for example01:01:45
studied some reference type01:01:49
classes01:01:51
we haven't studied much yet, but we already know01:01:54
that such data types exist and they01:01:57
nothing more than just classes01:02:00
built into the Java language if they are with01:02:03
big capital letter is written remember01:02:06
that the reference data type is stored01:02:08
differently and so that we create by creating01:02:11
we create a reference type variable01:02:14
object of this reference class01:02:18
like and here you go, exactly the same01:02:20
there is a MS class in the javal language01:02:26
package01:02:29
here it is also inherited directly from01:02:33
class which is the most important for us01:02:35
Class, if we see in the hierarchy then01:02:39
there is one main class in the package01:02:42
tailbone you inherit everything from it01:02:46
the rest are these classes and what do they do01:02:48
can be inherited directly like01:02:50
for example, cool, it comes directly from01:02:54
object of research, that is, he01:02:57
a direct child of the general class, but they can01:03:00
be inherited through other classes like01:03:03
for example these data types01:03:04
are inherited through the Number class and that is01:03:08
the Number class also has some of its own01:03:11
methods and accordingly they fall01:03:13
directly as if available directly here01:03:16
this class because they are inherited01:03:19
from this class let's say the class cannot01:03:22
see the methods of the Number class because01:03:25
they are full siblings brother sister01:03:28
but they do not inherit from each other but01:03:32
they can both see what is written in01:03:35
class both can use so yes01:03:39
there are such pains deep hierarchies01:03:42
inheritance is how we see here and there01:03:46
as if everything very much depends on01:03:48
why do they belong that is, what do they01:03:52
obtained as DNA01:03:54
inheritance wealth inheritance They01:03:57
get that but back to class01:04:01
mes That is, it is directly inherited from01:04:04
forehead class That is, he is straight01:04:06
child Here and accordingly here01:04:10
You can read the description of this class then01:04:12
there is basically its purpose01:04:16
be used for some01:04:18
mathematical calculations and we see that01:04:21
here are the fields of this class, let’s remember that01:04:25
Previously we saw class fields that01:04:27
calculated the minimum01:04:30
value the maximum value of this01:04:32
data type but for the MS Fields class it is01:04:36
such a number and a mathematical constant and01:04:40
the number of a couple is also in Russian We01:04:44
used to it Yes, but in English the number is here01:04:47
this is three dot 14 and this is 2.9 That is01:04:53
these are two mathematical ones01:04:55
constants you can read about them01:04:58
somewhere on Wikipedia again01:05:00
remember your school knowledge, that is01:05:03
refresh what they ultimately mean so01:05:06
these are the MS class fields these are these two01:05:08
constants, that is, from the MS class we always01:05:12
we can call the most accurate01:05:15
value programming framework01:05:18
constants constants and then01:05:23
MS class almost all methods now01:05:28
I check everything or not everything just in case01:05:32
yes It turns out that absolutely everything01:05:36
absolutely all methods As you can see They01:05:40
static, that is, this means that everything01:05:43
methods of this class are called from the very01:05:45
class, that is, to call the method not01:05:48
you need to create a class object like ours01:05:51
let's say in a class for example01:05:56
we had some methods static01:05:59
we remember Yes, for example, static A01:06:02
This method, for example, is not static01:06:05
it had to be called from an object01:06:08
class to create an object we wrote01:06:10
integer capitalized and equal to New01:06:16
integer capitalized in brackets01:06:18
I’ll pour some kind of Yes, let’s say they passed it on01:06:21
there is to call these methods01:06:23
who didn't have a word by the way at the beginning01:06:26
we needed to create a class object01:06:29
so that we can call the let's method01:06:33
But some methods we could simply01:06:36
write the name of the class integer put01:06:39
point and we have already seen these methods here01:06:43
accordingly let's say01:06:44
method01:06:48
remember We used him for homework he01:06:51
we were called from the integer class because01:06:54
that he belongs to the class therefore01:06:57
we called the class itself the integer class and we01:07:01
may have already seen this method But so01:07:03
use the comperte method for us first01:07:06
I had to create some kind of variable01:07:09
type integer and remember that01:07:12
variable of type intege with a capital letter01:07:14
It is always an object, that is, through a word01:07:16
New even if we don't have to01:07:18
it doesn't matter if you write a word somewhere01:07:21
there on the subcortex of our move it is01:07:23
the object is registered and created. So01:07:26
then we had to call01:07:28
let's allow this variable and put01:07:31
point and then we could see this one01:07:34
let's allow a method because it doesn't have01:07:38
words Static in front That is, he is not01:07:41
static does not belong to a class and01:07:44
accordingly, we seemed to have seen this01:07:47
method only calling the object01:07:50
mine could have been called and also Pay01:07:54
Please note that these are the ones you look at01:07:56
here are the icons and well, or rather the int byte types are there01:08:00
I don’t know double Bulin these are just the types01:08:05
data that these methods return01:08:09
that is, we have these methods01:08:12
I'll pour out the return ones, but maybe we01:08:16
we'll be lucky and we'll see some method01:08:19
which returns will be that is01:08:21
does not return any pouring no to us01:08:24
lucky here we see only data types01:08:26
we also see that the method is allowed01:08:29
can return primitive data type01:08:32
some method but at the same time different01:08:35
the method returns an integer but with a large one01:08:38
letters that is the reference data type That01:08:41
there are all types of data that we studied01:08:43
earlier we can write methods that01:08:46
return there all data types that01:08:49
we already know but so back to01:08:52
class in class just so much01:08:56
static methods That is, all these methods01:08:59
we can only call from the MS class01:09:01
But we don’t need to create an object either01:09:05
for this class to call the method but01:09:09
we see that each of the methods is also01:09:12
Almost everyone doesn't know for sure right now01:09:15
Let's look through the list But that's all that's on01:09:19
on this page each of the methods01:09:20
returns some kind of pour which then01:09:24
we can take it from this method and somewhere01:09:27
there to be reused here today we are01:09:30
let's practice a little with the class in01:09:32
mostly this will be your homework01:09:34
study class methods Yes and I see no01:09:38
Do we have some method here that01:09:40
returns the fight Well, that is, I won’t pour it out, but01:09:43
just an altered state, too, no01:09:46
We're lucky, I don't see a method that01:09:49
there were just some types of data everywhere01:09:52
Here01:09:55
for example, crowbar That is and But today we01:10:00
We will write with you the following methods in principle01:10:03
Voight You and I have already learned to write that01:10:06
there is, well, when we print something but01:10:09
no spillage is formed01:10:11
Right now, without going far01:10:14
let's move on yeah01:10:24
on this site, basically you should already01:10:28
be able to find It's me just like that01:10:31
hint now off Let's01:10:34
throwing off01:10:36
not to include chat but in principle01:10:40
Watch the previous lessons because01:10:43
we've already gone through this all the right way01:10:46
looking for everything is an important skill to find01:10:50
documentation01:10:52
I'm trying to find a link to a presentation01:10:55
she is present at one of the presentations01:10:59
is already in the presentation of which we already01:11:01
gave01:11:07
3 lessons if01:11:24
really needed for today01:11:26
now during the lesson she says this to you01:11:28
I don’t really need it, but I encourage everyone01:11:30
work with presentations and search01:11:33
documentation yourself because01:11:35
you really, really need this at work01:11:37
it will be that means And now we are going I will01:11:43
share back01:11:47
you can ask too, yes, but tell me for01:11:51
the homework we just did A01:11:53
it was also possible there then01:11:54
use in some cases which01:11:58
there is a clock I want to do and now I’m already01:12:02
said without moving far from the cash register01:12:04
let's take this fresh method01:12:07
which we just wrote and how01:12:10
you already saw the method itself in homework01:12:12
there is nothing complicated, we wrote it like this01:12:15
so that we are printed with the value Yes but with01:12:20
this we had a howl and that is, no01:12:23
didn't receive01:12:25
That is, how to understand that this is the method of combat and01:12:28
that we can’t reuse later01:12:31
what we formed here inside01:12:34
some line Yes, that is, we01:12:37
essentially formed some kind of string from01:12:39
some values and we straight this line01:12:43
we printed the method itself like this01:12:45
look if I call in the Main method01:12:54
and here I will pass this our method01:13:00
and pass some parameters01:13:06
I still need it there01:13:15
and forgot to eat and pass on01:13:18
some parameters01:13:20
I do you see I have problems I can’t01:13:24
print01:13:26
the result of this method01:13:29
that is, this method does nothing01:13:33
returns Java prompts me immediately01:13:35
compiler, well, it’s not here at all01:13:39
knows what's going on and is trying to help me01:13:41
just force the arguments into a separate one01:13:43
fold the line but in reality this is a mistake01:13:46
happens because Method with Kayla01:13:49
action it doesn’t return anything for me01:13:53
there is, it does not return or rather exactly that01:13:56
I have this method, so I01:13:58
I can’t put it in another method01:14:01
use the result that he had01:14:04
let's say produced01:14:05
here in another method the microphone is on01:14:09
If you want to ask a question, ask01:14:12
if not, it turns off. Now we’ll write01:14:15
Exactly the same method, I'm just watching it01:14:18
I take it and copy everything absolutely the same01:14:22
do01:14:28
he will be absolutely the same only01:14:30
look I won't print the result01:14:33
work and I01:14:35
I'll take it and create some here01:14:39
Stream variable01:14:44
That is, well, let’s call it01:14:47
cut That is, this is what I want in the end01:14:50
get some string that01:14:53
brings together my text and my01:14:56
parameters values I put a dot here01:14:59
comma and look now I'll write what I01:15:05
I want to return this one using my own method01:15:09
result01:15:12
accordingly, I have it underlined here01:15:15
in red because it says here that01:15:17
the howl doesn’t come back, no howling A01:15:20
here I wrote down what I want to return01:15:22
this is the result in the form of a string like01:15:25
the result of this method: Here it is01:15:28
accordingly, since I have the result01:15:32
has a data type then I just take it and here it is01:15:35
here instead of the word exhibition please01:15:39
this method is starting to bring me back01:15:42
I will display the data type Stream That is01:15:50
I can use it later and01:15:54
look what else I wanted to do now01:15:57
yes, that is, in my title it’s01:16:00
when nothing comes back just01:16:02
it's being printed and here I am01:16:07
Action files Let me remove one01:16:11
because that's the same name01:16:12
because this is the method I use01:16:14
will return some result01:16:17
some of these klmagends that will01:16:20
there to gather in one line and this one01:16:24
the method will return this string and01:16:26
Now look how one is no different01:16:29
method from another can because this01:16:33
the method will be And I can’t print it01:16:35
the result is because it is inside me01:16:38
as if nothing comes back But01:16:40
now I write myself and call another01:16:44
the method I have01:16:48
and here I pass the same parameters01:16:52
in the previous01:16:54
previous line and look I launch01:17:00
and I'm getting the same thing now01:17:03
wait a second, this is me for cognition01:17:07
so that it doesn't bother us because it's01:17:10
We printed it using a different method. So01:17:14
look I get the same one01:17:16
a line with parameters Key L like me and01:17:20
conveyed Yes, only now this line is01:17:24
I am not printed inside the method, it is01:17:27
me is formed inside the method and she has01:17:30
me comes back and Dante's type01:17:34
meanings I put here and now I01:17:38
I can use this method there in any01:17:41
Well, that is, I now have this method01:17:44
automatically equal to some string here01:17:47
see what this means01:17:49
that I'll take some kind of Stream01:17:56
let's say there is a variable there01:18:01
and I can assign the result of the work to her01:18:05
that method01:18:09
which returns something That is, I take01:18:12
method I pass parameters to it01:18:19
[music]01:18:20
and here is the result of this method:01:18:24
I can add a variable01:18:27
you see because this method returns01:18:30
data type Stream and this and how01:18:34
the result of the fact that this method is inside01:18:37
does himself so as to have this result01:18:40
this spin I can just add01:18:42
variable Stream or I can here01:18:45
print using System Of because01:18:48
that I have some kind of you as a result01:18:51
this method works and I pass it on01:18:54
method01:18:55
I have some kind of you like Stream and me01:19:00
I can add it up to a variable theme, that is01:19:03
my method in this case is some kind01:19:05
already as it were01:19:07
that is, some text exactly like Stream01:19:11
because it returns data type01:19:15
also If you are allowed01:19:21
Let's create some method01:19:28
let's say we have some kind of01:19:31
return value and let's say01:19:34
let's call it double01:19:40
That is, he will accept01:19:45
Here01:19:47
Let's say01:19:49
because he will receive from me01:19:52
some parameter01:19:54
let's say we remember some specific parameter01:19:59
that the name of the parameter in the method does not matter01:20:01
what matters is what type of data. That is, it will be01:20:03
take some number and01:20:06
here let's say I write what their prize is01:20:12
who will take this number and01:20:15
multiply it by 2 That is, it will be like01:20:18
would be a double in which he took that is01:20:22
double the value Here I have01:20:27
here it is underlined in red Because01:20:30
if I write here that the method should01:20:32
return before the method name if I01:20:35
I write that it should return a data type01:20:38
then it is not necessary to register01:20:41
the words Return and write what this method is01:20:44
will return she will return me01:20:46
will be This Rizal Rezal has the type01:20:50
data01:20:53
matches Yes and accordingly, if I01:20:58
now I’ll take my new method and write01:21:02
sout yes, that is, inside this method I01:21:06
I don’t print anything anywhere, but this method is01:21:09
it brings back some intrigue to me01:21:13
here let's say I'll just pass the number01:21:18
So this is the method01:21:22
takes this number and according to the data inside itself01:21:26
he will double this number That is, I expect01:21:28
get 12 and this is 12 this method does not01:21:33
the system will return another method01:21:37
will take the number 12 and print it out01:21:46
Yes please print 12 exactly the same01:21:50
I can take some kind of variable01:21:54
let it be and put the result in it01:21:59
my method works from the number 601:22:05
So, accordingly, if I now01:22:08
I'll print out the variable01:22:13
what will I get01:22:17
12 Yes, because I have this method as01:22:22
would calculate something within himself01:22:26
the output from this method will be 12 this is 1201:22:30
will be assigned to variable B and when I will01:22:33
print variable runout01:22:38
That is, the variable itself is, as it were,01:22:41
she didn't do anything, she just took it01:22:43
the result of the method which01:22:46
returns to them We see that Yes I received01:22:49
12 twice this is my variable And this is y01:22:54
me when I was typing myself and him01:22:57
result01:22:59
Are there any questions regarding this part?01:23:04
if we have two methods one is cleaned01:23:08
some meaning other other we them01:23:11
we can add each other01:23:13
it's just through01:23:16
we need to add the variables Or we can do it directly01:23:18
write let's do it01:23:24
one more method01:23:39
So let's call it three half-values01:23:44
we'll arrange01:23:47
we’ll also have some kind of variable there01:23:50
get it here we will triple it01:23:53
click on 3 and return the result too01:23:57
only this will return in some number01:24:00
it will already be01:24:02
that is, multiplied by 3 Let's check01:24:06
that this method works01:24:16
print out the result we are waiting for01:24:18
Get 15 we got it because01:24:22
by 3 inside the method Finally returns01:24:25
result 15 which we can01:24:27
print via command01:24:31
but we can make some variable01:24:35
let's say01:24:36
myself01:24:38
variable itself And what can we do We01:24:42
take the W method01:24:45
from 6 we add trippy01:24:50
That is, we see that we actually01:24:53
adding up the results of our own work01:24:55
methods and let us print it ourselves01:25:10
and we get 27 because 12 before01:25:14
halfvalue returns method 15 return01:25:18
three sexual 12 plus 15 is 27 that is We01:25:22
we produce ordinary mathematical01:25:25
actions because due to the fact that these01:25:28
methods returns some kind of pour them already01:25:31
as if mentally you can just not even01:25:34
consider methods Because if they01:25:36
return something accordingly We01:25:39
we work with these01:25:41
just like if we returned here01:25:44
some kind of Stream method, we’ll allow it01:25:47
could have been there01:25:50
with the result of the work, let's take01:25:54
the same method just different01:25:56
parameters and we want01:25:59
we will no longer have arithmetic01:26:03
addition is already01:26:09
Well, let’s say here we make the parameter m01:26:12
and we will see that is and now if I01:26:16
I'll print out the text01:26:22
I comment And here I will print it here01:26:25
the very text that I take from01:26:30
constancy of two calls to one and01:26:33
the same method only with different01:26:35
parameters and01:26:39
inserted here01:26:42
I print and look at the result, that is01:26:45
here I have the result here when I01:26:49
this system printed01:26:52
call one method call with01:26:55
Cale's parameters01:26:58
And here we see me as if double01:27:01
one line stuck to another01:27:04
because this patination of two01:27:08
results and this method is given to me01:27:12
This is the result01:27:16
Here we see absolutely the same And here01:27:19
this method gives me this result01:27:24
I sort of concentrated them together01:27:28
is when we have two Street variables01:27:31
then we just have 1 variable01:27:33
stick another one01:27:37
space to do this on purpose01:27:41
so you can see that it's just me01:27:43
the second part stuck to the first because01:27:46
that the result is of the Stream type and in this01:27:50
case plus is valid01:27:53
It's clear01:27:56
yes Tell me if there is one method01:27:59
Well, hypothetically some task01:28:01
there is one method we did which01:28:03
returns Stream and another method we have01:28:06
returns, let's say, a number Well, it doesn't matter01:28:08
we need to add them up we Well, it’s clear that01:28:11
we need to create some kind of variable01:28:17
but first, tell me if I will01:28:20
let's say01:28:29
and print some value that I01:28:32
I'll get it01:28:37
yes that is I will get it01:28:40
Stankotenated texts with meanings That01:28:43
there is I can't add Stream and value01:28:46
that is, in this case Add it means01:28:53
because if we are the first to allow01:28:57
we print Street then according to this01:28:59
mathematical operations will not continue01:29:02
will be easy to produce01:29:04
the first text will have a value added01:29:09
just like we would do this01:29:13
through the method but again accordingly01:29:22
let's make one text01:29:25
and let's add here what we get, let's say01:29:30
as a result of this method working like this01:29:33
how he returns Stream01:29:35
and as a result of this method:01:29:39
since he gives them back01:29:43
we’ll get the text for it in exactly the same way01:29:46
the sticky meaning is close that is01:29:53
and I print this text alone01:29:58
and correspondingly01:30:04
I receive some text to him01:30:07
sticky value 1201:30:10
just like here some text to01:30:13
values attached to it number numbers01:30:18
Well, that is, everything is the same as in01:30:21
ordinary01:30:22
actions are the same as what you do01:30:25
with regular texts and numbers you can01:30:28
do with the results of the methods01:30:32
Because if the methods return01:30:35
some kind of data type then all the rest01:30:38
rules for these methods apply01:30:41
absolutely the same as for ordinary numbers01:30:44
or text That is, everything is the same with01:30:47
In this case, our methods can return something like01:30:51
any type of data we wanted01:30:58
any type of data we want01:31:01
so that they return Here But with methods01:31:04
accordingly you can do nothing about it01:31:06
you can't because the method doesn't return01:31:10
no pour out so everything that happens01:31:12
inside the howl method it’s as if she’s not going anywhere01:31:16
goes that is, if we are here01:31:19
let's write that there will be some kind of variable01:31:21
Stream also let's call her cut01:31:27
let's write equal01:31:29
and just like in another method we do this01:31:33
did01:31:35
let's put a comma, you see absolutely01:31:38
the same as in this method but no01:31:41
the words Return and if this method01:31:45
nothing comes back here01:31:47
returns meaning no meaning01:31:50
comes back but that is this01:31:53
variable cutter us anyway01:31:55
only we will form it in such a way01:32:02
Because if there's nothing here01:32:05
returns as if this is all the action01:32:07
but it goes in vain because it’s here01:32:11
it’s not even printed, that is, here we are at all01:32:14
nothing seems to happen but at the same time01:32:16
the program did something01:32:19
formed a string01:32:21
and let’s say if I’m this one now01:32:25
method trying to print01:32:29
and you try01:32:32
because he doesn't have anything to me01:32:35
return01:32:40
That is, and look at me all at once01:32:43
this is emphasized and I have nothing to do with it01:32:46
I can’t do it Now there will be an error01:32:49
here we have Voight and that he is not allowed01:32:54
here inside the Print Land method01:32:57
because the Land printer needs something01:33:00
do get some text and01:33:03
print it here but like this one01:33:06
method does not return anything01:33:09
the team doesn't know what to do01:33:11
in the same way I can’t create01:33:16
Stream variable is acceptable01:33:22
was not there and assign the result of the work to her01:33:25
this method01:33:30
with all the parameters I can't assign01:33:34
Why Because here you go please01:33:36
They say that Print is actually nothing for us01:33:39
does not return Make it so that he01:33:42
returned Stream and then you can01:33:44
assign the result For now it is nothing01:33:47
returns something here I don’t seem to have01:33:49
I'll pour it out and I'm trying to appropriate it01:33:52
variables of type Stream That is, if01:33:55
here I could easily assign01:33:58
because something was coming back01:34:01
or just appropriated it now01:34:04
let's just say variable text01:34:06
appropriated it too01:34:11
or maybe I was typing because01:34:14
came back Stream then here I am nothing01:34:18
I can’t do it with this method and01:34:21
I must say that methods01:34:23
minority because they are very rare01:34:27
generally needed so that if there is something there01:34:29
produced internally and considering that01:34:32
programming testing we do nothing01:34:34
we don’t print but very rarely seem to be needed01:34:37
methods that have nothing inside themselves01:34:39
They don’t produce it, but they change it01:34:43
state01:34:45
We'll talk later about what they're for01:34:48
Testing is especially needed, but somehow01:34:51
We ourselves will very rarely write01:34:54
methods that do not return01:34:56
we have basically all methods01:34:59
will return for some time Therefore01:35:02
Yes, today we have such a topic that01:35:05
learn to use them01:35:06
respectively01:35:09
we can't do anything01:35:16
variable that is returned to01:35:19
second and when we connect them at01:35:21
execution from one method is not01:35:24
transferred to another Regardless01:35:25
there are no conflicts that arise01:35:28
specifically do you mean01:35:33
Where do we describe01:35:36
the method itself01:35:38
Return cut01:35:41
everything that is written inside the method01:35:45
exists only inside this method01:35:48
method remember skok remember we01:35:51
they said that this method is inside itself01:35:54
does not see this variable in any way, just like01:35:57
this method is inside itself this one01:36:00
does not see the variable inside the method01:36:03
we can name the variables whatever we want01:36:06
repeat the name as many times as you like01:36:08
the same but as if they were written01:36:12
Here in these01:36:14
the variables we created are three01:36:16
pump variables they are not visible at all01:36:19
to another No, this is when they are completely different01:36:23
method completely different year and they are each other01:36:26
they don’t see a friend so no01:36:29
doesn't happen here because it's two01:36:32
independent from each other and they are in01:36:35
There is such a concept in different brackets01:36:41
stop that is And01:36:44
these ospreys separate one code from01:36:48
another01:36:50
that is, these names they can be01:36:52
whatever they want, but they don’t see each other01:36:55
these two pieces of the move have nothing to do with each other01:36:58
doesn't work but if we want01:37:01
let's go to this method to create01:37:05
another variable01:37:10
This is a dead method for us that is not01:37:13
returns no but Let's say01:37:16
let's take and assign the result of the work here01:37:20
this01:37:23
and take some parameters that Well01:37:27
we can't take it like, well, we can01:37:29
work only with those parameters01:37:31
who come to us exactly at this time01:37:34
method I take then parameters 1 parameter01:37:37
201:37:39
further than 3 there was one because the parameters01:37:43
absolutely the same what's for this01:37:45
method that for this type of parameters01:37:47
exactly the same so I can01:37:50
use the parameters of this method to01:37:53
transfers01:37:54
and if I do this, then this01:37:58
variable cut get what will do01:38:02
this is the method with this01:38:07
but I think it's still a little difficult01:38:10
for beginners' understanding, let's01:38:13
let's dwell on what we are in general01:38:15
let's learn how to write these methods because you01:38:18
It’s like you’re running a little further, but then01:38:21
what you need to understand exactly is what01:38:23
inside one method Whatever variables01:38:26
you didn't create so that you wouldn't be with them01:38:28
did another no01:38:31
this is what happens inside one01:38:33
method the other method will not see But if you01:38:36
inside one method you call another01:38:39
the method is natural at the time of the call01:38:42
this method works and will01:38:45
if not, it returns something01:38:48
accordingly you can use01:38:50
inside another method now we01:38:52
Let's try to do this on other tasks01:38:55
because this is not a very good example01:38:57
in order to work with this01:38:59
here are some other questions about01:39:03
return on the topic of return01:39:07
or we’ll try to interfere with the problems01:39:10
return Can I ask this question?01:39:13
if we have a variable in a method in brackets01:39:16
let's denote the type float And the method itself is type01:39:18
int then it will just give us an integer01:39:22
without this remainder01:39:25
It depends on what code you have inside01:39:28
you prescribe, we don’t just take from01:39:31
[ __ ], some data types are acceptable if01:39:35
we need to create some method01:39:43
but let's say As you said this method01:39:46
will return some01:39:50
we will say that we will accept01:39:52
variable of type Flow I also have the name01:39:56
I came up with just writing down your task01:39:59
According to you, the experimental task in general01:40:02
all experiments are just yours, as it were01:40:06
students' responsibility at home with everyone01:40:09
experiment with these things but01:40:11
Let's take a look now, that is01:40:13
some variable like Flow will come and01:40:16
what are we actually going to do with her?01:40:18
do it and then return the result, what are you doing?01:40:22
what is our scenario with this variable01:40:25
Flow what we will do Let's say01:40:27
how we were able to find speedvage that is01:40:31
we take distances there. Okay then for us01:40:35
need variable distance01:40:40
it will just be here, that is, we are not01:40:43
we write methods just like that, we have all the methods01:40:46
are written for something so that they do something01:40:49
did01:40:55
that's what we're doing, we'll01:41:00
count01:41:09
This is what we need inside01:41:12
we need to do some result then01:41:16
there is if we are going to it exactly in01:41:18
we write this same one to return01:41:23
that is, here we will add what I01:41:27
meant that if the variable fruit01:41:29
That is, you do the actions completely01:41:36
And by the way, guys, I also saw that01:41:39
everyone used Flow, remember that01:41:43
we were just learning what a variable is01:41:46
exists we never seem to be in progress01:41:49
This01:41:50
problem solving because we do everything01:41:54
we forget01:41:56
what is Always exists But this type01:42:00
the data is deceased, so we won’t even talk about it01:42:03
nothing to do I saw Dan parsing01:42:06
a lot of people use homework but01:42:09
Remember I told you that we are just01:42:12
studied and used exactly within the framework01:42:15
one homework to find out01:42:18
this is an extinct data he has absolutely no data for us01:42:21
needed for calculations and what we will do01:42:24
only in Double, so we forget the word and01:42:28
Let's say two variables of type arrived01:42:30
But Time is usually not in Double01:42:34
denote Well, okay, let it come and01:42:37
Let's say we take this distance of ours01:42:40
who came home01:42:42
let's share mine01:42:45
we divide it into time which also01:42:49
it's arrived01:42:50
and so that we get all this result01:42:52
it is considered that we need a result01:42:56
calculations wrap01:42:58
so that we have it in the end01:43:02
this is how we wrap it is also called01:43:05
that's right And here we are, we got it01:43:08
some result of the division we have01:43:12
will be calculated accordingly01:43:23
That is, we are returning him. He is with us.01:43:26
data type the method will return itself01:43:30
this method will return the type01:43:32
data and Let us assume this average01:43:35
we want some other speed there01:43:37
increase the average speed, that is01:43:40
Let's call this method twice from different01:43:42
values that is and accordingly01:43:45
Let's say what we have01:43:49
some kind of Total01:43:51
I don't know why we need it, but it's just01:43:54
already a task that does not have01:43:57
relationship to real life01:43:59
we will have and we call one01:44:03
no who thinks01:44:07
distances01:44:10
point 4501:44:15
245 will read and let's say I have time01:44:19
I don't know there01:44:22
And now I therefore want to add01:44:27
accordingly another result01:44:31
and let's say I think it's 12 o'clock01:44:56
That is, I will01:44:59
275 is two hours three quarters to 2 and 301:45:03
quarter of an hour so I want to add it up01:45:06
what this method returned it returns the type01:45:10
data with the fact that I returned this method01:45:13
I add it all up somehow01:45:15
and accordingly I think I’ll print it out01:45:24
that is, the main thing is that Yes, I have parameters01:45:28
data types come Double but at the same time01:45:31
the methods themselves return them and like this01:45:34
I didn’t manage to check the total01:45:37
I will Correct Wrong most likely01:45:39
that's right, we just divide the disk by time01:45:41
yes we get it01:45:43
That's it, but accordingly the main thing is that I have01:45:47
this method returns01:45:50
that is, the value in the type accordingly01:45:54
the sum of two points is mine01:45:59
got some result data type01:46:02
which we convey there is absolutely no way01:46:05
does not depend on the type of data it is01:46:08
the method may ultimately return But everyone01:46:12
method we are not just there I don’t know from the sky01:46:15
they took and wanted each some type01:46:19
data create each method are created01:46:21
for a specific task01:46:24
accordingly Let's now move on to01:46:26
parts where we will interfere with the task01:46:28
in which we need, let's say, some types01:46:31
data and we will return some kind01:46:34
data type First we have easy problems01:46:36
let's interfere, but no matter how each method01:46:41
is created Just like that it is created for01:46:43
performing a specific task and01:46:46
accordingly depending on what01:46:48
we have to do in this method and for01:46:51
why is it being created in our country?01:46:53
look at what parameters we need in01:46:56
such and such data type and we return01:46:58
we will already have such and such data for you01:47:00
because this method should be valid01:47:02
return a different data type01:47:06
meanings But it all depends on what01:47:08
What exactly do we need this method for?01:47:11
There are still questions about this part01:47:16
let's still get to the task01:47:19
we're going somewhere else now01:47:21
because it’s like we’re already starting in the wrong place01:47:24
think about it, let's decide01:47:26
some specific tasks Now I01:47:28
just doing that's how I'll take it01:47:31
[music]01:47:36
such puzzles are stored up01:47:39
since we started the lesson with this task01:47:42
This is actually the code I'll give you here:01:47:46
I'm writing here Let's01:47:53
so I'm putting some here01:47:59
I have 2 lessons, let's say 201:48:05
I don't have time to write your code after you01:48:10
Sorry, yes, but still we have a task to01:48:13
listen more in class than write01:48:15
that's right And now we will have three of these01:48:20
I think there are three or four problems here01:48:24
which we need to solve today and01:48:26
then it will seem like we will have time01:48:29
go to parts 3 or not, well01:48:31
accordingly, I’ll take it here too01:48:34
to01:48:39
real solutions to real problems01:48:42
This means that first we will do yes01:48:48
let's get straight to this problem01:48:50
this is where you need to test it01:48:52
there is what you need for your home01:48:55
work in part 1 homework here you go01:48:59
and accordingly We will take Let's say01:49:01
such a problem Find the maximum01:49:04
value between variables01:49:10
and we start testing the work of ours with01:49:14
very easy methods we don't go there01:49:16
far01:49:19
and Let's write some methods then01:49:23
there we divide the task into task and01:49:25
First we will find the maximum value01:49:27
between some two variables and Well01:49:31
let's say we have them01:49:34
that is, we write01:49:38
[music]01:49:41
we will have him back01:49:44
the maximum value of the two That is01:49:48
if we have both values then in the method01:49:51
will come01:49:55
while this and B then respectively01:50:04
Here's the type accordingly01:50:07
we will return something01:50:10
Here we need01:50:12
because between two variables01:50:15
data types01:50:17
the maximum will be one of them01:50:19
accordingly, also a data type because01:50:22
that we won’t actually do anything01:50:24
Except that we will choose which one01:50:26
more this or this and accordingly01:50:29
Which one is bigger?01:50:31
Well, let's say we call our method01:50:35
starting with the verb01:50:40
and here01:50:46
the maximum of the two because we have01:50:49
there will then be a maximum of three01:50:51
the maximum of 4 is for these sub-tasks01:50:54
That is, we write this method01:50:57
Well, let's help both of us01:51:00
find more meanings what do we need for this01:51:05
need to do01:51:06
compare compare01:51:14
This is how we write them, that is, I don’t just tell you01:51:17
so I ask you at the interview too01:51:20
may also ask: Should you How?01:51:22
would answer That's accordingly what's with it01:51:26
we compare01:51:28
yes, that is, we say what if and more01:51:32
what do we do01:51:37
let's deduce01:51:39
No01:51:41
maximum value value01:51:47
we can create some kind of intermediate01:51:51
maximum value01:51:53
and then we will say that Max01:51:59
Yes, otherwise, if you don’t stay with us01:52:05
Max equals B01:52:08
Otherwise we will say that Max is equal to Binet and01:52:13
accordingly, so that he can do the same for us later01:52:17
I need to return this01:52:23
let's check our method01:52:30
they won't necessarily be there then01:52:37
Wait or if we have more than B01:52:41
Do you mean that it may be01:52:44
equal Okay, let's make this condition01:52:46
that is in this case if Hey more01:52:50
or equal to B then well, they are the same01:52:54
we don't care which one we return01:52:56
we will say that Max is equal to her yes And if y01:53:01
there are no more of us than equipoise, that is01:53:05
less then accordingly01:53:08
we do that is, it is equal to good01:53:12
remark because they can be01:53:14
are equal but as if on the algorithm itself it is01:53:17
it doesn’t influence us, that is, they set us up Well01:53:21
so we got something like this01:53:23
method that will find01:53:25
the maximum value of the two and by01:53:28
old habit for all beginners01:53:30
it was more clear We'll just print it out01:53:34
the meaning of this method That is, I I take01:53:38
system01:53:39
and we had a method there it was called So01:53:44
here Let's pass any two numbers01:53:48
Which01:53:49
501:53:52
and 901:53:54
Well, let’s print accordingly01:53:58
meaning that is, we do not print inside01:54:02
method we print when we are apart01:54:05
write a command01:54:08
and there we write our method inside01:54:12
which returns some value01:54:15
the maximum of the two, we see that the method01:54:18
worked correctly And here you go01:54:21
we printed the result here01:54:25
now let's talk about this part to everyone01:54:29
everything is clear why01:54:37
33 Let's check 33 essentially what01:54:41
we expect to receive01:54:43
3 Yes, so we take our method01:54:49
So, accordingly, we transfer 33 there01:54:53
could create separate variables for them01:54:56
assign some value but we are straight01:54:58
these were here We transfer everything on principle01:55:01
it’s as if they immediately conveyed that01:55:03
create variables and Yes we get 301:55:06
the method works here01:55:15
what is the maximum value between 301:55:18
Irina turns out to always be published01:55:21
only a01:55:23
Why01:55:25
let's make it so01:55:29
that is, we will take the value that01:55:34
we allow01:55:36
no here by the way if it was before 9 9 what at 301:55:42
will always only come out01:55:44
they are equal, what is the difference in conditions then01:55:49
they are equal to ours there is no condition to withdraw01:55:52
variable name01:56:00
Who cares which one we will be01:56:02
call01:56:12
For01:56:14
We will check the purity of the experiment so that 9501:56:17
Yes And you see we have equal 901:56:34
or there Regardless and more beat bi01:56:37
more he still thinks more like01:56:41
would print more but not01:56:44
outputs the method does not output anything to01:56:46
print it returns the larger value01:56:48
we're printing mine. Now let's go with01:56:52
with help01:56:53
we will write a method of the MS class exactly like this01:56:58
same method01:57:00
I'll copy it to waste time but only01:57:03
with number 1 we will have exactly the same01:57:06
come 2 variables and trouble but here it is01:57:12
Here01:57:13
look, we will call the Ness class and have it01:57:17
there is a Max method01:57:20
which will already be between the two01:57:22
variables consider the maximum01:57:25
this is the value it will return01:57:27
the value of the type that is from it from01:57:31
class places I call the Max method there I01:57:35
I pass what comes to my method01:57:37
exists01:57:39
it's called a rapper when I'm alone already01:57:44
I wrap an existing method in another01:57:46
your method, that is, essentially01:57:49
this operation makes no sense because01:57:52
that such a method already exists built in01:57:55
language and how to wrap it in your own method01:57:59
there is no point because why should I01:58:03
as if to wrap one in two wrappers and01:58:06
the same candy, that is, it’s just wrappers01:58:09
some resources01:58:12
environmentally friendly not clean let's say that is01:58:16
accordingly I just took another one01:58:19
wrapper and chair in another wrapper01:58:23
existing that candy, that is, that code01:58:26
which is in this Max method then01:58:30
there is when I write my Max method01:58:32
it's Okay because I'm doing my own01:58:36
the algorithm may for some reason tell me01:58:39
The algorithm of this method does not suit me01:58:42
I just want to create a layer for which01:58:44
there will be a slightly different algorithm OK I am01:58:47
I do, but how would I take one method and01:58:51
wrap it in another wrapper01:58:54
let's use blue wrappers to make red ones01:58:57
this is from the point of view01:58:59
there is no point in programming01:59:01
So yes we can do this to01:59:04
just check that yes we do too01:59:06
you can do it even though it is pointless and01:59:09
let's say Now we do01:59:13
and here We transfer our method but only01:59:17
number one at the end which is from Max01:59:20
will work and let's say exactly the same01:59:23
let's do 5 901:59:26
print it out and expect we will receive 9 and we01:59:30
we get exactly 9 And what is this method01:59:33
will print if all of its own are equal01:59:36
interesting three01:59:38
Let's check01:59:40
we compare, we output one thing, and that is, we01:59:43
we logically conclude that B means01:59:46
less we don’t know which one but it means01:59:48
less But probably logically it should have01:59:52
this is the conclusion of our method in general01:59:56
I don't draw any conclusions. He doesn't.01:59:59
says what it means02:00:02
he just says that if she has more02:00:05
or it is equal, then we will assume that02:00:08
and maximum otherwise if not more02:00:12
what is equal then we will assume that02:00:16
we do not make a conclusion in this method02:00:18
different things maximum02:00:25
this is 3 and 3 is not the maximum value02:00:28
why does it not correspond to the task from02:00:31
we cannot choose the maximum of two numbers02:00:34
so we just take whatever I pour02:00:37
Maybe there will be 150 of these numbers and in them02:00:40
there will be several triples and we’ll like these02:00:44
threes will be the maximum in any case02:00:47
the rest will be less than 302:00:49
accordingly you still have to02:00:51
choose 3 Correct Because Despite02:00:54
because we have a lot of threes, we came02:00:57
equals maximum02:01:00
and all the rest let's assume numbers are less02:01:03
than 3 Here But we still need02:01:05
output some maximum result02:01:07
comparisons and how in this case not02:01:10
go this way that both meanings02:01:13
that's all equal and I really feel that02:01:16
the gag on this is that they are equal it is not02:01:19
means that we cannot choose the maximum02:01:21
from them we simply take either one or the other02:01:24
the other one doesn't matter to us, they don't care02:01:26
simultaneously maximum simultaneously02:01:28
minimal at the same time they are equal between02:01:31
themselves That is, that they are equal This is02:01:34
means that they are simultaneously and maximum02:01:37
and minimum and02:01:40
understandable Yes, the task here is to deduce not and or B02:01:44
And the task is to derive some02:01:47
the value that is between them02:01:49
maximum Therefore, we don’t care what02:01:52
lead away Because if they are equal then02:01:55
any of them is both a maximum and02:01:58
the minimum is just that they are equal, but not02:02:01
go deeper into this direction you are leading away02:02:04
yourself a little out of place and how would you02:02:07
just put a stopper where there isn't one02:02:09
as if mathematical logically If two02:02:12
the expression is equal but there are two values02:02:15
are equal but you need to find the minimum02:02:17
at most they are at the same time02:02:20
minimums are also maximums at the same time02:02:23
if anyone came to us there02:02:25
average temperature02:02:27
some temperature values02:02:30
hospital and it just so happened that today02:02:32
all our patients have the same one there02:02:36
accurate to some sign02:02:39
temperature, that is, the probability is Very02:02:42
low but in principle it cannot be said that02:02:44
there is no such possibility02:02:47
let's say in 10 patients absolutely02:02:49
the same body temperature is not02:02:52
means that we cannot derive the minimum and02:02:54
maximum This means that today we have02:02:58
the minimum is equal to this temperature and02:03:00
the maximum is equal to this temperature and02:03:02
the hospital average is also equal to this02:03:05
the temperature is here and we'll let you come to us tomorrow02:03:08
different temperatures arrived for someone there02:03:12
40 someone has 36 and accordingly 3602:03:17
there will be a minimum of 40 there will be a maximum tomorrow and02:03:21
we consider the average between everyone02:03:23
values we divide by the number of these02:03:25
values and output accordingly02:03:27
average for the hospital But as if02:03:31
suddenly it happened that they came absolutely02:03:33
same values probability low02:03:36
It may well be that's accordingly02:03:39
It's okay We have the same meaning02:03:41
We consider the minimum to be the maximum And, as it were,02:03:45
and we consider it average, so let's go here02:03:48
now let's look at this method02:03:51
which we wrote02:03:53
I want all of them and a little bit of him02:03:57
it is possible to improve the task a little02:04:01
grew up because the main thing is to write in general02:04:03
At least somehow you understand and so that this02:04:07
the method eventually gave you some02:04:09
the value you expected to get But02:04:13
I still want this method02:04:17
I copied it, I'll just put it here, I did it02:04:22
His02:04:26
look, I still want you to02:04:29
saw that this is the Max variable for us02:04:32
There is absolutely no need here Why Because02:04:36
what do you see if we compare and equal02:04:41
greater than or equal to B and we let02:04:44
we say that yes this is true or more02:04:47
or it will be equal to B then we just02:04:51
we can write right away02:04:55
otherwise we can immediately write02:05:04
then we don’t need this common letter02:05:07
We don't need extra variables02:05:10
and the method will do absolutely the same02:05:13
the most he did before but at the same time02:05:16
don't use extra memory02:05:20
he's just comparing02:05:24
if more then he returns immediately02:05:28
meaning02:05:29
and there is Otherwise, if not more than02:05:35
then it returns the value02:05:41
That is, if you still understand exactly02:05:44
like this through an additional variable02:05:46
write to us the main thing is to write but just for02:05:49
those who, for example, will immediately understand that02:05:52
no additional variable needed here02:05:54
that's how this option would be more02:05:57
optimal02:05:58
then it’s easier Yes, it’s easier, I agree02:06:02
just like let's say here we look02:06:05
did not create an additional variable02:06:08
let's say02:06:09
Max was not assigned02:06:14
we could do it like this02:06:19
and return fog but essentially it’s for us02:06:23
Max is absolutely not needed And by the way here02:06:25
Java actively swears She speaks online02:06:28
take it, that is, I clicked that before online02:06:31
and please, it’s easier to return it right away02:06:35
the value that we calculate using02:06:37
we don't need any other method02:06:40
intermediate triangular here now02:06:43
let's move on to testing02:06:46
then now we tested through02:06:49
That is, this is not called testing02:06:52
we just printed it like this and double-checked it02:06:56
so and not so, that is, during postponement02:06:59
programs Sometimes there is something there02:07:02
print especially some intermediate ones02:07:05
results Because if there is allowable02:07:07
something doesn't even come from somewhere02:07:10
sometimes it helps, that is, you have to02:07:12
print but in general We02:07:16
almost nowhere in the finished version02:07:18
no programs02:07:20
we won't use it, but now you and I02:07:23
let's go right here02:07:26
let's get here to the task in the port and02:07:30
here we will write methods like02:07:35
who will test our code but when02:07:38
this way they will not print the result as02:07:41
we wrote before that they won’t02:07:43
print test result02:07:48
[music]02:07:52
here it was a test Yes, here it was, as it were, me02:07:58
inside it printed the result for me02:08:01
checks And now we will not print02:08:04
check result and return02:08:06
check result Here and Here let's do what02:08:10
more correctly let's do it now02:08:12
let's do it, we'll write a Public method like this02:08:16
By the way02:08:18
and we will have the result of the check02:08:21
return I remember that for testing02:08:23
with us it’s either a pass or a floor02:08:25
that is, accordingly what type of data02:08:28
we will return02:08:32
we will return the string because we02:08:35
we will return either the word pass or02:08:38
word02:08:41
boolean this will be the result of comparison A02:08:44
based on the comparison result we02:08:47
Let's just conclude our test02:08:49
passed or failed and we will02:08:52
return either a pass or a file, that is02:08:55
accordingly, the data type. So let's call it02:08:58
this method02:09:04
Why are we so called in the future02:09:07
you will understand because it is very similar to02:09:10
Real testing of how02:09:12
our assertions will truly be02:09:15
look like this, that is, we'll call it like this02:09:18
this method02:09:19
and let's assume that it will receive as input02:09:22
it will get two results02:09:25
I remember during testing what02:09:27
results We are always among ourselves02:09:29
compare02:09:33
Yes we will compare02:09:36
just do it in reverse order02:09:39
The expert cut it off02:09:43
And02:09:48
The expert is this result which is ourselves02:09:51
ask Yes now I beg your pardon Here02:09:55
why don't I write the data type because02:09:59
The expert cut us off maybe somehow02:10:01
number accordingly and went knitting the number02:10:04
Yes, and we can compare it with each other02:10:07
maybe there are some lines I don’t know which02:10:11
we need to let each other have a method02:10:14
there are some lines being formed and we need02:10:16
compare that it was formed exactly like this02:10:19
the string we wanted to form and02:10:22
then we will have them because we02:10:25
now we are doing we will use02:10:28
polymorphism Let's use this method while we02:10:31
let's do it02:10:34
forget polymorphism while we do this02:10:37
it's as if02:10:40
gets exactly02:10:45
and what will he do he will02:10:49
compare them to each other what if02:10:53
The expert cut it off02:10:55
equals action-cut02:10:59
then he will have something to return02:11:07
pass is correct to give because it is02:11:11
the test gives a conclusion or the test passed02:11:14
either he fell over, that is, he will02:11:17
return words02:11:20
Here and accordingly Otherwise if the Expert02:11:25
cut off is not equal to Action it will be02:11:29
return the word02:11:38
That is what we have In the end, as we see02:11:42
We do without intermediate02:11:44
variables That is, something immediately02:11:46
return inside02:11:48
and we get a method that02:11:52
upon receipt, experts hit the hall02:11:56
some exactly the same one he will be02:11:59
compare these two values and02:12:02
give some conclusion the test passed02:12:05
or didn't pass also let's have some more02:12:08
let's make this method additional02:12:11
auxiliary02:12:13
which we will just have it02:12:18
let's do that is, there is no return02:12:21
he won’t, but he will publish poetry with us02:12:27
that is, now we are all our own02:12:30
tasks02:12:31
starting from today we will count02:12:34
test cases, that is, some tasks02:12:38
or there is a history user But we’ll talk about that later02:12:40
haven't talked much yet, but I hope you02:12:43
already understand these concepts, that is, from02:12:46
lessons and theory of what is what02:12:50
history but let's assume that here we are02:12:53
create some code to02:12:56
us some kind of test case we Then could02:12:58
test And accordingly we02:13:01
Let's test this code by running02:13:07
Yes And here we will create a variable02:13:12
let's make Static so that she02:13:15
the whole class just owned it02:13:18
us part 2 I don't want to divide into02:13:20
Different classes, that is, this code we02:13:22
let's leave it in the form it was But02:13:25
usually if you wrote all this by02:13:28
That's right, here's the variable02:13:30
Static should be here02:13:33
because first we announce everything02:13:36
variable and only then we create02:13:38
methods but since we have the first part as02:13:42
whatever the code does not depend on the second part02:13:44
so just consider it like this02:13:46
new class but we have an old one Here we go02:13:50
let's say we're some kind02:13:58
and Let's say we have it by the way02:14:05
will02:14:08
Let's say we make one02:14:11
and this one02:14:15
what will this method do?02:14:18
does not accept parameters02:14:21
and he will just print02:14:25
and through print02:14:28
look then you will see Why after 302:14:31
it will print02:14:34
let's say02:14:38
underlining How to denote conventions02:14:41
and this is our set of poems02:14:45
so that next time it will be printed02:14:48
you think that is And now I'll take it02:14:52
this method02:14:55
I'll call you here like this No, you know what02:14:59
I'll add with a plus sign I'll add02:15:06
let's use the tabs02:15:11
so now I want to immediately bring beauty02:15:15
through02:15:16
Tab like this02:15:18
space bar02:15:20
one more so this is just for beauty02:15:25
so that we can print a quiet set later02:15:28
the result and look what we are now02:15:32
now we will do all our results02:15:34
We will do our homework here02:15:36
in this way, that is, here I go02:15:39
here in this our code which I have here02:15:42
there was part 2 and we forget about these symptoms02:15:48
Let's comment in general so that he02:15:51
didn't interfere with us02:15:53
we don't need him now02:15:57
so we forget about the purely small ones no longer02:16:01
working system02:16:03
And what are we doing? I'm now calling02:16:09
method for now I have it just print it out02:16:16
And here I will enter it here02:16:19
the result of my testing and here it is02:16:23
let's say how I will check now02:16:25
your own algorithms your own tasks Let’s say02:16:28
change everything One because let's say02:16:30
again don't forget that now02:16:33
starts today you can02:16:35
have several cases per home02:16:38
task Because if you use02:16:42
different data you must compose02:16:45
different cases and let’s assume everything that02:16:48
we have now checked using System Of02:16:51
Print TV we will now check in our these02:16:54
methods that we created but only in02:16:57
form of testing and print02:16:59
the result and let’s say it’s not the first02:17:01
case I will set a variable and02:17:07
which I have is 502:17:10
I'll check the same thing further02:17:14
I set a variable that is equal to 902:17:22
So I’ll ask some Expert cut off02:17:26
that is, my Expert cut it out02:17:30
these two variables02:17:33
What value do I expect to get Apparently02:17:36
maximum so I'm testing my method02:17:39
maximum02:17:43
accordingly what result do I expect02:17:46
get from these two values02:17:50
that is, this part is for each case02:17:56
almost automated with you02:17:58
We are now writing an automated test02:18:01
not yet in a special framework But for now02:18:04
on your own, so this part is in02:18:08
automated case is called02:18:12
parts that are responsible for arange02:18:18
and spells the English word which02:18:21
means02:18:23
announce02:18:24
install that is, declare all data02:18:29
which we know02:18:36
that is, this part of the case She usually02:18:39
allocated to a separate area02:18:41
the first one is recorded, that is, let's say this02:18:44
we have to do exactly like this02:18:48
there is such a mandatory rule02:18:51
now we’ll write it down like this02:18:54
there is this rule called Triple and02:18:56
rules02:18:58
for creating02:19:01
that is02:19:04
Let me write 3 in English anyway02:19:12
rule02:19:19
for creating02:19:21
automated And who02:19:26
[music]02:19:30
we already have this02:19:32
automated02:19:34
in the first and02:19:36
we write the data that we know02:19:40
that is, some test data that02:19:43
we ask and spectrum hall Expert cut off02:19:47
We should always know in advance02:19:50
how do we even launch our pelvis case?02:19:52
otherwise there is no point in checking anything If02:19:55
we don't know what we have to do in the end02:19:57
get that there are experts when they salvo us02:20:00
you should always find out in advance and clarify02:20:04
as if given more often we get02:20:08
such data needs to be tested02:20:11
we get more often from some kind of childbirth but02:20:15
sometimes we come up with it ourselves because02:20:17
if we understand what is in this case02:20:19
let's say there may be some02:20:22
such unpleasant situations Where is our02:20:25
program what to fall and our task how02:20:27
tester to come up with such02:20:29
unpleasant situations we check them as02:20:32
We would also test them, but in02:20:34
without fail we first02:20:37
We test the data that we were given and02:20:39
First we Test Happy Past scripts02:20:43
What is happy Pass PES is it like a way then02:20:46
there is a happy way What is happy02:20:49
Test scenario is when we get02:20:52
correct data and expect to receive02:20:54
the correct meaning is that here we are02:20:58
got the correct data02:21:00
it’s possible to compare Yes, nothing like that there02:21:03
they are not there, they are part of our area, that is02:21:06
there's nothing so scary about them And we02:21:08
We expect to receive some kind of Expert02:21:11
cut off which Yes is logical correctly in02:21:14
in this case in this case is called02:21:17
testing when we enter the correct ones02:21:20
We use the values for testing and wait02:21:23
get the correct logical result02:21:27
then why is this a program of its own?02:21:30
a program was written to determine02:21:32
the maximum between two numbers like this02:21:35
this is this is the first part of Range when we02:21:38
first we declare all the data that02:21:41
we know further in this arrived and02:21:44
pattern there is a second part02:21:47
and this part is called02:21:53
that is, in this part in the second part we02:21:57
must02:21:58
produce02:22:02
some actions02:22:07
let's call02:22:09
method or there for example Let's have one for now02:22:15
we just don’t know about the others yet02:22:17
for example call a method02:22:21
that is, we must produce some02:22:23
actions to receive02:22:27
Action cut that is02:22:36
Action result we get as a result02:22:40
work of our program02:22:44
So to get this we have to02:22:49
in this case we are the only ones to call02:22:52
while we are working with methods, that is, we02:22:54
should call this our method02:22:56
which we test and the result02:22:58
meaning of this method the result works02:23:01
he method we must As if appropriate02:23:04
result and accordingly we will make our02:23:09
second part We'll take the same02:23:16
variable and assign the result to it02:23:21
the work of the method and the method We have here, let’s say02:23:25
we take this find Max Out Of to02:23:28
which without numbers Don’t forget the whole numbers02:23:32
We have already created three methods and02:23:35
respectively within this methods02:23:37
We transmit our test data, that is02:23:40
variable02:23:44
variable02:23:48
we Test our method on our Test was02:23:51
there is what this method returns02:23:55
assign the variable Action vizal Here02:24:00
here we have performed some actions for02:24:03
receiving02:24:06
our part02:24:09
A302:24:10
it's a donkey02:24:16
Asser is an English word that02:24:20
means comparing the results and02:24:24
not just a comparison of results, but also02:24:28
conclude that we have this method02:24:31
works correctly or incorrectly ours02:24:34
the test passed or our test failed comparison02:24:49
and a02:24:52
how to say it correctly in Russian02:24:54
draw a conclusion and it’s not a matter of conclusion Of course02:24:58
you say and conclusion02:25:02
About02:25:04
passed the test02:25:07
or fell so this is tripolypata which02:25:13
stands out of three, as it were, and which02:25:15
stand for certain things02:25:18
necessarily components of each02:25:21
automated02:25:23
we will learn to write02:25:26
automated02:25:28
based on Triple and that is and we will02:25:32
always talk first let's do first02:25:35
then we do the second and third and that’s all A02:25:41
we actually compare the results02:25:43
happens in the method02:25:49
they created it themselves, that is,02:25:52
accordingly here in this method we02:25:54
we need to pass on ours, that is, look02:25:58
in what order are the parameters? We see that02:26:03
first we have to hand over the experts02:26:07
We take our Expert to the hall02:26:10
We take Action cut which we02:26:14
received as a result of the program02:26:16
experts we ourselves calculated in our minds and02:26:19
actually we are now02:26:22
print it out02:26:24
so what better way for us to do this?02:26:31
let's do this for02:26:33
convenience and for beauty, that is, it is necessary as02:26:38
my task would be for you to understand now02:26:41
lost the method02:26:44
my task is to make you understand that this02:26:47
the method should actually return something02:26:49
that is, no, he doesn’t print anything, he02:26:54
returns something Let's do it again02:26:57
let's do this additional one too no02:27:02
let's write he will also be Voight and he will be02:27:06
just print the result of our check02:27:10
A02:27:12
printest02:27:15
because you don't seem to wrap it up well02:27:21
so we'll just make a separate one02:27:24
method which ultimately02:27:28
will02:27:29
Okay, here it will be received02:27:32
I will pour some meaning, that is, with02:27:37
with help02:27:42
so he will print it, that is, he02:27:45
I'll just type02:27:48
accordingly as we print02:27:50
test results then we'll be here02:27:53
separately pass this verifyls but02:27:57
this is already like an auto test02:27:59
that is, it does not print veri files02:28:02
result let's say so we now02:28:04
We will also report testing02:28:07
there is some kind of report about02:28:10
performing our tests That is, this02:28:14
it is important to understand that here is an auxiliary02:28:16
meter print result it is no02:28:19
our test has nothing to do with the test02:28:23
this is the part02:28:24
I’ll write here that this is our author02:28:30
test02:28:32
and here it is02:28:34
this is the part02:28:39
more02:28:41
the report is our account02:28:48
That is, we are printing a report on02:28:52
running our test and what we will do02:28:56
we call this one02:28:59
and here We transmit the result of the work here02:29:03
this verification method02:29:06
but this is not testing, this is just printing02:29:10
result and testing is this02:29:13
the part where we kind of got a groove or02:29:16
file Here and accordingly Now if we02:29:21
Let's print this out all together here I am02:29:24
launched you see I have one case02:29:28
That is, let’s say in this form I can02:29:31
create02:29:34
let's create them now, that is, although02:29:37
would be for one method We are completely02:29:39
let's test all these values02:29:42
all values that should be fine02:29:45
processed without any problems02:29:48
Yes First we tested 59 now02:29:51
I'm creating02:29:53
That is, I had a report for the case02:29:58
one that he passed me now I create02:30:02
case 202:30:05
that's what I do, that is, I have02:30:08
variables AB and Expert cut off were already02:30:13
are specified earlier, that is, I just call02:30:17
mine and assign it the value 3 and call02:30:21
bi and assign it the value 302:30:25
I'm calling the experts02:30:28
this is just a meaning for me for something new02:30:31
testing for a new test just like02:30:35
I already had them announced, I don’t do it02:30:37
new changes use the old ones02:30:40
Expert result I expect to get 302:30:45
This is what I have02:30:47
Range part02:30:48
first now I do that is I again02:30:53
I call my variable which was earlier02:30:56
no longer existed and I re-entered it02:31:00
I call the method that I have Fine02:31:05
numbers and here I pass mine02:31:09
here and transfer my business to new ones02:31:12
values and thus02:31:15
I will have some maximum that02:31:19
I will be calculated thanks to the work of this02:31:21
no here But I expect to get something like this02:31:25
maximum before Misha I do the third one02:31:29
I call mine02:31:31
And02:31:34
my method Yes, and there I add the Spectrum02:31:40
Action cut and this method will compare for me02:31:44
Is my result equal to what I02:31:47
I expected to get the result that02:31:50
I have already received and as a result of comparison02:31:54
I will receive a conclusion: I passed the test or02:31:58
the test failed This is what I had02:32:01
testing, that is, is over. And now02:32:04
I'm reporting again02:32:06
just let me do it like this02:32:10
Remember I called here02:32:13
I called separately, let me direct him02:32:16
I'll put it in the report, I'll print the number and02:32:22
I am printing the result of the work Exactly here02:32:24
also i will print the number and result02:32:28
work already new new checks02:32:33
so now I’m typing this as if02:32:38
for the second02:32:40
Here I am02:32:42
the only thing needed was the system here02:32:44
write Let's go here where I am02:32:48
typed by Beri faikvels that is me02:32:51
I printed two values, but I have them02:32:54
top two results But I have them02:32:56
stuck and I need to go here where02:33:00
there I printed the test result here and02:33:04
here I'll just do it02:33:07
an additional empty line and then02:33:10
now I if I print it out then I have02:33:12
it will be like this02:33:14
I passed the first one02:33:18
[music]02:33:19
How to check that the test is valid02:33:21
works correctly who remembers from the past02:33:24
lesson02:33:26
what should I change to check?02:33:29
that the test really works ask02:33:31
wrong data02:33:33
if I change the crystal experts to02:33:37
some invalid one and will print it out02:33:40
my test 2 should fail correctly02:33:44
fell over02:33:45
So I really have something there02:33:48
it is considered not just as if it is deduced02:33:51
first value that comes up That is02:33:55
this is how I received reports about02:33:58
his work02:34:00
it's clear Here at this part Let's do it again02:34:03
let's write toskase 3 because we are still02:34:06
checked that we have more bi and02:34:09
checked when they are equal and now we02:34:11
we need to check what we have and more and02:34:15
here we are doing such and such a case02:34:19
and again we call our02:34:22
assign it a different value, let's say02:34:27
call B and assign it to it, let's say02:34:30
value 502:34:32
and the Expert untied we expect what02:34:36
get02:34:38
1002:34:41
this is what we did, that is, we set those02:34:45
data for our automated02:34:47
test that we already know Now we02:34:51
we do it that is, we don’t know what02:34:54
will calculate programs from these test ones02:34:56
data but we call our Action02:35:00
and here we assign02:35:05
the value that our method will return02:35:08
based on this02:35:13
from our test data and now we02:35:16
do the third part of the osser, call the method02:35:20
who makes Acer there We transmit02:35:24
The expert cut off what we asked ourselves02:35:26
We pass on the action cut what the program tells us02:35:30
calculated02:35:31
And now we're making reports02:35:34
this is our part that is responsible for the report02:35:44
has nothing to do with itself02:35:46
test us tests can be with reports02:35:49
without reports this is additional02:35:53
function it was convenient for us to see which02:35:56
tests passed and which ones failed02:35:58
respectively02:36:01
I am typing And now I have please02:36:03
dragged everything went fine02:36:07
let's say if I do something strange02:36:11
value to check what02:36:13
really mine, I work here02:36:16
I see what I have here, which means we believe that02:36:21
ok gives some expected result02:36:24
that's right, not just the first one that comes along02:36:26
second one02:36:30
that is, regarding this part What questions02:36:37
Irina question Yes, I'm sorry02:36:43
I don’t know, I swam a little02:36:52
this is the output just at this point02:36:56
came up with the name of the variable or did you02:37:00
it's not a name that goes somewhere02:37:02
variables are the meter that you and I02:37:05
we created a little earlier in the lesson02:37:09
created02:37:13
we created three methods, the first one is no02:37:17
which we have now tested without02:37:20
Some numbers at the end02:37:31
the algorithm is considered and the third method is02:37:35
in principle absolutely identical only02:37:37
more environmentally sustainable02:37:40
because they don't use extra02:37:43
variable but seems to do everything the same02:37:45
the most02:37:46
it seemed like everything above02:37:48
commented out and that's why I02:37:50
commented on the first part of the lesson02:37:52
which did not relate to these tasks02:37:55
Yes02:37:59
we actually have this algorithm which02:38:02
you dictated it to me, we tested it and02:38:05
we were convinced that at least get out02:38:08
destination we receive currency02:38:10
the result and everything seems to be fine with us02:38:12
passed all three of our tests as we see02:38:16
We also passed this report02:38:20
Thank you for this method that we ourselves02:38:23
just wrote correctly If we have02:38:26
everything was on top which means it was commented out02:38:28
then it didn't work for us02:38:33
Of course there is no method, there would be no way to02:38:36
Why do we have nothing left at all?02:38:39
commented out this is me just here02:38:42
we did not comment out the code that02:38:45
we wrote before so that we could publish02:38:47
only these reports that have02:38:51
attitude by the method we test02:38:55
for real But this is all I can do02:38:58
uncomment Our methods are the same02:39:01
would work if I did that's all02:39:03
I’ll document the methods we have too02:39:06
worked but02:39:09
comment all the time Because there is02:39:11
part of the code that we tried like02:39:14
home02:39:16
Print02:39:21
we would still have testing02:39:24
happened and all the methods worked simply02:39:28
so that it all doesn't load Honestly02:39:32
telling me these questions just killed me02:39:34
because I thought that you were thinking like02:39:37
about how to write tests and you succeed02:39:40
sat and thought about what care02:39:42
commented that is, and as it were02:39:45
a little bit02:39:46
Here, too, it turns out that bi me02:39:49
I'll have to comment out the second one for now02:39:50
since I use it02:39:55
I just removed everything that won't be there02:39:59
work because the code is wrong here02:40:03
But I could leave it all02:40:06
uncommented it doesn't play02:40:07
no role for commented02:40:10
I just tried to tell you the first one02:40:13
part of the lesson second part of the lesson just us02:40:16
If only we hadn't seen the report to whom we've seen02:40:19
I wish I had a bunch of everything printed out. I wanted02:40:22
so that you see only the latest report02:40:24
which is this commented one02:40:28
he has nothing to do with what02:40:31
we wrote autotests. Not any at all.02:40:34
no, I just commented on it02:40:37
so that unnecessary things are not printed so that you02:40:41
saw exactly what we do02:40:43
it's clear now02:40:50
Can I finish? The thing is that Before02:40:54
today's lesson we somehow wrote everything02:40:57
our tasks are one page many02:40:59
the guys are used to the fact that we have one02:41:01
depends on another02:41:03
let's do this02:41:06
But in general, guys need a little more02:41:09
to be flexible and not to resist02:41:12
here's a buck yes here's a box yes what02:41:16
that's just one way and no other way, that is, I02:41:19
I'll make one Forest Pie Park and bring it there02:41:24
all the code that was before and made02:41:29
I'll move it there and leave only that one there02:41:32
which relates somehow to testing02:41:36
But to be honest, you know right here02:41:39
yours got a little out of whack, that is, not02:41:43
I understand, I kind of explained it02:41:45
testing was expecting a question02:41:47
testing and in the end we got stuck on02:41:50
some part that is not at all02:41:53
has nothing to do with anything at all and02:41:56
you understand that I’m just making comments02:41:58
for your convenience so that you understand02:42:02
what happens better02:42:06
it seems that yes, apparently I'm wrong02:42:08
I thought02:42:10
that I want questions02:42:13
new people Yes, but let's do it now02:42:18
let's separate it so it doesn't bother you, although02:42:21
I’ll repeat this once again as if it’s all the same02:42:24
I expected that lesson 5 would already have such questions02:42:28
won't be so I even a little02:42:31
teenager02:42:34
we're not discussing that at all02:42:37
Can I please finish this so02:42:40
Yes, so that we end02:42:45
back to how to print02:42:52
Yes, now I’ll leave it there02:42:55
just testing me this relationship02:42:58
I commented it all out here like this02:43:02
the first part of the lesson and this is the class I02:43:05
I'll rename it and say that this is the second part02:43:08
lesson02:43:13
and I’ll say that this is Park 202:43:17
and do the factor now go to this second02:43:22
part and Let's clean it up a little here02:43:25
code That is all we have left02:43:27
this is this variable strongly Borodin02:43:32
method that prints the name there02:43:36
prints the number the method that prints02:43:40
test result02:43:42
the method which is actually our main one02:43:45
method that compares experts02:43:49
This is Our task02:43:52
this is a method that does this02:43:56
part of the problem and without comparing them gives Well02:43:59
here we have three methods, then this is02:44:02
There will be more tasks for us, we are not yet up to them02:44:05
got there02:44:11
then what do we have left? Well, now02:44:15
in fact, our Main method is all02:44:18
code which02:44:20
from the first part02:44:24
this is already02:44:27
in the method We first seemed to call02:44:31
the result of our method02:44:35
called through02:44:38
well, it’s not a method, but it’s what they were looking for02:44:41
the maximum value was printed but here02:44:44
in this part we did the author tests and02:44:48
print for each case here02:44:52
tested our method and printed reports02:44:55
For02:44:58
We test our method and print02:45:02
and print reports 202:45:07
We test and print accounting for02:45:10
I’ll bring it out again, that is, everything I02:45:14
I wanted to achieve this by commenting02:45:17
code section is so that we print like02:45:21
if the previous part of the lesson was separate02:45:24
print the next part of the lesson02:45:27
doesn’t print, takes a little long to parse02:45:32
that is, all I wanted was for you02:45:34
we just saw that now we no longer02:45:38
print the result of some work02:45:41
method or some kind of check02:45:44
or there to see that we all02:45:46
we did the right thing. What will we do now?02:45:48
learn any method we write02:45:51
We will learn to check using our02:45:54
case test02:45:56
testing not using02:45:59
we print some kind of result02:46:02
which we calculated A using methods02:46:05
who return something from us then we02:46:08
this is something that the method returned, we check02:46:11
through the test and print accordingly02:46:14
the result of the work in the form02:46:18
as if it were clear that that part was02:46:20
commented out just for convenience Not02:46:23
because there is some02:46:27
the one that relates02:46:29
to the method of this problem Find the maximum02:46:34
meaning between AB it is here in02:46:37
in this class these are helper methods02:46:41
so we can print reports and this02:46:45
our main method which compares02:46:47
expert section02:46:51
And here, in fact, this is ours02:46:55
that is, this is one02:47:05
but then there is auto test 202:47:11
and it goes on02:47:15
too Here it is for every auto test after02:47:19
how we tested it with02:47:22
printed a report with the result02:47:27
Let's talk about this part Everyone02:47:30
was it clear or do we need to do it all again02:47:33
repeat02:47:35
I can repeat it not difficult02:47:38
I have such a small question about02:47:41
these autotests Let's say we are auto02:47:45
write tests in each class02:47:48
as it is asked, it turns out this way02:47:51
let's say if we need to test02:47:54
three times something we will ask in02:47:57
in the same class if something we somehow don’t02:47:59
we will do as we do at home02:48:01
task one after another I mean02:48:03
at work02:48:04
We can allow02:48:07
I don’t know about yours, unless you don’t care at all02:48:10
It’s clear what tests are. You can02:48:12
continue writing task number such and such02:48:16
and there it’s like trying to go do02:48:19
basically it's like we're trying to move to02:48:23
auto tests we try to understand that everyone02:48:26
separate test data is separate02:48:29
which we check separately if you work02:48:32
our method is with these test tests02:48:36
we are still trying to be02:48:37
testers and not just people02:48:40
who are having fun with the code so that there02:48:43
something to watch And this is how it happened02:48:45
or not so, that is, we will each be ours02:48:49
test data separate02:48:51
toskase But if it’s more convenient for you to write what02:48:54
Let's say task number such and such here02:48:57
two melancholy out of 3 Write later let's say02:49:00
task number of some kind and again case one02:49:05
let’s say with different data it’s just yours02:49:09
homework starting today02:49:13
Try not to be there again02:49:15
print plates with calculations we are more02:49:18
Let's not just print it like that02:49:21
inside there is no immediately printed at the same time02:49:25
no nothing returns him nothing02:49:27
check that is, we do this more02:49:30
we won't, we'll write only to those02:49:32
methods that are basically something02:49:35
I'm embarrassed and02:49:37
helper methods that are something02:49:39
they print and do not return the time purely02:49:42
Helper methods for printing How do you02:49:45
you see from all the methods we have today02:49:48
only two auxiliary And all02:49:51
other methods return something and what02:49:53
we will be like the result of our checks02:49:57
our calculations in homework We02:50:00
we will try to check with02:50:03
using tests and printing here's some02:50:05
report02:50:10
Now let's maybe decide02:50:14
the next option may be more this02:50:17
it will settle down in my head because now it doesn’t02:50:19
commented code Now the whole code02:50:22
which we have it relates to02:50:23
map for testing and just sort of in02:50:27
the task that confronted us02:50:30
Now we have completed this part of the task02:50:34
found the maximum value only02:50:36
between02:50:38
question please tell me this02:50:46
Our methods are identical02:50:50
the third one works for me for some reason02:50:53
that's right and the second one No, I'm looking at02:50:55
principle Nothing02:50:57
there is no difference your meaning is the same as02:51:01
a Try it02:51:11
you understand then I will have02:51:13
result02:51:16
if I ask you something else02:51:19
do you mean someone else here?02:51:21
no, I'm trying to check right now02:51:23
on the correctness of the decision, that is, he did not02:51:27
passes like a pass when all three and when I02:51:30
I change Expert for some reason I don’t care02:51:32
makes a pass02:51:35
Well, maybe it means something is wrong02:51:38
algorithm good thanks02:51:44
I'll post it just interesting, I'm calling02:51:48
I have the same methods02:51:53
the same02:51:59
and it doesn't work for you02:52:05
it should be like this but we won’t do it now02:52:07
figure it out02:52:09
check later but I still recommend it02:52:13
to listen and pay attention more02:52:16
they got confused about what I was saying and what they were typing02:52:19
forgot, missed something there because02:52:22
what you can’t do and how in the end02:52:25
you sit and suffer for four hours02:52:28
mistakes they listen to what I say and02:52:31
then it turns out that you listen again and02:52:33
nothing succeeded02:52:35
just terrible nothing worked out02:52:37
actually yes I need to give you a lesson02:52:40
in order to quickly give you these02:52:43
some new topics I'm writing code quickly you02:52:47
so far Maybe it’s not done so quickly02:52:49
write code + seem to make mistakes02:52:52
more because you are not out of his head02:52:55
you invent your own you think through you try02:52:58
just repeat what I write, that is02:53:01
sometimes not understanding what is written there02:53:03
so I still recommend it in class02:53:06
listen and watch more and then after02:53:09
lesson try you reproduce the same02:53:12
the code itself to understand02:53:14
what is written here but let's do it now02:53:18
if there is a question02:53:21
it turns out that in every sand he02:53:24
still copies itself and repeats itself02:53:26
there is another better one02:53:32
[music]02:53:35
ultimately, if we need to test02:53:37
one method with many data We have02:53:41
two options about one we don’t know yet02:53:43
We'll find out soon and what's the option02:53:47
which we are now trying to do is02:53:49
here we will be every time for everyone02:53:51
New sketch create new data02:53:54
new expert02:53:57
does our method work with these?02:54:00
data02:54:02
Irina Vot02:54:04
Be sure to do it as a separate method02:54:06
or could it be02:54:10
no in any case these are two absolutely02:54:14
independent from each other02:54:18
checks it works and this one is correct02:54:21
method And this method in our program in02:54:25
our big system has no02:54:27
attitude towards testing this method02:54:30
may be specially created there for02:54:33
I don't know any02:54:36
for other functions of our system we02:54:39
Let's test whether this one works correctly02:54:42
separately taken that thank you actually02:55:02
with the data that we set and this02:55:06
we call the method point-by-point02:55:09
our test and check if it is correct02:55:11
works and does it work so that02:55:14
with this data, get exactly this one02:55:17
Expert potential and based on this we02:55:20
we conclude that Yes, we have this method02:55:23
did we pass the test or did we fail?02:55:26
we can check another one here02:55:28
some method but not here separately02:55:32
we can check another method and write02:55:35
other meanings but as if in this02:55:39
case we test the method itself02:55:42
taking a program some algorithm02:55:44
now we are writing it ourselves because02:55:48
us in our02:55:49
there are no programmers in the community who would02:55:51
they wrote us methods that we then02:55:53
tested these methods in the future02:55:56
which we are currently testing we will not02:55:59
programmers A will write this02:56:02
we will check if they are correct02:56:05
wrote02:56:06
or wrong that is, we will02:56:09
receive the data we need02:56:12
check we will receive or02:56:14
consider02:56:15
in our opinion02:56:22
and we will test02:56:25
what the programmers wrote in the algorithm02:56:29
works correctly or incorrectly if02:56:33
we have Black Box testing We don't even02:56:36
we will see this code that we wrote02:56:38
programmers but we will test this02:56:42
works correctly They incorrectly A02:56:44
if we have White Box testing then we02:56:47
we will see the programmers' code but not02:56:50
less we will still write02:56:51
a separate test which is, as it were, with02:56:54
With this data we call the method02:56:57
fold02:56:58
knitted work using the method we02:57:02
We test and check if it matches02:57:05
received the room what we expected02:57:09
getting your own is everything02:57:12
testing that we are testing some02:57:14
part of a program or part of code that02:57:18
written by programmers we make our own02:57:21
independent tests and we test by calling02:57:25
this part of the year and accordingly02:57:28
compare the result that was02:57:31
obtained as a result of part of the code it02:57:34
matches what we expected02:57:36
get if it matches then that's it02:57:39
a normal program works like this02:57:41
expected if it doesn't match then02:57:44
we formalize Baku and say that with02:57:46
let's say these are the results02:57:49
this is the kind of data we expected to get02:57:52
such and such an expert And in the end we get02:57:55
some kind of failure That is, we have something there02:57:59
the result was wrong02:58:01
running our test and this method02:58:04
Accordingly, we write bugs here02:58:07
this method doesn't work for us02:58:11
if we have access to Logan code then02:58:16
we can also debug our opinion02:58:18
express Perhaps such and such does not work02:58:22
code section maybe here here there02:58:25
in some place they don’t work02:58:28
because the conditions are written incorrectly02:58:30
This is our opinion, that is, we can02:58:32
express the God inside somehow02:58:35
testers if we have access to the code02:58:37
or clog and we see what the error is02:58:40
We think that this is the mistake, but somehow02:58:43
the decision is not ours Because02:58:45
programmers get our Bach if02:58:47
something fell, they are sorting out their02:58:51
point of view with their advertising02:58:53
and somehow in the end we come to the conclusion Yes02:58:58
is this code really not working or02:59:00
some different02:59:02
or Our guess was correct and02:59:06
that's really why the code doesn't work02:59:07
because we made it easier02:59:10
programmer composition his opinion but how02:59:13
it would be all the same then programmers02:59:15
understand this section of code why02:59:17
it gave the expected result02:59:20
But with our auto tests we are precisely02:59:23
we catch such sections of code that02:59:25
somewhere they give the wrong result02:59:29
on this part I understand02:59:31
I hope you all go to theory02:59:34
testing that explains all this to you02:59:36
on testing theory because02:59:39
in fact, this seems to be the basis02:59:41
take some tester jobs02:59:44
test a section of a code program02:59:48
get some result with those02:59:50
data that was given to us which we02:59:54
they came up with it themselves. It doesn’t matter to us most of the time.02:59:56
the data is given. Here's what to expect03:00:01
some result and in the end manually03:00:05
Compare the two with your own eyes03:00:07
the results did not match write tank that they03:00:10
did not match or two results matched03:00:13
tick that yes the test passed03:00:17
worked fine and he got you here or there03:00:22
such auto tests03:00:25
we call our results to some kind03:00:29
section of code for a large program03:00:32
Let's work on this section of code03:00:35
assign variables to Action visual03:00:37
the result of this piece of code and03:00:40
as if then specifically using a method that03:00:42
compares experts03:00:45
we get the conclusion they are equal or03:00:48
equal that is, our longing has passed or03:00:51
I failed03:00:53
If you have any more questions about this part and03:00:57
respectively, then either Compose03:00:59
report or not Prepared more often Compiled03:01:02
report on which tests were passed Which03:01:05
fell in Irina Tell me, that is, how03:01:08
tester we get it in fact03:01:10
wrote only top and call with03:01:13
method How to test us Sometimes03:01:17
has to be a tester to get03:01:21
perform a lot of actions and03:01:24
write a big script based on a work03:01:26
actions03:01:29
we will write more to receive03:01:33
now I don't even want to03:01:45
mostly we will work03:01:51
but this method is what we do now ourselves03:01:54
wrote because we don't have access03:01:57
I planned the framework today at03:02:00
third part of the lesson03:02:01
but we are somehow walking slowly Yes, but03:02:05
We’re unlikely to make it today, but when do we have03:02:09
will have access to tidy we will already have03:02:11
built-in method similar to what we have03:02:14
wrote it yourself03:02:15
mine we write What to understand how it works03:02:18
built-in So we will have built-in03:02:21
this method is a myth03:02:23
we'll just call03:02:26
And we work03:02:29
testers, automation specialists will be over03:02:32
part03:02:33
write code to get03:02:36
and ask this data03:02:39
either separately in each test or there03:02:42
ask some data in a large stream03:02:45
and check that everything worked for us03:02:48
works correctly on this data03:02:54
Do you still have any questions regarding this part?03:02:57
or Let's compare again03:03:00
write to go03:03:02
exactly03:03:04
they said03:03:05
morphism I kind of got out of it but I guess03:03:08
yeah let's go back to the field part03:03:11
Marfism because everything we will do03:03:14
let's just copy our method and just03:03:19
let's do it this way, that is, we don't change03:03:22
Name let's just make it so that he also03:03:26
compared03:03:28
among ourselves but remember that spring through03:03:32
what should we03:03:36
Required Via dot03:03:41
We will find out why later but definitely03:03:44
through a point also if we assume03:03:47
compare two capital letter integration03:03:49
also through a dot03:03:51
we will also take let's say the same03:03:56
and let's make him compare us03:03:59
results03:04:01
If suddenly we need to compare two03:04:04
results from experts who03:04:08
Please03:04:14
which ones we still have there often03:04:17
used03:04:28
there's no way03:04:45
but he will return something, either pass or03:04:49
the meaning of this game03:04:52
in this Stream all this type03:04:56
return value what do I need?03:04:58
transform And please tell me this03:05:03
in this case we have the name method03:05:06
may remain the same03:05:10
incoming data can be of different types03:05:13
parameters03:05:45
overloading that is, we reboot it03:05:48
earlier let's say on this line it03:05:51
worked only with the parameters on this03:05:54
line the same method now also has parameters03:05:57
That is, it’s not that intense is no longer03:06:00
accepts that he is now still from03:06:02
parameters works but here it is still03:06:05
from the Double parameters it works03:06:12
that is, let’s say if I want here03:06:16
Now03:06:19
I call please let me choose which one03:06:24
exactly the method I want03:06:26
suppose I chose the method that03:06:30
technically I'm technically again03:06:34
I clicked on the meter which03:06:38
but at the same time, let’s say I’ll take it there too03:06:43
twice That is, he recognizes perfectly03:06:47
because yes please in this method03:06:49
Stream is allowed too, that is, but I want to03:06:54
the same method I called let's say with03:06:59
doubles03:07:03
3.303:07:09
if I want it I will call the same method03:07:13
I can call you because it’s like that for me03:07:16
it says that I reboot three times03:07:19
one03:07:20
it now works for me with different types03:07:23
parameters03:07:26
and accordingly here what I will get as03:07:30
the result works03:07:35
here is what I get03:07:37
What am I here?03:07:40
because I have unequal experts03:07:44
Not because they are this fat because03:07:46
expert03:07:48
And this is how I get the result03:07:51
working with these parameters03:08:02
need to put03:08:08
it's called overload when03:08:11
same name of methods and with different03:08:14
exactly03:08:18
overload03:08:19
I accidentally called it at first03:08:22
wrong03:08:34
that is, we overloaded it, she said03:08:38
reboot03:08:39
we overloaded it, that is, we sort of03:08:43
made it so that it works with different03:08:46
parameters We take the same method03:08:49
and thanks to what we give inside03:08:51
different parameters hunting remains exactly03:08:54
we seem to have the same opportunity03:08:56
then call the same method with03:08:59
different parameters But if we wanted03:09:03
would like to create it again03:09:06
method let's say I take Yes and want to do it again03:09:11
exactly with two Incas again03:09:14
naturally I can’t do it anymore I already have03:09:18
swears this method already exists03:09:21
there is the same name stylish03:09:24
parameters of type int already exist03:09:26
the name is here by the way Absolutely none03:09:30
it doesn't matter if I try to do it03:09:33
I don't care03:09:36
he's just scared now03:09:41
that is, But still I cannot create03:09:44
exactly the same method with the same names03:09:48
with two parameters because it doesn’t matter03:09:51
what the variables are called, it doesn’t matter which one03:09:55
the code inside is written, it is important that I have03:09:57
method with this name which03:10:01
takes two type parameters and what is this03:10:04
the method already exists, but it doesn't exist With this03:10:08
same name also Takes two03:10:10
parameter03:10:13
and here is a method with two type parameters03:10:16
Stream please I can create a method03:10:19
the same name but with two03:10:21
with parameters of type Double I can create A03:10:24
like this I can create03:10:31
Yes03:10:33
I can only have a problem03:10:36
there are no comparisons inside, but create exactly03:10:40
I can because I don't have two03:10:43
parameters not two parameters I have one03:10:47
the parameter is different but for us03:10:54
say what the main parameters are03:10:58
exactly the data type name03:11:03
Yes, but in the last lecture you said03:11:07
about polymorphism03:11:11
It's either called that or that's all03:11:14
one and the same Well, in this case yes03:11:16
That's an example03:11:18
polymortism is one of the principles we03:11:21
We won’t go too far into theory, but somehow03:11:24
for an interview if he tells you03:11:26
Show us Tell us some example03:11:33
here you go, you say it’s possible03:11:36
create methods with the same name03:11:39
but with different parameters and different types03:11:42
data and this will work for us because03:11:46
what do we do in this case03:11:49
this method and, as it were, one of03:11:53
examples of the field of Marxism when we are one and03:11:55
can also be used many times03:11:59
different guises Think about what it means03:12:02
word field Marxism That is, we have it03:12:05
some entity that can03:12:07
exist there in different guises then03:12:10
there is here we take this entity this one03:12:13
method with a unique name03:12:15
and as if with different parameters of my03:12:18
we create and this is one of the examples03:12:26
somewhere else there is03:12:29
Well it doesn't matter to you03:12:31
don't bother filling it out so deep though03:12:34
would03:12:35
if you can at least about one03:12:37
telling it in an interview is already great, huh?03:12:40
if, as it were, you need it, well, let’s say you don’t03:12:44
beginner you need to know about some03:12:46
still go to lessons there I hope so03:12:50
many different examples How can we help beginners03:12:53
just remember the baking sheet03:12:57
we often come across questions in interviews and03:13:01
as if an answer With such an example already03:13:04
quite enough03:13:09
just understand that if you now03:13:11
I'll go to theory and I don't have any beginners03:13:14
will remain and two will not come to me03:13:17
because they have their own lessons so03:13:20
let's not get too deep03:13:22
go deeper divide the tasks here I am03:13:25
I tell you exactly as much as you need03:13:28
prepare you for testing and03:13:31
more or less prepare the passage03:13:33
Of course, I don’t do interviews for you03:13:35
I can sit down and learn that this is an example03:13:41
let's say03:13:43
or rather this03:13:47
they wrote that this is how it works03:13:51
because the same principle works03:13:55
I can’t torture this for you, I’ll give it to you03:13:58
information exactly enough to be03:14:01
enough for you to be ready03:14:04
hereby testing and03:14:09
interview, if you have any other questions03:14:13
except for in-depth theory03:14:16
I can yes03:14:19
please return to 100 31 these03:14:22
lines03:14:31
Here03:14:32
Line 104 we call the equals method and03:14:37
Line 109 we call again03:14:41
from under the method already Print and cut 10403:14:46
line we get03:14:48
result before Return of this method But we are with03:14:51
We don’t do anything to him. Why because03:14:54
this one And these are two completely different03:14:58
area of us maybe03:15:01
we can't have a report without a test03:15:08
But this part relates specifically03:15:12
testing And this is report writing03:15:16
results03:15:18
That is, these are completely two different03:15:20
this is what we do here03:15:23
If only we had here03:15:28
This is where we got the error03:15:31
problem with Vere Fayta in this case we03:15:35
we don’t do it, but in a real framework03:15:37
we will see exactly the error that fell03:15:39
the test itself And these are just reports and03:15:42
report result03:15:46
how would we see this line 104 if03:15:50
it gives an error, we understand that we03:15:52
the test was written incorrectly, not really03:15:56
spelled incorrectly03:15:59
no what could it be like what we have03:16:03
Expert of unequals so he gives a failure but03:16:07
we don't use it anywhere now we don't have03:16:10
real testing We don't work03:16:12
In Frank03:16:14
we won't have time to get there today because03:16:17
that we are at some of these moments03:16:19
we're stuck here But if we had03:16:23
real testing03:16:25
now we're just doing fails for real03:16:29
in fact you could value03:16:31
done using this method, it’s easy to deduce03:16:34
in system03:16:36
system outprintella and it would be the same03:16:39
that is to say, he would simply deduce03:16:41
we just artificially created the meaning03:16:44
a special function that gives us03:16:46
test result is printest cut03:17:27
But these are two different actions that are important03:17:30
understand what the test is, this is the test and what03:17:35
his task is to compare aspects03:17:38
secials in this case while we are working03:17:41
here in this, as it were, in this LG shell we03:17:47
we can't do it in this place03:17:50
here on this line we have something there03:17:52
an error occurred, so we just do it03:17:56
but if we ever get to03:18:00
our framework will be very similar03:18:03
method Why we write it here because03:18:06
what we want is well I want you03:18:09
understood How the next one works This one03:18:11
offer which is in this framework and03:18:14
here are the real rollercoasters in this place for you03:18:18
will tell you that everything will fail the test03:18:22
the mistake will go where further03:18:25
the program would not work without special03:18:27
given conditions That is, you will fall03:18:30
heart test and here is the report This is03:18:34
completely independent actions03:18:36
prints the result of the check if there was one03:18:39
file please03:18:43
but there seems to be nothing here anymore03:18:47
can't fall because it's easy03:18:49
prints03:18:52
I didn’t want to give this to you, but03:18:55
I thought that you are not a sprayworker at all03:18:57
you can handle it, so I finally decided that03:19:00
ok okay we'll write it like this for the most03:19:03
beginners who use the framework right away03:19:05
they won’t understand But how about now03:19:09
it turns out that we need more depth03:19:11
We don’t have time to go deeper due to this03:19:13
move on03:19:15
Because they seem to have questions03:19:18
attitude03:19:19
so to speak03:19:21
no testing problems03:19:24
relation to the fact that this shell03:19:27
which we have now created for the project03:19:30
Java hobi ginners we can't do03:19:32
differently, so we do it like this03:19:36
Well, we could have done it differently, but for03:19:39
this requires another shell and there you are03:19:41
we clearly saw that we have this test03:19:44
fell precisely on comparing the results and in03:19:47
report Yes, what did you do? Well, the report seems to be03:19:51
in itself it has no03:19:53
attitudes towards testing In addition03:19:55
may not exist at all, that is, ours03:19:58
test without report exactly the same as if03:20:01
He will get some result right away03:20:04
compare now I commented out the report03:20:07
for the first flight03:20:10
the report will not print but it is not03:20:13
means that at this point it’s simple03:20:16
here's one Let's all report03:20:26
I take and comment on everything unnecessary and03:20:30
if I print now I have nothing03:20:33
won't print because I have03:20:35
reports are commented out as if they were not03:20:38
exists but doesn't mean anything wrong with the case03:20:40
I didn't pass, I'm passing here03:20:43
so no03:20:45
reports are printed separately yes it is03:20:48
artificially created situation that03:20:51
just print it out nicely03:20:53
test results Because myself03:20:57
the test itself is just like the real thing03:20:59
the framework itself is no test03:21:02
the report does not create, it writes pass or Fail03:21:05
for a certain situation but the report is here03:21:09
in such a way that it can be03:21:10
print it out and demonstrate it03:21:13
creates to print reports03:21:15
we either write some ourselves03:21:17
we attach customized reports to03:21:20
our testing or use there03:21:22
ready-made frameworks there are aluminum, for example03:21:25
which creates reports nothing more03:21:27
other similar frameworks do this03:21:31
there is a report that is completely separate from03:21:34
automatic testing of the situation and that's it03:21:36
understand that this is what she said03:21:39
precisely to confirm that03:21:42
experts are the right people or not equal here03:21:46
and the report is just us03:21:48
artificially created some kind of separately03:21:51
such03:21:52
auxiliary methods that are easy to see03:21:55
Yes, it worked for us in this case03:21:57
and in this it worked in this it was said03:22:01
So we will see the report but there is no test03:22:05
does not depend03:22:08
let's probably understand everything further already03:22:10
then we give nothing03:22:13
let's not go and do this, let's say this03:22:17
We won't miss it in time Let's get it03:22:20
straight from rock But this is what we need after all03:22:22
must be done How do we find the maximum03:22:25
value between four variables here03:22:28
let's create03:22:32
Here they are I'll just copy the Title but we03:22:37
let's create something like 403:22:41
parameters we must go to this03:22:44
we will also do the method03:22:50
So there are four parameters and how do we03:22:53
compare Find maximum03:22:59
we will03:23:01
Let's take from all the previous ones received03:23:05
knowledge Let's try to do03:23:07
returned equals due03:23:10
4 parameters and it should return03:23:14
Let's try to create some03:23:17
algorithm03:23:20
without class methods let's just say03:23:24
We’ll come up with some kind of algorithm ourselves to03:23:27
return from four parameters03:23:29
maximum Let's think about how it's easier for us03:23:32
do it03:23:34
can be done03:23:38
divide by 2 to03:23:40
I mean take if A and B are greater than03:23:46
Divide the parameters into 2 groups Yes no03:23:49
divide by 203:23:51
sounded like dividing something by 2 yes03:23:55
that is, let’s take two groups03:23:58
parameters and Suppose we compare that03:24:01
first we will find the maximum between03:24:06
that is, we03:24:08
we Oh, by the way, okay, let's write first03:24:14
that is, we take and compare what if she03:24:17
more03:24:21
equals B yes then we assign what03:24:27
we will return03:24:29
we can return it here03:24:33
we can write03:24:38
we can But we checked all the parameters03:24:42
Yes, we haven’t checked how here yet03:24:46
since we can't write returname because03:24:48
what in this case this method will compare03:24:51
only and immediately03:24:55
won't touch it, it's just here for us03:24:58
need additional variable03:25:01
no additional variable and here03:25:05
we just what if we have more either03:25:09
Let's say that our Max is equal03:25:14
so because we can't yet03:25:16
return some value between the two we03:25:19
could immediately determine and return And here03:25:22
There are four parameters of us. We are all03:25:24
must compare with each other so we03:25:27
create an intermediate variable and for now03:25:31
at this stage we set the Max variable03:25:34
let's say yes, if it's more then ours03:25:39
maximum correct Otherwise03:25:42
our maximum03:25:47
our maximum is03:25:50
further as you said that we divided03:25:54
parameters into two groups03:25:57
Yes and greater than or equal to D yes that is we03:26:01
let's write the same thing03:26:04
but only for CD That is, if si is greater03:26:08
or equals money then what do we have03:26:12
will be at most equal to 7 And where do we get these03:26:20
we need one more variable so that we03:26:24
didn't erase the previous maximum, let's do it03:26:28
Max is one and let's say that Max day is equal03:26:35
or keep quiet03:26:41
maximum compare without entering this03:26:43
additional03:26:45
Variable Max one is simply Max03:26:47
compare and then03:26:50
we can have a great idea what could happen03:26:56
divide into two parts03:27:04
from here calculate some maximum03:27:07
And let’s say right away that if03:27:13
Let's add that algorithm anyway03:27:16
For now, we’ll leave your idea for later and03:27:19
let's write another one03:27:20
but if we divided the parameters into two parts03:27:24
now what should we do03:27:30
Yes And here we can already03:27:33
write03:27:35
because comparing the maximum from the first03:27:40
couples with Maxim and the second couple here in03:27:46
basically so and so Trifa will be like So03:27:49
that So yeah maybe Let's see03:27:55
We can already talk to each other03:28:09
yes otherwise myth otherwise yes we will03:28:14
return Max 103:28:17
weave Max one03:28:20
And in this case, that's exactly where we are03:28:24
we can return something because we03:28:26
have already divided our parameters by 2 by 203:28:30
groups found a maximum between two03:28:34
parameters compared one maximum with03:28:38
another maximum and as if immediately we03:28:41
we can return03:28:42
Or could it be like you already said?03:28:47
there is a second idea, let's do it03:28:49
let's say03:28:51
let's do it03:28:54
what could we do right away03:29:00
develop your idea03:29:03
maximum03:29:06
I think this would be relevant if03:29:08
if we had an odd number03:29:09
compared parameters when we are not03:29:12
Could you break it down into pairs?03:29:16
May be03:29:18
We also03:29:20
after we received some03:29:23
maximum from the first pair we can What03:29:27
do just to finish this thought03:29:32
we helped take the maximum and compare it03:29:37
first and choose between maximum and03:29:41
bi we already have something there we chose A03:29:44
now we take this something and say that03:29:46
if it's something more then maximum03:29:51
it will be Max, that is, we are not changing it at all03:29:54
even in principle it’s like this line03:29:56
excess to receive if the maximum is more03:29:58
or03:30:00
The maximum we have is what remains03:30:03
was03:30:05
Yes03:30:06
look otherwise it will be different03:30:12
But this line is superfluous, even why?03:30:16
because you can immediately say that if03:30:19
maximum less03:30:23
or less then03:30:27
everything is maximum Yes, otherwise we03:30:31
it’s not even necessary because that’s how it was with us03:30:33
it will stay that way03:30:36
it means it is greater than or equal to si03:30:39
before that is not on otherwise we have nothing03:30:42
must be registered03:30:45
Yes, go exactly the same way, that is, with one03:30:48
sides we also have 3 conditions and but the code03:30:53
in short in this case Yes because we have03:30:58
how do we get into this area already with03:31:01
somehow a maximum if this maximum is not03:31:05
falls under the condition as if he03:31:07
less then we change it this maximum A03:31:10
if it is greater or equal then we are as if03:31:14
our Max remains, that is, in the end03:31:17
look at our code here, it’s kind of longer03:31:21
Well yes we can03:31:27
there will be a certain maximum that will03:31:29
less and less did not compare with each other03:31:35
compared because we took the maximum from03:31:40
but some maximum whatever it may be03:31:43
if he has less than a sieve, respectively03:31:46
we have become the maximum media and we are here03:31:49
compare between sindia And if the maximum03:31:52
whatever it is we have more than that03:31:55
why do we need to unite03:31:57
compare with yourself if the maximum is already03:32:00
more than us then it doesn’t matter at all03:32:03
let's say we have03:32:05
let's take03:32:08
234 and they both hit and three is less than two03:32:13
more than two, that is, maximum less03:32:16
and maximum less go we did not choose in03:32:20
watch this moment here03:32:23
your numbers would give us two03:32:26
As you say but at the same time 2 you03:32:31
say that03:32:32
should be equal to three03:32:40
now the maximum we had it03:32:43
compare03:32:45
that Maxim Less means maximum has become03:32:48
equal and then Dima let's go and compare03:32:52
new high03:32:54
[music]03:32:57
that is, we will check all options03:32:59
the only black we record03:33:02
maximum03:33:10
much more03:33:13
[music]03:33:16
so yeah And now we're in this03:33:19
the method is missing03:33:21
Now we have to return exactly that03:33:25
is there any max as a result of these03:33:28
checks failed we must return03:33:32
exactly the Max who came to us at03:33:37
this line 119 Here is our method03:33:40
quite now, as it were, a little bit of code03:33:42
slightly less03:33:47
reassignment but in principle exactly the same03:33:52
could it be done or could it be done03:33:55
try03:33:57
greater than or equal to B or C or D03:34:02
write it down like this No, she does it like that03:34:07
greater than B or C not greater than D03:34:12
No, don't even think about it03:34:15
It’s wrong to compare like that in this case03:34:20
and C and D like this03:34:23
Think this way, sorry about that03:34:26
interrupts now we'll get stuck and this03:34:28
Wrong Way03:34:30
it would still just be them03:34:34
much longer more and there would be a cat03:34:37
much harder because we would03:34:39
I had to compare something and more03:34:42
equal to B and greater or equal and greater03:34:46
or equals And if nothing hits then03:34:50
then if Bay is greater than equal03:34:56
how03:34:57
there would still be three left because03:35:01
we get the result of performing all three at once03:35:04
Doesn't mean anything that we wouldn't care03:35:07
would find something greater than or equal to it03:35:10
all either and no more or equal all but03:35:14
at most we would still find me in03:35:16
in this case, that is, it would not have worked03:35:19
make one through these connections03:35:22
all comparisons that is03:35:31
the result of this is this03:35:37
that is, there is no point in writing oil03:35:40
what if there is more and03:35:45
then let's say there is something more03:35:49
chopped03:35:54
equals03:35:56
and then write more separate conditions03:36:02
and then write separately what if conditions03:36:15
so then03:36:17
consider that this is our maximum, that is03:36:20
it would just be an unnecessary action03:36:23
which is completely unnecessary03:36:28
that is, it's just oil03:36:32
re-arranging the same concept03:36:35
twice in different specific wrappers at03:36:39
this candy remains candy so we don't03:36:43
we do it because this is the result03:36:45
comparisons already either03:36:48
we get here if we get there03:36:51
here now just a second03:36:58
and now let's figure out how03:37:01
we could also use the method03:37:04
Let's write down a comparison. Can I ask a question?03:37:10
Now we have already written two comparisons03:37:14
We have a disadvantage in this situation then03:37:17
that he brings out the one and only Max03:37:19
let's say if the source data is here03:37:22
Of the four of us, let's say three of us are the same03:37:24
he will only get the maximum out of us03:37:27
equal to it and the maximum They can be03:37:29
if A = B and let's say A = D then we have03:37:33
three maximum that's good of course03:37:39
and from these average temperatures according to03:37:42
hospital03:37:59
and we just need to Find03:38:02
maximum value of03:38:05
four-digit03:38:07
Understood03:38:11
let's now through03:38:14
4 value via method03:38:19
Well, since the Nes method we can immediately03:38:22
write Return Don't let us think how03:38:25
the method belongs to us in this case03:38:27
use Who has any ideas point Max03:38:31
yes And there you can register four at once03:38:34
No03:38:41
This is one option, but it can be simpler. Let's03:38:44
immediately to03:38:49
No, look as hard as you can, I’ll write later03:38:54
writing03:38:56
Max03:38:59
between03:39:03
and one more03:39:09
between03:39:10
si and03:39:16
see I'm at first Max between03:39:19
in the middle then so that I won’t be found there03:39:24
I'll insert next month meanwhile03:39:28
what was found03:39:30
here and then so that it is not found in03:39:35
result of comparison and previous03:39:38
comparisons I add here and03:39:41
I compare with what was found in03:39:43
as a result of these operations03:39:46
you see I'm just three times excellent03:39:49
method03:39:51
also without leaving the cash register while you03:39:54
think about it03:39:56
see what you can do03:40:05
this is a built-in method but we have it03:40:08
already our own method which we used before03:40:12
found the maximum of two We are exactly the same03:40:16
we can reuse our method that I03:40:20
I do I say03:40:22
I write at most03:40:27
I'm writing again again03:40:44
and this way I will first find03:40:46
maximum of these two03:40:49
then so that I don’t have it here03:40:53
substitute and find between and what03:40:57
the maximum has already been found and then so that it’s not there03:41:00
it was found to substitute here and it will be found03:41:04
mass between Hey and Look, I'm like three03:41:09
times call the same method that I have03:41:12
already been and this way I get around03:41:15
like this03:41:19
I already have additional coding03:41:22
were these methods I just three times03:41:25
I call, substitute different variables and in03:41:28
In this case, I won’t invest, let’s say, extra03:41:33
And I just use the method that was03:41:36
there is this03:41:38
the form, as you can see, doesn’t need these03:41:42
we practiced all the methods we saw03:41:45
but in general I could have a task there somewhere03:41:49
bypass method03:41:51
at most just substituting different ones03:41:55
variables use these nested ones03:41:58
other methods because when the method03:42:01
returns something03:42:02
maximum between these two I am something03:42:06
I take it and immediately use it in a new method03:42:09
which already substitutes what has returned03:42:12
finds the maximum between what came back03:42:16
and then I take what it returns03:42:19
I substitute this part again as03:42:23
parameter That is, I called one three times03:42:26
and used the same method03:42:29
same piece03:42:30
I just used different parameters03:42:33
invested03:42:38
so we will strive for this03:42:41
parts03:42:43
that is, that we will03:42:45
reuse the methods we03:42:48
have already created and figure out how to create them03:42:51
use it to avoid breeding there03:42:53
a million new methods like we are here03:42:55
Yes, they have given birth, but in reality they are already for us03:42:58
were not needed03:42:59
we no longer needed it because if we03:43:03
found the maximum03:43:05
please we can we can even do this03:43:09
I don't wrap the method wrapper, we can03:43:11
just out there somewhere03:43:14
find the maximum loan several times03:43:19
much more important in the future when we03:43:22
let's learn how much03:43:24
you can pass as many parameters here as you like03:43:27
Now we have strictly quantity parameters03:43:30
strictly defined parameters because03:43:32
that we should write it in advance we03:43:35
must know in advance how many parameters03:43:37
we will learn how to pass parameters03:43:40
somehow common Well, let's say this is the group We03:43:45
we may not even know how much there is03:43:47
There will be parameters in the end, but we will learn03:43:50
find the maximum of all parameters03:43:53
no matter how many there are, just like that03:43:57
now calling some of these already03:43:59
existing methods03:44:02
Here03:44:05
it will work first so03:44:09
CD or03:44:11
because remember in math03:44:15
rules We first do what is in03:44:18
parentheses When we have a lot03:44:21
looking for the latest03:44:31
This is what it does and only then works it out03:44:34
maximum And what has already worked03:44:41
Well, basically it's identical to this one03:44:44
So in the future you won't even03:44:46
create such a method yourself03:44:50
because we already have a built-in03:44:53
method from the class with which we can03:44:55
call any moment and how would we for03:44:58
it is not necessary to create a new one03:44:59
method just here we are03:45:01
trained to understand how it all works03:45:03
done you will have a similar task03:45:06
Homework and how it will be necessary too03:45:09
test But let's go here03:45:11
we do not test this particular task03:45:13
we will because in theory we still need03:45:16
Here are some tasks that will help you03:45:18
actually almost do my homework03:45:21
4 hours until we sit, well, let's write though03:45:24
I wish I could03:45:26
This is something I planned03:45:29
so that we don’t have much more time to do something03:45:31
Well, okay, my problems How03:45:33
it says03:45:34
let's take it03:45:36
so here I will write somewhere in my place03:45:40
there was a Main method Yes, unfortunately for now03:45:43
we get a very good year because03:45:46
We write everything in the same class, but it’s like03:45:48
idea planned for you already in the present03:45:52
It didn’t work out to provide the framework today03:45:54
so next time we’ll do And there03:45:57
there won't be so much code anymore03:46:00
you have to go back and forth like this03:46:02
scroll search, that is, everything will be there03:46:05
it will be organized differently03:46:06
it's easier to see your code for a specific03:46:09
task but for now it means here we need03:46:13
write a method that takes input03:46:15
number pay attention one number from03:46:19
one to 1203:46:21
there are certain boundaries and returns03:46:24
month name03:46:26
we write help public By the way03:46:31
what this method will return what it03:46:35
must03:46:37
before the name of the month the name of the month is03:46:40
Stream03:46:42
he will return Stream as we do him03:46:45
let's call03:46:58
and what's going on03:47:07
number03:47:12
Let's03:47:18
let's check the validity03:47:22
When we have a certain value03:47:25
boundaries then we must03:47:28
check this value for validity03:47:31
it came to us exactly within this border03:47:34
meaning Because if came 0 We03:47:36
we don’t even know what to return if it arrived03:47:39
13 We also don’t know what to return, no03:47:52
Yes, if we have the number that came03:47:57
greater than zero and03:48:03
equals 1203:48:06
And03:48:11
less than 13 Let's say03:48:15
Here03:48:17
we must have it at the same time03:48:19
and greater than zero and03:48:23
less than 13, that is, then it will fall into03:48:27
the one in which we will do something at all03:48:29
Otherwise, if she didn’t immediately get into our03:48:33
We'll let this rage be returned03:48:46
that's when the method returns something, then we03:48:50
write Return03:48:52
in a word Well, for example, or there will be others03:48:57
we haven't been through the situation yet, we can03:48:59
throw an error here But we don't03:49:03
We're unlikely to pass because03:49:05
that testing will not be much needed03:49:07
that is, but in this case it’s simple03:49:11
for your homework Yes if you don't have03:49:13
valid value means something03:49:16
should still return it because no03:49:18
should return something anyway03:49:20
even if invalid values mean nothing03:49:24
This is the method that says:03:49:26
that he returns 3 still has to03:49:29
return some Stream in this case too03:49:31
It's easiest to write down the numbers03:49:35
[music]03:49:36
here, but if we hit the valid ones03:49:40
meaning then what will we do03:49:43
How can we do this in code?03:49:47
give me a hint03:49:49
month name03:49:51
the current that came03:49:57
assign depending on the number03:50:00
relevant text if03:50:09
What03:50:12
if number is strictly yes strictly03:50:18
equal to one more less there namely03:50:23
strictly equal to one then only in this03:50:25
in case we will refund that03:50:30
We're coming back03:50:38
further accordingly if03:50:43
strictly equal here we should have03:50:46
els or just a chain03:50:53
because we only get one03:50:56
number and it can only be equal03:50:58
one thing and accordingly only03:51:01
we can return one month for each03:51:03
number if we allow we could on03:51:07
number 1 return both January and February then03:51:11
then we would need a chain here03:51:13
Just03:51:14
independent but since for each number03:51:18
we can only return one name03:51:20
we need a month03:51:24
because one excludes the other03:51:28
accordingly, if it doesn’t seem to us here03:51:31
Can03:51:35
can't Why can't somebody03:51:38
explain03:51:41
Why does the program check all games if03:51:45
look if I do it like this then I have03:51:50
let's say the number 1 came, I have it03:51:53
check out And that’s why we’re writing now03:51:57
film Right Why Because reter03:52:00
stops everything else from working03:52:03
programs if we have already got here then03:52:07
we immediately return the Jenners and then we03:52:10
we won't go anymore so yes the movie is always03:52:12
we remember right here actually03:52:15
indeed, if we printed then we03:52:19
they would go along the entire chain and print03:52:23
continued further03:52:26
or they would have checked and not printed but because03:52:30
what the word retur is worth is very03:52:33
important word because as soon as we03:52:37
we got somewhere and we just saw03:52:40
return I think it's written here03:52:42
and we fly out of the program here, that is03:52:46
We're not going any further at all. So yes03:52:49
movie so accordingly Let's go03:52:53
I'll quickly copy it so we can have this03:52:55
a year left then here we have March03:52:58
That's because you will have a similar one03:53:00
exercise03:53:02
accordingly and adj. but you probably know03:53:05
I'll stop here, that is, to03:53:08
time to waste and that's it I see03:53:12
the meaning is clear this assignment is clear03:53:17
and how are we going to write the test because we don’t03:53:20
I want to write03:53:22
Is it possible to write the question more correctly?03:53:26
via els so that the program does not run on03:53:29
the whole list or not or one another in03:53:32
in this case it doesn't matter at all03:53:34
good because yes in this case03:53:37
will work as soon as there is some03:53:40
meaning03:53:42
matches what came03:53:45
that is, three black will work and then03:53:48
we won't go anyway if we don't have03:53:51
we'll go to this one anyway03:53:53
check But if we have two we will immediately03:53:56
we will return and we will not go anywhere further and03:54:00
also selfie That is, we would have03:54:04
absolutely also Why Because just03:54:07
no longer depends03:54:09
from the fact that as soon as we are somewhere inside03:54:12
hit the letter is triggered and further03:54:16
independent lcf goes on or simple and03:54:20
we are completely out of the word program03:54:24
Return is our exit from the program03:54:27
you understand03:54:29
we immediately complete the program from the point of view03:54:33
readability as it was written by everyone03:54:36
what in terms of readability is it03:54:39
It's a completely separate conversation because03:54:41
There is another way to write through03:54:44
Switch operator Switch and Probably so03:54:49
don't confuse you even more today, we're going there03:54:51
we won’t go, but for me personally, yeah03:54:54
for a tester who works a lot03:54:57
with exactly these things, what when03:55:00
there is one case we do this there is another03:55:02
We'll do something like that there, that's it for03:55:06
I would be a much more comfortable operator03:55:08
Switch because it would be better readable on03:55:12
my opinion03:55:19
Select We even pass within03:55:22
let's not, that's why we don't swear so much at03:55:26
Javakh make sure everyone knows what it is03:55:29
Select go to the Evens Well, but somehow03:55:34
again from a readability point of view03:55:37
maybe someone wouldn't like it03:55:40
maybe in the next lesson we will have time03:55:43
grab a candle, we'll see, but how about it?03:55:47
Well, I don’t know, but here you already know this03:55:50
you like in this case it will be03:55:52
it doesn't matter at all and or and because03:55:56
it will work03:55:59
in terms of design Yes, I wanted to clarify03:56:04
you make spaces for future use03:56:07
do for clarity or readability03:56:09
or in the future we need to get used to it03:56:11
write without spaces03:56:14
on the contrary, now I'll go straight when03:56:17
I didn’t make any spaces, I really don’t either03:56:20
you know what they say, my hand hurt but03:56:22
I thought it was okay so they can see what it is03:56:26
one block of photos is according to the rules03:56:28
registration according to our remember03:56:33
must be put before03:56:36
spaces because naturally in the future03:56:39
we basically won't be that easy03:56:42
I think I did everything the other way around03:56:45
you have to accustom yourself to always03:56:48
there was an extra line because03:56:51
usually we will have something big03:56:53
a big piece where then there at the end03:56:55
some kind, that is, it will be considered03:56:58
much better because if we don't03:57:01
you need to understand what this method does A03:57:04
you just need to find out what it ends up being03:57:06
returns we immediately go and look03:57:08
Return Yeah, this method returns here03:57:11
Let's say this, and accordingly03:57:13
We try to name the variables so that03:57:16
it was clear that in the end the method03:57:18
return03:57:20
that’s clear Yes, it’s not better here at all03:57:25
you have to train yourself to write so that there are03:57:28
spaces before dark on03:57:31
let's go03:57:35
we still need to write a test03:57:39
write for03:57:41
beginners03:57:45
Let's limit it to four03:57:49
then the conditions need to be changed and then he will say03:57:53
here is the code commented out03:57:56
unclear no let's write yes I already03:58:01
typed oh Let's03:58:06
I'm still typing your piece later03:58:19
so seventh03:58:22
next we have August03:58:28
filming for programming03:58:30
stelland further we still need 4 months03:58:38
That is 903:58:45
write next 10 in advance03:58:50
the bus goes further03:58:54
and 11 November03:59:01
and on December 12th everything went to the end03:59:08
So now let's write a test for that03:59:11
to test our case let's03:59:15
let's make only one positive scenario03:59:18
Happy Pass and one negative03:59:20
accordingly, let’s repeat at the same time What is03:59:23
positive What is a negative scenario03:59:26
we do it here 4 Yes, we already have03:59:30
just in order and no matter what03:59:34
we end up testing, we just don't03:59:37
we share functionality as a rule03:59:39
go in order there really are there03:59:42
complex numbers Let's assume that03:59:45
let's go in order So what do we have?03:59:49
may be the input data that we need03:59:51
known for testing if if we03:59:56
I liked it, I cut off one block04:00:00
no no input data remember three04:00:03
half 1204:00:06
input data then we have this04:00:09
be a variable some number up04:00:12
I don’t know who will come, I don’t know04:00:16
Well, let’s say they gave us product picks What04:00:20
you need to check the number 504:00:23
so that the month comes out correctly because04:00:27
13 salary if he doesn’t work there04:00:30
the entire organization without 13 salaries04:00:32
will remain This is conditional and that’s how we take it04:00:35
some number that they gave us next04:00:37
Necessarily04:00:39
data that we already know Which04:00:43
Expert cut correctly What type04:00:47
he will be here with us04:00:51
But we will no longer be able to create04:00:54
The Expert cut off the variable, then we have it04:00:56
there was further so we'll do it there04:00:59
ex-cut or let's say experts04:01:06
don't learn this stupid habit04:01:09
how many are cutting Yes but we will do it04:01:12
let's say this is with us, look with us 4 That04:01:17
there I am just for your future homework04:01:20
what is the case number? Better then04:01:23
Call your experts04:01:28
and accordingly let's say that this is04:01:33
us for number 5 We are expected04:01:40
they said that on the fifth number you should04:01:43
we get further04:01:45
something else we know04:01:48
for check04:01:51
no no let's move on to the next one04:01:55
parts04:01:56
that is Black we must somehow04:02:02
pervert and get the result of the work04:02:05
programs04:02:07
that is, we need to create some kind04:02:17
Sometimes it's just not that easy to achieve04:02:21
result and there are a lot of actions required04:02:23
do now it's just that is what we04:02:26
have to do to get it04:02:32
call our method call method yes No04:02:35
be afraid to answer because you will04:02:38
also at the interview Yes and it won’t happen04:02:42
Do you think it’s worth saying something better?04:02:43
say than hang in my opinion yes04:02:48
we had something there04:02:52
this is where we will transmit it04:02:56
Our our test data that is our04:02:59
give us a variable here inside the method and04:03:03
we will see if our method will work04:03:06
that is, and accordingly further more04:03:09
We don’t need to take any action anymore04:03:11
already received and call what's next for04:03:15
in order to compare experts04:03:25
we don’t write That’s accordingly here we have04:03:29
is there please in reform which04:03:31
compare two thongs and we just come here04:03:34
We convey to our Expert the result that04:03:38
for this04:03:39
show which is also for this04:03:43
so if we launch we won't do anything04:03:48
we'll see because the report went well with us04:03:51
nonsense04:03:52
Yes, we are missing something here04:03:56
By the way, we see that the method is not04:03:59
it worked because there was not enough commonality04:04:01
ritterna let's do this, look04:04:04
when this situation happens, by the way, it’s good04:04:08
that we have poisoned such a situation now I04:04:11
I'll make the code a little smaller so that04:04:12
funny04:04:15
it turns out04:04:17
No, it doesn’t work, look what we have04:04:21
happened here we have a lot04:04:24
VIPs and method we always have to do something04:04:27
return but look But unlike04:04:31
other methods sometimes it happens like this04:04:33
the situation is that look we seem to be at04:04:36
every action is prescribed Yes, we have04:04:39
inside each Ifa there is inside LS there is04:04:44
but if we have anything in common at all04:04:49
just that it doesn’t work for the method it04:04:51
only LS works as a negation04:04:54
Therefore, if you have such04:04:57
the situation you described04:05:00
so newbies don't even think about it yet04:05:03
Why did this happen Yes, but just take it04:05:06
in this case remove it04:05:08
and leave Return for the entire method then04:05:13
there is and Then look what we have04:05:16
we will have this04:05:20
one extra line is not needed here like this04:05:23
that's what we'll have if we don't04:05:27
let's get a more valid value04:05:29
then we immediately return for the entire method04:05:33
that is, in this case we no longer need04:05:35
write it off, we will immediately return it for everything04:05:39
method And if we get valid04:05:43
values that is, let's go here then at04:05:46
us for each individual valid04:05:48
case will return its value, that is04:05:52
now the error is precisely this:04:05:55
this is the three turn it was kind of closed04:05:59
It’s clear what they wrote, but it was closed.04:06:03
it was dark, it was closed in brackets and04:06:06
as if for the whole method there is no retur04:06:09
was registered But if such a situation we04:06:13
we check for validity then if04:06:16
meaning04:06:20
just for the whole method and now04:06:24
if I run04:06:29
404:06:31
worked, that is, we don’t know it04:06:35
results in this case given worked04:06:38
our code is 0, that is, the test worked Test04:06:41
everything is fine there but the result04:06:43
we don’t know and here we are04:06:46
you need this part to print the report04:06:50
and we take it simply and simply copy04:06:55
we will print another number04:06:58
case and result please here 404:07:02
now we see that the result of you is he04:07:04
passed04:07:06
We've had a positive scenario. Let's04:07:10
now let's come up with a negative one please04:07:13
sorry, can I put a comment on04:07:16
about them and the general conditions for the method04:07:19
my code worked a little with others04:07:22
conditions the same error happened04:07:24
but I added I wrote through I added04:07:29
in this cycle just els And after that04:07:32
the error has disappeared, that is, the general word is clear04:07:35
I haven’t written it for the method yet, but04:07:37
it turns out that each of the cycles04:07:41
closed and ended on els excellent Yes but04:07:45
my point is that if you see04:07:47
error then try something like this04:07:50
fix it here because04:07:52
this is your first time working with methods that04:07:55
Something must be returned Honestly04:07:57
I myself don’t always know the situations when04:08:01
you need to write Return for the entire method04:08:03
when it’s not necessary I just see what if04:08:06
error I'm going like this is three term04:08:08
which I have there let's say is the last one04:08:10
exception of all cases, here I am just04:08:13
I'll insert it as a return of the entire method if04:08:16
no error means great04:08:19
that's it And that's where we got04:08:28
27 this is the first one prescribed Action and04:08:31
expected ordinary not a B Oh04:08:35
sorry yes and it's very good04:08:38
remark because we need exactly04:08:40
wow, this is exactly the result04:08:45
its up to keep in mind that since we are still04:08:48
didn't come here04:08:52
let us do this after all04:08:56
this is also assigned04:08:59
yes, that is, all the results that Stream04:09:02
will come here and we will appoint experts04:09:06
don't create every time just to04:09:09
remember that the action is Spectrum in this case04:09:13
either Stream or04:09:23
that is, in this case04:09:25
yes here But I won’t correct it anymore but04:09:29
as if in the future when you are on your own04:09:31
you can write04:09:34
assign04:09:41
I don’t know Well, so as not to get confused about what04:09:44
and Let's check04:09:47
Thank you04:09:51
because we work it04:09:55
some other leftists04:10:00
hunger and Yes but Let's figure it out04:10:04
what a negative scenario we have here04:10:07
maybe a negative scenario I just04:10:10
we added it and it turned out that it didn’t04:10:13
matches the text I'm on the simple path04:10:15
tested What did you do?04:10:21
we can't change or can I release04:10:25
Stream just added a letter there04:10:28
thought for example did and to check04:10:30
that everything works correctly, look here04:10:32
By the way, it’s very good that we came to04:10:36
this remark that is, look while we04:10:39
we are working on our04:10:41
I'll just comment on this in the future04:10:45
what we managed to write together Yes04:10:48
This way we don't make negative04:10:52
the scenario is not a negative scenario it is04:10:55
we just look at our test in general at least04:10:58
thinks something goes somewhere and then04:11:02
may be there What value not to give04:11:04
but he will still write this is us04:11:07
we check our test but it is negative04:11:10
the script is not a test of your work04:11:12
test negative scenario is what we need04:11:16
pass some invalid value and04:11:19
expect some error Most often04:11:22
this is what is called negative04:11:24
their scenario may be many others but04:11:28
in our case we will be more04:11:30
say that a negative scenario is04:11:32
when we Pass method Pass04:11:36
some invalid value and we must04:11:40
get some that is registered in04:11:43
our advertising You see this04:11:47
negative scenario that is given04:11:49
case that we may have a negative04:11:52
script04:11:56
12 yes And what do we expect in this case?04:12:02
Yes, we expect to receive our test04:12:06
still has to pass04:12:09
because we already have these variables04:12:12
that is, we still call the same04:12:15
the very method We transmit the number that04:12:18
in this scenario we are in the negative04:12:21
we'll get some04:12:24
then we'll compare compare ours04:12:28
this04:12:29
received it will be equal to the one we04:12:32
expect expected accordingly here04:12:36
We must also get in this case04:12:39
let's print our04:12:42
and how about with these experts04:12:45
which we already have different meanings04:12:47
at this point in time we will get that04:12:51
we have a pass or a fail and we have a PAZ To04:12:54
we really got it if04:12:57
would we expect to get there at 1304:13:01
I don't know some January04:13:09
This is what we got04:13:14
because at 13 meters this is the method04:13:18
to which We Test issues04:13:21
But what if, on the contrary, in this method04:13:25
it would have been written down that it had to be returned04:13:28
If the value is not valid then we get04:13:32
some month accordingly04:13:34
the programmer made a mistake and wrote the code incorrectly04:13:37
and what is the invalid value?04:13:39
it turns out there is something there, no matter what04:13:42
the main thing is that it doesn’t work out Era which04:13:45
was registered04:13:47
all errors are usually indicated separately04:13:51
in advertising directly separately like this04:13:53
paragraph04:13:56
a lot of attention is lost on mistakes and04:13:59
error testing is just like this04:14:01
separate section for error testing04:14:04
this is not testing there is negative04:14:07
script sometimes it's not even testing04:14:09
and there Well, this is not testing04:14:13
positive scenario scenarios sometimes it04:14:16
not testing negative scenarios but04:14:19
error testing sometimes We need04:14:21
just play it04:14:23
by our actions some specific04:14:26
error that may occur04:14:28
user and immunoscreen should04:14:30
get out This is exactly the error sometimes04:14:33
reproducing these errors is a whole04:14:36
a separate area is a whole thing, that is, well04:14:39
now we're going to talk about this in more detail04:14:41
we won't talk about this in this case04:14:44
We are not testing a bug, we are testing04:14:46
negative scenario because we have04:14:48
the number which04:14:50
it is called that is, we have it for04:14:53
outside the limits of permissible values Here04:14:57
and we expect that some kind of04:15:00
Just04:15:02
and that's it, we tested it here04:15:10
a Probably because I didn’t return everything a04:15:14
tested for January, yes, that is, a test for04:15:17
it still passes us by04:15:19
negative scenario does not mean that04:15:21
there must always be a file, this means that04:15:24
yes, with some invalid meaning we04:15:27
we expect to receive some action from04:15:30
system what error message is there04:15:33
or is there something else there I don’t know, that’s it04:15:36
as if our test is still negative04:15:39
the script must pass04:15:41
It's clear04:15:42
Do we still have time to solve the problem or is it already done?04:15:46
or you’ll have time to think for yourself at home04:15:49
Let's decide let's have time04:15:53
if possible yes but let's then without04:15:57
We’ll probably have time for the tests, but still04:16:00
yes, there are two tasks left, let's do it04:16:02
let's take this one because it's like the average04:16:05
calculate you can probably guess04:16:08
of a family of three, average age04:16:10
counting is a difficult task No04:16:16
most likely you will guess this and this04:16:19
this task can cause problems and so04:16:23
Let's do it like this, that is, you will have04:16:25
several tasks similar to this one04:16:29
task I'm going Insert my task here04:16:33
I will write methods that relate to04:16:36
this task04:16:37
no need to write a method that receives04:16:40
input distance as decimal04:16:43
I have the numbers04:16:46
no public by the way04:16:50
Yes, I don’t know yet what I will do04:16:53
return if I don't know I just04:16:55
I leave I don’t know how it will be04:16:57
to be called I know what will come at the entrance04:17:01
decimal number that is from decimals04:17:03
the numbers we now have are all just W about Flow04:17:07
we forget we know that this exists But04:17:10
use W So we'll get some04:17:14
distance, that is, we will have some04:17:16
distances That's what's written next to me04:17:23
that is, this is what I read so far:04:17:25
part recorded it04:17:28
should return the distance in04:17:31
kilometers and meters as text04:17:35
if in the form of text, then in what type?04:17:40
yes, that is, in the form of text, here it is04:17:45
accordingly, whatever the distance04:17:48
it didn't come as a decimal number04:17:51
should return text like this:04:17:54
kilometers so many meters Based on04:17:57
this number Well, and accordingly04:17:59
the string will return Yes and Let's call it04:18:03
there04:18:05
Well let's say there04:18:09
I don't know, it doesn't come to mind04:18:16
can you just call me something else04:18:19
nothing else comes to mind04:18:21
in principle it doesn’t matter. That’s what I called04:18:23
such a method Yes, it will take some kind of help from me04:18:26
decimal floating point number04:18:30
Here's what I need to do to get out of this04:18:33
numbers pull out the value of kilometers and04:18:37
meaning of meters Does anyone have any ideas?04:18:40
divide by a thousand with remainder04:18:45
let's experiment let's here04:18:48
we'll do it like this now so that it's04:18:51
everyone can see how this happens because04:18:55
if I run the method now it will be04:18:56
I don't understand why, let's be here04:19:00
just like that04:19:02
and let's say that let's say something came to us04:19:06
number 2 and 504:19:08
if we divide it by remainder by04:19:12
thousand04:19:13
to make it clear that we are at the same time04:19:16
we get04:19:19
but we can’t get it04:19:23
we'll get two and a half yes, let's do it04:19:26
let's divide it directly by 1000, that is, again04:19:30
if you don’t know how you go And here you go04:19:33
so you're just experimenting04:19:36
Let's see if we divide directly by04:19:39
a thousand that we will get and we will also get nonsense04:19:42
and we need to separately pull out the deuce on04:19:46
what do we need to share so that we have04:19:48
it turned out to be a deuce04:19:52
Let's try for 1004:19:57
this is if we know what number will come04:20:00
if we don't know what to know04:20:04
whole part Yes, and some fractional part, but it04:20:08
became acceptable 50 maybe Yes04:20:11
please if it's 2004:20:23
Irina input number04:20:25
no matter what it's just decimal04:20:28
number and you need to take the whole number out of it04:20:31
part is kilometers and the fractional part is04:20:34
label04:20:38
there you get the remainder of division by 1004:20:42
and then 1004:20:44
fall04:20:46
Okay, I'll tell you one04:20:58
if you need to divide 10 then the percentage of04:21:01
division by 1004:21:03
it’s easier to translate into a screw and04:21:07
cut off then Subtract from one number04:21:09
other04:21:11
see how to get the rest get04:21:43
maybe first maybe for action04:21:45
then divide by 10 and take the remainder04:21:48
Okay let's04:21:50
let's experiment further, that is, multiply04:21:53
by 10 and divide by what division04:21:57
which cuts off the remainder which04:22:01
stayed for 10 let's see what we do with it04:22:05
we'll give out what we'll get we'll get 5 but 504:22:10
we don't go there, we don't go there, Why Because 2004:22:15
kilometers point 5 is 20 kilometers 50004:22:19
meters04:22:21
correct at 10 per 100004:22:25
that is, we need a thousand04:22:27
multiply Naturally, yes they divide04:22:32
we get 004:22:38
but there is no operator who is like04:22:41
the mass is given off by a whole part04:22:44
Well, for the twenty they already suggested that04:22:49
easiest way04:22:52
what did what? Yes, I just didn’t do it anymore04:22:57
talk about this that we are for twenty04:22:59
just take this number and wrap it around04:23:07
and let's say whatever the number is04:23:10
20.504:23:12
in this case we will only get the whole04:23:16
we will get part of it 20 that is about04:23:19
don't think about it anymore, I just thought that04:23:22
it's obvious because someone already04:23:24
suggested that yes, the whole part is easier for us04:23:26
just pull it out by wrapping it in a number04:23:29
having translated you yes then the rest will rush and04:23:33
here's how to get the correct remainder04:23:38
5 was 500 meters probably subtract04:23:43
multiply the result by a thousand04:23:46
Okay let's try04:23:49
[music]04:23:51
Irina, you can do this04:23:52
in brackets it turns out what we wrote04:23:55
int multiplied by 25 is what we calculate04:23:58
integer plus04:24:00
then divide 20:05 by04:24:06
20:05 divide by percentage by new isolate04:24:10
to stay with us04:24:13
no Think Here we get 2004:24:16
on the contrary, we need from04:24:20
20.504:24:23
from our number 205 we need to subtract04:24:28
the whole part of this one. And then what about this?04:24:31
Maybe a thousand04:24:33
that is, yes, this is how we will succeed04:24:36
Now what is it that something is already all over me04:24:40
the computer is jumping Let's get the last ones04:24:43
Let's print it out so everyone can see it like this04:24:45
we will get 0504:24:47
But we need it not to be 0504:24:51
so that it is 500 respectively here04:24:54
proposal Yes, let's multiply all this by04:24:58
thousand04:25:06
and we get 500 but with zero04:25:10
but also take the intent from him yes04:25:14
see this is how we seem to04:25:18
together, just not knowing what would happen, we sat down and04:25:21
picked it up, I'm just showing what's there04:25:23
in homework it’s exactly the same. Sit down and04:25:26
you select that is and print and04:25:28
look like this04:25:39
So now we print04:25:42
and that's it, we got separately 20 and04:25:46
separately 500 that is, accordingly in04:25:49
in our method we first need this04:25:53
the number we received as input04:25:56
translate you go straight to our method04:26:03
that is, first any number that we04:26:06
got Let's say that kilometers04:26:10
the whole part will be04:26:15
we translate you04:26:21
variable that came to us04:26:24
so then what should we do04:26:29
from here All our fabrications are here04:26:33
I'm copying it for you to see04:26:37
more Clear That's what I copied04:26:40
that is, now we need the whole part04:26:43
for meters04:26:47
in this case we see what we are doing in general04:26:52
total result04:26:54
and in brackets we what do we take from our04:26:59
no matter what distance it comes04:27:05
further we take away from it04:27:08
a whole part of this one04:27:14
Well, either we already have this whole part on04:27:16
in fact, these are already kilometers. Why do we need04:27:19
count again if we already have04:27:21
a variable that is exactly this04:27:23
does04:27:24
distance we take away our kilometers and04:27:28
then we have to do all this04:27:32
multiply by a thousand04:27:36
and convert to04:27:40
this way it's true04:27:44
write So look at04:27:48
there will be some number of us04:27:51
which now what we have to do04:27:54
some two numbers we get that04:27:57
we have to do with them04:27:59
convert to string04:28:02
yes And for this we can for example04:28:08
make an additional variable A04:28:11
we can write right away04:28:14
and here we would say that04:28:20
let's do it like this04:28:25
such three until then we have everything04:28:28
the confidentiality was further we write ours04:28:32
kilometers04:28:35
and write04:28:44
then you understand why I do this04:28:47
did04:28:49
everyone understands or has a question why me04:28:52
I did that04:28:55
And what else04:28:57
no, everything is like a string for me04:29:01
perceived04:29:03
I'm not making an additional variable.04:29:05
string Yes, I want it right away04:29:08
everything came back like a string and that’s how I start04:29:12
from the number So as not to write separately04:29:15
number touring That is, it’s still me04:29:18
I just took some empty line04:29:21
I’ll attach it here and now I’ll have everything04:29:24
like a string and everything will be seen04:29:28
and accordingly here I will add more04:29:34
Russian letter Here it is04:29:38
And now I have this line04:29:41
is formed from all this data and it04:29:44
the same will return in this method04:29:46
I delete everything unnecessary, here you go, mine04:29:49
method Well, let's first04:29:54
let's try it quickly04:29:57
print I'm already cleaning that is04:30:03
Let's just people already04:30:06
diverge then just see that we04:30:10
we'll really get it Well, let's say from that04:30:13
same 2 and 5 if she came04:30:16
We have to get 20 kilometers 50004:30:20
meters Yes, I just forgot right here04:30:22
Let’s also add that we’ll work out our method04:30:27
There is04:30:28
we are writing a method that will do this04:30:32
I'll add it here04:30:35
then everything will be beautiful for me two04:30:38
kilometers 500 meters but now we04:30:41
we act as testers, that is04:30:44
wrote04:30:47
but we04:30:51
Here's a quick look at what we know04:30:55
In this case04:30:58
6 what we know What data04:31:02
famous04:31:05
Yes, what does it have to do with us? Yes, it was04:31:15
Say any number04:31:20
let's do 6 and04:31:24
00404:31:32
Let's go But this is negativity04:31:38
we'll do it next04:31:42
more than04:31:44
but look here we should have 4 coming04:31:48
meters04:31:50
Yes, beyond 500 we checked 50004:31:55
works Let's now here 4 Expert04:31:58
This is our result In what type04:32:08
Naturally, we have the text. We are04:32:11
in the form of text remember all this is returned04:32:13
that is, Expert, this is such a change for us04:32:17
already exists so we'll just call04:32:19
here it is and what we have in experts04:32:23
result here04:32:29
Yes, here when you write04:32:32
experts Be careful not to04:32:34
make a mistake, that is, and we should have on04:32:38
in Russian exactly kilometers and 4 b04:32:43
This is what we should get we expect04:32:47
then ours, that is, Action from Well, sort of04:32:53
in the second part04:32:55
this is what we call our method04:33:00
and I will believe here Yes and there We transmit04:33:03
the distance that is already ours04:33:07
test data04:33:10
so and what do we have04:33:14
yes yes I chose the wrong variable04:33:17
further04:33:19
we have to compare call our method04:33:25
and there we pass our04:33:30
and compare it with our Action Well,04:33:35
to see the result immediately04:33:37
report04:33:40
That's what it is04:33:44
with thongs everything is fine Well, let's see04:33:48
result04:33:49
will our value match, we fail04:33:54
that is, it did not coincide with this Well,04:33:59
yeah now we don't know what happened04:34:01
and yet we have to print04:34:04
the result of our method and04:34:09
watch debug what we have04:34:14
So let's see what we have for some reason04:34:18
it turned out 6 kilometers 3 meters Who04:34:21
any ideas why we got 604:34:28
because and because actually04:34:31
when all these translations are coming, remember04:34:33
there it's a double he does there 39904:34:38
and at some point this happened to us04:34:42
this is 399 where we translated you from us04:34:46
I only took three and this is it04:34:49
the task is for you to think at home and04:34:53
I’ll say right away that we are the fourth stream04:34:56
wrote about your surroundings but there are also you04:34:59
class its methods, that is, read04:35:03
Take a look and here it is04:35:06
Despite the fact that this is a double Despite04:35:09
that yes it was completely unpredictable04:35:12
doing all sorts of nonsense with it04:35:16
numbers in particular together 4 which we04:35:19
asked can write 39904:35:22
you need to find something like this04:35:26
way If we had these numbers04:35:29
translated correctly, I remember that then04:35:32
The owl was very indignant that in general Yes04:35:35
was you working so wrong and then04:35:37
we wrote separately not so which will be04:35:39
because we need to round the value04:35:43
But this is your task, that is04:35:46
Think because yes you will too04:35:49
many similar problems there are different numbers you04:35:53
experiment But the main thing is that04:35:55
you knew how to write this method That is04:35:58
he didn't pass here not because I like it04:36:00
does not work correctly, that is, more accurately Yes04:36:03
it doesn't work correctly in parts04:36:05
rounding you need to think about how04:36:07
round correctly so you understand04:36:09
How do we pull out a whole part from a number?04:36:12
fractional part That is, I wanted you04:36:16
have time to show04:36:17
this part Do you have any questions?04:36:21
Let's now do after the point04:36:24
400404:36:25
Well, let's do it. Can I have a stamp?Description:
On this page you can download the media «5. (09/25) Value-returning methods (Irina Z Java)» highest quality possible WITHOUT any restrictions on the number of downloads or download speed.
Preparing download options
