Flutter 10 - Abstract Classes and Interfaces Video Lecture | Flutter: Build beautiful native apps in record time - App Development

everybody this is Brian welcome to the
what are we on the 10th flutter tutorial
we're going to talk about abstraction
today so what is an abstract class use
the abstract modifier to define an
abstract class a class that can't be in
stood meaning you can't make an instance
of it abstract classes are useful for
defining interfaces what is that what
are we talking about here so there's a
few key concepts we have to understand
first an abstract class cannot be
created you can't use the new keyword
second we're going to be defining
something called an interface an
interface just think of that simply as a
contract so when we look at this is the
previous tutorial we had the mammal
class which has the has backbone hands
here and we're sending the value
actually in the mammal class the problem
with that is when we change something
down here it blew up the entire stack so
if we changed it here suddenly feline 2
stopped working lion stopped working
we're gonna fix all that today so let's
just go new project we're gonna make a
new dart console application where I
call this classes for yes let's do this
window and that will calculate the
meaning of life and everything else all
right so let's just get that out of
there somebody emailed me and said hey
stop complaining about how slow that is
mine's really slow so we're gonna make a
a new you guessed it mammal file and
we're going to say abstract class and
we're say pool as backbone
I've got weekend on the brain it's my
it's technically my Friday it's the day
before Thanksgiving I'm just kind of
cranking out a couple tutorials here and
avoid speak so what is going on here
this looks like a normal class but
there's a few minor changes the abstract
puts the abstraction to this class and
then we have some elements here that
don't have a value that's actually part
of our interface what we're saying is
anything that inherits this class has to
include these I think of an interface as
a contract it's a lot like buying a car
so let's go out and say Felyne my office
chair is driving me nuts sorry about
that
mammal and we're gonna say abstract
class feline oops extends mammal so far
nothing's really changed here right bull
has claws let's play around with us and
see what happens let's actually go out
to our main and we're going to import
that feline class here whereas a feline
cat equal new feline and oh we already
have a problem as you have suspected
abstract classes cannot be created with
the new expression we can't instigate
them can't make a new instance of it so
how do we actually do that well we have
to make a concrete class here so let's
actually go file new we're gonna make a
lion class here because why not
whoops lost my place in my notes here
alright so in our lion class we're going
to actually import the feline and then
we're going to say class lion
extends feline whoops that is not what I
wanted there we go now it's giving us
some sort of other issue it's saying
okay missing concrete implementations
because this is a concrete class not an
abstract class we have to actually now
implement that interface are actually
interfaces because this is an inherited
interface so when we mouse over here you
can see that it has Clause has backbone
has hair so it's missing the
implementations from feline and mammal
and you can actually right click on this
I'm going to generate and then implement
methods and you can see exactly what
it's missing and what's from what it's
from
you can even double click and create it
which I'm not a big fan of because I
don't like the way it does it but if
you're curious it just looks like that
so we're gonna say pool as backbone and
we're gonna actually implement this now
wool has hair bull has claws misspelled
has twice Wow
so we have everything that we need now
we can actually make an instance of this
thing so let's change this we can now
actually make an instance of this thing
and we can actually not speak and see
what we want it to do now I've never
heard a lion say hello world so we're
kind of changed that a little bit here
we're going to go in here and we're
going to say we're make the lion roar
instead so you can see how it's very
similar to actually just inheriting and
extending a class but there's some key
caveats here first off you're not
setting this value in the abstract class
you're not setting the actual getter so
that's called an interface you actually
have to have that in your concrete class
without it it will actually generate an
error see how suddenly it's complaining
missing concrete implementation of
mammal dot has backbone you would do
that for certain things for example if
you're building a car or truck you know
not all cars have all the same features
but you want certain things that make up
a car car has four wheels you know for
example car has a windshield most of the
time if you pay extra usually it has a
windshield so the other key component
here that we're missing is you can
actually do some really cool things with
abstraction and interfaces so we're
gonna actually make another file here
and call it a bird and we're gonna say
abstract class bird and we're gonna say
bull has wings
now let's just get a little crazy here
let's make another one
score the end I don't know what that
thing's called on the back of a square
beam I just call it a stinger why not
so what are we doing here we're just
making abstract classes or actually
making interfaces so we're going to make
a concrete class now and we're gonna
call it monster we're gonna actually
build a monster here because that's just
how cool we are
we have nothing better to do we're gonna
build a monster so we're gonna make our
bird we're gonna import a bird we're
going to import the Scorpion and we're
gonna actually import the feed line and
this is an example of interfaces so I'm
just going to put that in case anybody's
wondering so when I say class monster
implements and we're going to say bird
feline and scorpion so now we've got
multiple inheritance going on here but
as you can tell we also have multiple
things that we're gonna have to make
concrete implementations of so we're
gonna say bool stinger yeah let's give
our monster stingers and let's say pool
has hair
mmm do we want a hairy monster why not
and through the magic of copy and paste
we're just going to a couple these
so we're going to thin and then we're
going to say I don't know what noise a
monster would make I mean some gobbly
gook I don't know that's a monster noise
ladies and doing and that's what that is
all right so what are we missing here
has claws and heads because we
misspelled this
all right so now we've got our monster
clashing CSL icon over here and you can
actually see implements method has
colossi and feeling you can actually
click on that it'll take you right to
the implementation of it alright so
let's go back to our monster here and
let's go to you just cheer me in my
whole little office here just falling
apart
alright so monster um what do we want to
call our muscles call the Babbitt duck
if you've ever seen that movie it's kind
of a crazy movie gonna make the Babbitt
duck speak and why not let's just run
this see what happens
bang so there's our lion and there's our
monster making some crazy noise a lot of
work great but what does it really
bought us well we now have two different
extensions of this feline class in Lion
and in Monster and you can see how we
have multiple inheritance going on here
and notice the use of the implements key
word here that is key if you try to do
extends that's a different thing it's
it's kind of hard to really explain but
when you're extending a class you're
extending the class you're taking it and
making it more when you're implementing
it you're actually implementing it
you're saying I'm going to follow the
directions so really we're just using
drum roll drum roll you guessed it
interfaces through abstraction and what
is it bought us well we can actually say
we don't want our monster to have hair
and when we run there's no error where
if we had done this through pure
inheritance and we put has hair all the
way back up in mammal because we inherit
feline this whole thing would have just
exploded and it would have said nope
assuming we have done an assert down
here that's a lot of talking but as you
can see you can do some really just
crazy outlandish things you can make
like a airplane that's also a
refrigerator or you can make a car
that's also a helicopter so that's a
it's a really good example of
inheritance class abstraction and
interfaces for the source code for this
and other tutorials I encourage you to
visit my website void realms comm click
on tutorials and drumroll there is a
void roms Facebook group we have 1700
other programmers in it go ahead and
click that link takes you right to it
and ask to join