Prática de Shadowing: Records In Java - Full Tutorial - The Best New Java Feature You're Not Using - Aprenda a falar inglês com o YouTube

records are a relatively new addition to Java

⏸ Pausado

Velocidade:

207 frases

Se as frases estiverem muito curtas ou longas, clique em Edit para ajustá-las.

records are a relatively new addition to Java

that you can use to avoid a ton of boilerplate code in certain types of classes.

In this video we'll talk about exactly what records are,

how they can simplify your code,

and when and how you can implement them into your Java programs.

My name's John and I'm a lead Java software engineer.

I also have a full Java course available and a link down in the description so go check it out.

To understand why records are so useful it helps to know what programmers had to do before they existed,

which is probably what you are still doing if you're not using records yet.

Let's say you wanted to make a very simple Java class

that all it contained was a bunch of fields to carry data about something.

These kinds of classes are super common in the Java world.

Like for example if you had an employee class that carried the employee's name and their employee number.

Maybe that employee info exists in some database

and all this class has to do is hold that employee info and return it to the user.

So before records existed, here's everything you had to do.

Let's give it two private fields,

a string employee name, and an int employee number.

Let's also go ahead and make these final so they can't be modified after the employee object is created.

So because these two fields are final,

we want to be able to set them right when we create an employee object.

So we have to add them to a constructor.

So maybe our constructor is just public employee class and

that takes in the string name and the int employee number as parameters.

Then all it does is just set this.name equals name and this.employee number equals employee number.

Then let's go ahead and generate some getter methods for these two fields so they can be accessed from outside the class.

Next you also want a good two-string implementation

that returns all the data in the class in a nice

readable string format something like this next you're going to want

to override the hash code method with a good implementation as well now we're almost done

but not yet you're also going to want a good equals

method implementation to check whether one instance of this class is equal to another

so now finally after all of

that we can come back here to our main method

and create a new employee class object we'll just call it employee equals new employee class

and we pass in a name and employee number here in the constructor.

And there you go!

But that was a whole lot of code!

That's almost 50 lines of code for a class that does something so simple like hold two pieces of data.

But that's how you have to do it with a traditional Java class.

Now to compare, let's show how to do the exact same thing but using a record.

We just say public record.

We'll call it employee record.

It has a string name and an int employee number.

Open and close the curly brackets and that's it.

This single line of code gives us the equivalent of everything we just created in this employee class.

So now with just that we can go back here to our main method

and create an employee record object in the exact same way that we created the employee class object.

So we'll call this employee record equals new employee record

and pass in the name of Kramer and Kramer is employee number 54321.

So now let's break it down a bit.

To create a record first we say public record instead of public class.

That's because a record is a certain special type of class,

kind of like an enum is also a special type of class.

Next we just give it a name.

Here we're calling it employee record.

Next in parentheses we list out all the components

that we want to hold inside our record in a way that looks a lot like the parameters to a method.

So this is just all the different data elements that you want to hold in your record.

So here we have string name and int employee number.

So with just that, Java gives us a whole ton of other stuff for free.

First, it generates private fields for all the components that we listed here,

just like we did over here in our employee class.

These will also be generated as final fields by default,

just like we did in our class,

so that they can't be changed after an employee record object is created.

It also generates public getter methods for each of these components,

similar to the getters that we created here.

The only difference is that the getters that it automatically generates for a record don't have get in their method name.

They just have the name of that field.

So just to demonstrate that back over here in our main method,

if we wanted to print out this employee class object's name we would just call employee dot get name.

But to do the exact same thing with our employee record

object we would just have to call employee record dot name without the get

but if we go ahead and run our program we can see

that the functionality is the same next it will also generate

for you a certain type of constructor now you might know

that when you create a normal java class what it automatically creates for you behind the scenes even

if you don't make any constructor at all is a no args constructor like this that doesn't take any parameters.

When you create a record however it works a bit differently.

Instead what it creates is a constructor like this one

