All language subtitles for 12. Class Constructors & Named Argumentsf

With this first output on the screen, before we dig deeper into this app and build something more beautiful,

let me take a step back and go back to Dart because it's so important that you also understand Dart

whilst we are working on this.

For one, let me go back to MaterialApp and text.

I mentioned that these are not functions but classes and yet, I pass some data to them right,

I passed the hello string to text and I even have this more strange looking home colon thing here for

MaterialApp.

Let's go back to our little Dart example here on DartPad which we started working on earlier.

There we also have person and person has some default values here.

Now we can override these defaults but what if our class should be a bit more generic, for example for

a person it doesn't really make sense that the default would be Max and 30,

if we're for example building an application where users can sign up, then why would we assume that the

average user is named Max,

that does not make any sense.

So you might want a setup where you have no initial values but instead when this class gets created,

we can pass the initial values here between the parentheses

so that I have Max and 30 here and I have Manu and 31 here and then I don't need to override

my name down there.

That would be nice but right now, it's not supported,

we can support it by adding a so-called constructor to this class. A constructor is a function inside

of a class and therefore we could also call it a method because functions inside of classes are methods,

it's just a different name,

it's a function that of a class which is different to other functions inside of the class in that it always

executes only once when we create a new object based on a class which happens when we call a class

like this.

You add a constructor by repeating the name of the class, in this case person like that. In other programming

languages,

you would write constructor for example but in Dart, it's really just the name repeated.

You add parentheses, like for a normal function and then you add curly braces which holds the code that

should run

when this class gets created.

Now here, you can accept arguments like name and like age or input name and input age to avoid confusion

with the names we chose up there, though you could use the same names because Dart also has a feature

called scoping, which means that if you had the same names as up here, here in the arguments, it would

not override this or anything like that,

instead it would simply just create new variables inside of person,

it always creates new variables for every argument you get and these variables could have the same name

and they would not clash because Dart would behind the scenes manage that separation between your

class level variables and your function or constructor level variables.

But here, to not confuse you,

I chose different names and now inside of the constructor body, we could refer to our name up

here by just typing name and assigning input name as a value and the same for the age.

Now by the way, if you had the same name,

so let's say I had age here, then of course Dart would not be able to figure out if we mean the age up

here or the age here when we're using age in the body of the constructor and therefore, it gives us a

special this keyword which refers to the class itself

and with this .age, we can tell Dart that here, I want to refer to the class level age variable whereas

without this, I want to refer to the function or constructor level variable.

So this is the code we can use, we could do the same for name, just want to show the two different options

and now with that, we have a constructor which allows us to create our object if I run this with different

default values down there and which is of course pretty convenient and a feature you'll use quite a lot.

That's also the feature text uses here which accepts a string which you can pass to the constructor

which you will use to output something because having a default text in the text class would not make

that much sense.

Now besides using this syntax here, you can also use named arguments and that means that you simply wrap

that here in curly braces.

Now what this does is, it means that now these arguments are all optional and therefore of course you

should write code that can live with no values being provided and that you do target them by name

when you're creating your data.

So here you would then target an argument by name, by repeating its name here when you create an instance

based on that object, like this, inputName: and also age:.

That concept of named arguments is also not only available for constructors but also for normal functions.

Now if I repeat this,

it still works.

Now why would I use named arguments?

It's especially great for constructors or functions that take a lot of arguments because if you have normal

positional, so non-named arguments, you have to remember which argument goes into which position, that

the name is the first and the age is

the second argument. Now obviously for a constructor with two arguments, that is doable but if you had

10 arguments, it would be more difficult. By using named arguments,

you can simply use the name to assign it and you can also mix and match the order here if you wanted

to.

So here I could first assign the age and then name because I'm targeting it with the name, right,

so with the name of the argument and therefore, the order doesn't matter, here for positional arguments

as the name suggests, it does matter. Now since I mentioned that all named arguments automatically are

also optional,

you also should either define default values here with an equal sign, right in here in the argument list,

that's something you can do. Now in case you don't provide an age,

the default value would be used and that can of course be useful to avoid that your code breaks or

you add a special annotation, the @required annotation which will ensure that the compiler yells at

you if you don't provide a value for that named argument.

So with that, you turn that optional named argument back into a required one.

Now side note, required is not a feature built into Dart and therefore here, I get an error that Dart

doesn't understand what @required means but it will be built into Flutter,

so here we will be able to use that and with that, it's hopefully a bit clearer

what named arguments are and what constructors are. Now

one last side note,

if I remove @required here, one last side note because it is important, let me add the default value

again. Sometimes,

this set up here where you get certain data and you want to assign it to variables of your class is

so common that you don't have to write all that code,

instead you can get rid of your constructor body, add a semicolon after it and now just make sure that

you use your variable or your property names up here, so that you use name and age

and now here,

you can simply target this age and here also, this name, now without a type assignment because we

got the types here already and this is a shortcut understood by Dart which tells Dart, okay what we receive

as a name argument will be stored in a name property,

what I receive as an age argument will be stored in the age property and

now since I renamed this to name again because now the names here have to match, since I rename this

to name, I also have to rename it down there of course. And now this works again and it's of course shorter

than writing that extra function body for the constructor.