And then you have another person s here.
So he had this person as this token is for this punching power required call and Space Person D just
punching power required.
And if you have a person and hear new line character person as punching spit required to call him space
gets a punch in space speed required as you can see this token this person these four these are get
punching speeds require required hit.
OK.
So hopefully that makes sense.
And now let's actually go back and go inside of these are kick boxing that of a fight here and now.
So here after the name of this kickboxing class here as you can see just a pin here extends boxing.
So here if you are actually inheriting all of the features and behaviors that are actually inside of
these boxing class.
OK.
And as you can see inside of this boxing class this boxing class actually inherits all of the features
and behaviors that are actually inside of this sport class.
OK.
And this sports class actually implements this life insurance interface.
So because inside of this boxing class we actually are provided an implementation for this evaluate
cost of insurance Smurfit that is inside of this life insurance interface.
OK.
Our inside of this kickboxing class we do not need to actually provide another implementation for that
abstract benefit for that effort that is inside of this life insurance interface because this boxing
class actually did this job for us.
OK.
This boxing class actually provided an implementation for the Smurfit and this kickboxing class can
inherit that implementation.
OK.
So here.
Let's actually create some instance variables for this kickboxing class here.
OK.
So as you can see here I actually declared two instance variables here ain't Keech power required to
teach speed required.
So let's actually declare this instance variables as private.
OK.
And here private's.
So now let's actually create a constructor for these kickboxing class.
Ok now I'm going to actually pasting this constructor here and then I'm going to try to explain to you
what's going on here.
So as you can see here this is my constructor for this kickboxing class here.
OK.
And as you can see the access modifier of my constructor is Puplick the name of my our constructor is
kickboxing.
So this name must be the same as the name of this class.
OK.
And this a constructor actually accepts some arguments.
So the first argument that this kickboxing constructor accepts is types think name.
The second argument is of type again.
Strange rules in uniform int speed required in power required in punching power required int punching
Spizz required in cheek power required an int like Keech.
Speed required.
And we have this this ain't custom insurance here and here I'm going to the inside of this constructive
here.
I need to actually initialize.
OK I need to initialize the constructor of the superclass.
So what is the superclass the superclass.
Is this boxing class.
So here super name rule is uniform speed required the power required punching power required punching
speeds required and this cost of insurance here.
OK so if you go back inside this boxing class as you can see this class actually accepts some arguments
as against it is a constructor that is inside of this class accepts some arguments as you can see name
rules uniform speed required the power required punching power required punching speeds required and
this cost.
Cost of insurance.
So inside of a kickboxing class we need to initialize the are actually the constructor of the superclass.
OK because we are inheriting all of the features and behaviors that are inside of this muxing class
OK and then we can actually initialize the instance variables that are actually specific only to this
sheet boxing class.
Is that a Keech power required assignment operator Keech power requires these dots Keech Spizz required
assignments operator Keech Spizz requires.
So now this actually creates some getters and setters for these instance variables.
So here just right click here.
Inside this class generate get here and set here and select.
These these these two instance variables and then click on OK.
So as you can see here the ID are automatically generated.
These are get hills and settles for us.
OK so now inside of this class this actually overwrite the twisting method that we actually inherit
from the superclass.
So what is the superclass the superclass is this boxing class and we can actually inherit these two
string Meffert here.
OK.
So inside of this kickboxing class that's actually just typing to stream.
OK.
And here in say the policeman for let's actually read this line of code here.
And that's actually putting our own implementations that are actually in specific.
Only two Ds these kickboxing class.
So here I can just type in return OK.
Stream data formats and inside the.
I'm going to actually actually are pasting a piece of code and then I'm going to explain to you what's
going on here.
So here as you can see inside it up of course I actually specified the formatting of my string value.
OK.
Percent.
So this person is for these superb that string Meffert here as you can see I am calling the twisting
method that is inside of the superclass boxing on the super here.
OK.
So it's going actually to execute these lines of code.
This piece of code as you can see here inside of these two string if it is going I should return a string
value.
OK.
That has actually this throughput that was strange I guess punching power required and get punching
Spizz require you.
OK.
And here as you can see we have a per cent and a new character.
A percent is here as you can see it is this.
This is for this Keech power required Colan person deep.
This is for a good power the quiet person as person person and person as hard as you can see Keech speeds
requires a colon and we have a person here.
And this is for get Keech speed required.
And here we need to put a semicolon at the end of our statement.
And now let's actually go inside of these students class.
OK.
And as you know a student cannot be actually a sport or K as a student is actually.
And other concepts are key.
So if the student can actually implement it can actually implement this life insurance interface life
insurance.
So here we need to actually pro-white as you can see it says the class student must either be declared
as abstract as an abstract class or implement abstract method evaluate cost of insurance.
OK so here because student is not an abstract concept we need to actually provide an implementation
for the abstract method that is inside of this life insurance interface.
OK.
So first of all let's actually provide some instance variables for this student's class.
OK.
So now we're going to actually paste in some instance variables for these students class.
So as you can see here these are my instance value bets for this student class.
String name string course name into custom insurance.
So he had actually declare this instance variables as private.
OK.
Here private and private here.
OK so now let's actually create a structure for these student class.
Now I'm going to paste in this constructor here and then I'm going to explain to you what's going on
here OK.
So as you can see here this is my constructor for these students class.
So publish student and this constructor actually accepts some arguments here as you can see string name
string course name end.
Cost of insurance.
And here as you can see inside of this constructor I am actually instantiating the instance variables
that are actually created inside of this student class.
OK so does that a name assignment operator name does that call same assignment operator course name.
That are cost of insurance assignments operator.
Cost of insurance.
OK so now let's create some getters and setters for these instance variables that are inside of this
student class.
So here inside this class just right click here.
OK.
Generate.
OK.
And then I click on get here and setter here and here select all of these instance variables and then
click OK.
So as you can see here the Android studio ID generated these are instance.
These are getters and setters automatically for us.
OK.
So hopefully that makes sense.
And now as you can see the compiler is complaining and it says the classes students must either be declared
abstract or implement abstract method evaluate costs of insurance.
So here we need to actually implement the method evaluate cost of insurance.
OK so evaluate cost of insurance and as you can see your overriding Ismir for the fee.
So let's actually get into this implementation in say that this evaluate costs of insurance Smurfette
and now inside of this measure they can actually be putting our own implementations.
So now I can I should return the value of the cost of insurance instance variable and that I need to
put in a semi-colon at the end of my statement.
OK.
As you can see here I have a good term for it.
And I have a sitter in my faith for this cost of insurance.
OK so here I could just refer to the name of this get her if it gets cost of insurance.
OK.