that takes in as parameters all of the different components that you listed up here in the record declaration.

Then it sets all of

that record's fields with the values in those parameters just like we did over here in our employee class constructor

that we made.

This type of constructor that is automatically generated when you create a record is known as a canonical constructor.

Even though we didn't explicitly create any constructor over here in our record,

we were still in our main class able to call a new constructor and pass in our two component values.

And that's because that constructor was automatically generated behind the scenes.

There's also some really cool things that you can do with constructors only in records

that you can't do in any other type of Java class that we'll talk about in just a little bit.

Finally, it'll also automatically generate implementations of the toString,

equals, and hash code methods.

Very similar to the ones that we created over here in our class.

So the toString method will give you the name of the record class

and then the name and value of all of its components.

And we can actually test out

that automatically generated toString method just by passing in the actual object to the system.out.println method

because when you pass in an object

100

that isn't a string to system out print line it automatically

101

calls the toString method to get the string representation of that object.

102

So if we go ahead and run our code we can see

103

that it prints out the contents of these objects in a very readable way.

104

So we can see that the record automatically created a toString

105

that has the name of the record and then the value of each of its components.

106

And it will generate equals and hash code methods

107

that will consider two objects of that record class equal if all of their components are equal to each other.

108

These three methods can be somewhat tedious to write,

109

and so often programmers will just skip implementing them.

110

And even if they do bother to do it,

111

they can be really easy to mess up,

112

especially the equals and hash code methods.

113

So with records, you don't have to worry about them at all.

114

It will automatically create them for you.

115

You are allowed to override those methods with implementations of your own,

116

but most of the time there's just no reason to do it.

117

One thing to note is that it does not generate any setter methods.

118

One of the main features of a record and one of the main reasons to use a record

119

is that they are immutable by default.

120

That just means that a record object cannot be changed once it's created.

121

Once your employee record object is created with a certain name and employee number,

122

you can no longer change this employee record's name or employee number to anything else.

123

So it really wouldn't make sense to have any setters created anyway.

124

Now there are a few other things that you'll have to know if you're going to be using records.

125

First, like any other class,

126

you can create instance methods if you want.

127

So for example, you might have some method public string name in uppercase.

128

And maybe all that does is just return name dot to uppercase.

129

And so you can call this method on an employee record object just like you would any other type of object.

130

So over here we can call employee record dot name in uppercase.

131

And if we run it,

132

we can see that we get the employee name in uppercase.

133

You can also create your own static methods as well.

134

So like public static void print whatever and that can just print whatever.

135

Of course to call a static method you should call it using the name of the class itself

136

and not a certain instance of that class.

137

So over here we would just call employee record with capital E capital R dot print whatever

138

and of course that will just print whatever.

139

You can also create static fields like you could in any other class.

140

For example, you could have a public static final string default employee name equals George.

141

However, you cannot define your own non-static instance fields.

142

So something like private string something,

143

you are not allowed to do this.

144

You'll get an error that says instance field is not allowed in record.

145

Any instance fields like this that you want have to be defined up here in your list of components.

146

Another thing is that records cannot extend any other class.

147

So up here if you try to do something like extends employee class you would get an error

148

that says no extends clause allowed for record.

149

All Java records implicitly extend the record class.

150

Kind of like all enums implicitly extend the enum class.

151

So because Java doesn't allow multiple inheritance your record can't be a child of any other class.

152

Records are also implicitly final classes,

153

which means that they can't be extended by any other class either.

154

You are allowed to put final in your record declaration,

155

but it's redundant to do so because it's already automatically going to be final.

156

However, you are allowed to implement interfaces in records.

157

So to do

158

that right up here after your record declaration like any other class you can just put in implements whatever interface you want.

159

So if you want you can implement the runnable interface.

160

It would probably be kind of weird for a record to be runnable

161

but if you want to do it you can do it.

162

You just have to implement this run method like you would for any other runnable.

163

I mentioned before that we'd talk a little bit more about constructors in records.

164

Remember that for records, Java will automatically create this canonical constructor

165

that takes in all of the components and just sets all of those fields based on those components that are passed in.

166

So the idea is once you use that canonical constructor to create an object of that record class,

167

all of its fields will be set and can never be changed.

168

The record only exists to carry that collection of data through your program.

169

However, you can also define your own constructors.

170

First, even though it gives you that canonical constructor for free,

171

you can override it with your own implementation if you want.

172

So if I want, I can create public employee record,

173

which takes in a string name and an int employee number.

174

So to override that default constructor,

175

it has to take in the exact same parameters in the exact same order.

176

One reason you might want to override the default constructor is

177

just to do some sort of validation on the values being set.

178

Like maybe it doesn't make sense for an employee number to be negative.

179

So you might do something like if the employee number is less than zero,

180

throw a new illegal argument exception.

181

Employee number cannot be negative.

182

After that though, you still have to set your records fields using the values passed in like this.

183

So this.name equals name and this.employeeNumber equals employeeNumber.

184

However, with records there's a really cool little shortcut you can use to override your canonical constructor

185

if you want and that's called a compact constructor.

186

This is something that is unique only to records.

187

All a compact constructor is is this exact same constructor except with the parameters removed and these assignments removed.

188

It will automatically add these same parameters in the same order,

189

and at the end of this constructor it will automatically set all of this record's fields with those parameters.

190

You can also have additional regular constructors that take in different sets of parameters if you want.

191

And for those all the normal constructor rules apply.

192

You can learn a ton more about Java constructors in this video here.

193

I think the ability to create this kind of compact constructor is really cool

194

and it really serves to illustrate exactly why records exist.

195

Records are just a super simple

196

and fast way to create a certain type of class

197

that we have to use all the time in the Java world and that's a class that just holds data.

198

Now remember we didn't even need any of this extra stuff we added

199

so just this is all

200

that we needed to create a full featured class whose purpose is to just hold and carry this data.

201

And

202

if you ask me that's a whole lot better than having

203

to write out all of this to do exactly the same thing.

204

If you enjoyed this video or learned something please let me know by leaving a like.

205

Be sure to subscribe for more java tutorials

206

and for my full java course just check out the link down in the description.

207

Thank you so much for watching I'll see you next time.

TRENDING

Populares

O que é a Técnica de Shadowing?

Shadowing é uma técnica de aprendizado de idiomas com base científica, originalmente desenvolvida para o treinamento de intérpretes profissionais. O método é simples, mas poderoso: você ouve áudio em inglês nativo e repete imediatamente em voz alta — como uma sombra seguindo o falante com 1-2 segundos de atraso. Pesquisas mostram melhora significativa na precisão da pronúncia, entonação, ritmo, sons conectados, compreensão auditiva e fluência na fala.

☕ Pague-nos um café

O ShadowingEnglish permanece 100% gratuito graças ao seu apoio. Os custos de servidor e IA são altos — seu café nos mantém ativos! 🙏

Doar via PayPal

ShadowingEnglish.com – Prática de Shadowing em Inglês

Fale inglês fluentemente usando a técnica de Shadowing. Ouça vídeos nativos do YouTube, repita frase por frase e desenvolva pronúncia e fluência reais — usado por estudantes de IELTS no mundo todo.

Prática de Shadowing: Records In Java - Full Tutorial - The Best New Java Feature You're Not Using - Aprenda a falar inglês com o YouTube

Populares

Por que praticar a fala com este vídeo?

Gramática & Expressões em Contexto

Armadilhas Comuns de Pronúncia

O que é a Técnica de Shadowing?

Prática de Shadowing: Records In Java - Full Tutorial - The Best New Java Feature You're Not Using - Aprenda a falar inglês com o YouTube

Baixar aplicativo

Por que praticar a fala com este vídeo?

Gramática & Expressões em Contexto

Armadilhas Comuns de Pronúncia

O que é a Técnica de Shadowing?