Name: Kotlin課程--初學者教程。 (Kotlin Course - Tutorial for Beginners)
Uploaded: 2021-01-14T10:20:09.000Z
Duration: 2 h 38 min 31 s
Description: 【看影片學英語】數萬部 YouTube 影片，搭配英漢字典即點即查，輕鬆掌握單字發音與用法，長久累積看電影不必再看字幕。

Hi, my name is Nate and welcome to this tutorial on the Kotlin programming language. If

情態副詞

you're not familiar, Kotlin is a statically type programming language developed by JetBrains.

It's been around since about 2011 and has steadily increased in popularity ever since.

Today it's actually the primary development language for Android and in this tutorial

we're going to move from basic topics like setting up your first project up to more advanced

things like modeling data and working with higher order functions. The goal for this

tutorial is to help you understand how the work with Kotlin so that you can then take

that knowledge and apply it to building applications across mobile, web and native code. So without

further ado, let's jump in and start building our first Kotlin project.

The first thing we're going to want to do is to install JetBrains IDE Intelijay so that

we can work with our Kotlin code on our development machine. The first thing to do is to open

up your browser and search for it. Until Jay here, you should see a download link and we

can click on that to be taken directly to the download page. Now I'll be working on

a Mac, but intelligent is available on windows and Linux as well. You'll also notice here

that there are two different versions of intelligence. There's the ultimate edition and the community

edition. The ultimate edition has a lot more features that we need and there's also a paid

product. The community edition is supportive for JVM development and Android development,

so it's perfect for what we want to look at in this tutorial. When you're ready, go ahead

and click the download button and that should start the download. Once the download is complete,

we'll get started on installing the IDE and we'll take a look at hello and Kotlin. Now

that our downloads complete, we can go ahead and onto the installer

and I'm Mac. We'll drag the application into our applications folder which will start the

install process here for us. Once the files have been transferred to your machine, we

can go ahead and start intelligent for the first time to start the install process. In

this case, we want to do a fresh install, so click that. Do not import settings and

Go ahead and accept the privacy policy. Hit continue. Now here you can choose your theme.

I'll choose the dark theme. Go ahead with the standard and tell the J key settings here

and we'll go ahead and click next through to finish the setup process and then we'll

finally launch intelligent IDE community edition.

The next thing that want to do is create our first Kotlin project here in intelligence.

So to do that we'll click on create new project. Now over on the left side of this panel, we'll

see a number of different project templates to choose from because we are going to be

learning about Kotlin. We want to make sure that we have selected the Kotlin template.

Now within this, there are a number of different Collin project types that we can choose from.

The default here at the top is a Kotlin module for a JVM target, so this would be sort of

a standard, just Kotlin project that could target a the JVM. I have nothing else added

to it. Other examples would be, you know Caitlyn module for a Java script target or I taught

in the native targeted or an Android or iOS mobile target. So all of those are interesting

but more advanced. For this, we want to just stick with the basics so we will make sure

that we have selected Kotlin module for JVM target and go ahead and hit next. Then we

want to make sure that we name our project something meaningful. So in this case, let's

call it hello Caitlyn. We'll make sure that our project location is set and then we'll

Now we have an empty Kotlin project. Let's start by adding our first common file so that

we can write a simple hello world example. So do that. We'll come over here to the left

and here we have the project panel within intelligent. You'll see at the top we have

our hello Collin module. If we expand that we can see that we have a source directory

but it's currently empty. That's right. Click on source, go to new and then Caitlyn file

our class. And here we're going to type main for the name of our file and then we will

leave this as file so that we can create our main dot KT file. Now we can get started by

writing our main function here in our main dotK T file. So to start we'll type in fun

Maine, no parameters and then we can type print Ellen parentheses.

Hello Collin. And from there you'll see now that we have this little green arrow intelligent

recognizes that this is an executable main function within this uh hello Caitlyn module.

So we can actually go ahead and run this. We'll select to run main KT and that'll take

a second to go ahead and build the project. And then we will get our output window here

at the bottom and you can see that we have hello Collin. Now one extra quick fun fact

here and tell Jay comes with a number of live templates built it. This means that you can

type something and it will know how to complete that and auto-generate some code for us. So

we can start typing Maine and then hit enter and it will automatically generate a main

function for us. And then we are free to fill in with our, hello Caitlyn text.

Awesome. You've just written your first program in Kotlin. Now let's dive in and start actually

learning the language to get started. Let's look at how you can define variables in Kotlin.

Now there's two types of variables. In Kotlin we can define mutable variables, which can

have their values reassigned. Those are declared using the VAR keyword. Or we can define local

read only variables, which can have their value assigned only once these are defined

using the vow keyword. So to define a variable, we can use the keyword of our choice. So in

this case we use vow, then we'll define the name and then we need to indicate that type.

In this case I'll say a type string and then you can use an equals and then you can assign

the value to this variable. So in this case I've defined a variable called name of type

And then I have assigned the string literal Nate to that variable. Now, like I mentioned,

vow our assign once variables, meaning this is read only once it has a value assigned

to it. So if I tried to update the name of this, we'll see that we get an error. That

area says vow cannot be reassigned. So this is our indicator that if we need to be able

to update the value of our variable, we're not going to be able to use a vow. Instead

we can use a VAR. Now VAR variables can be reassigned as many times as you want. So as

soon as I updated that keyword, now I can update the value of our name variable. And

then if we want to use that variable, we can pass that in to the print function here. And

if we then run our main function, well now see the output value of that variable at this

time is blank because we had reassigned it.

If we remove that reassignment, well now see that we get this little underlying saying

variables never modified and can actually be declared immutable instead using vow. So

this is nice that the IDE gives us that helpful hint. So in this case we'll go back to a vow.

And now if we rerun this once again, well now see that my name was printed out to the

console and this example we're using a local variable, meaning that the variable that we

have defined is available locally within the current scope. So in this case it's available

only within the main function we have defined. Now in Kotlin you can actually declare variables

outside of any type of enclosing function. Our class, all you have to do is declare a

variable within a Kotlin file. So in this case we've moved our variable name outside

of the main function into the main dot. Kate. He file variables defined like this are referred

to as top level variables. And you see now that we've moved this outside of the main

function, we can still run it and our variable is still completely valid.

Top level variables can be worked with just like a local variable. So we get a fine and

an additional variable. This time we'll say VAR greeting of type string equals hello.

We now have a publicly available top level variable called greeting. So now if we wanted

to come down here and print out a greeting before the name, we could do that by calling

print line and passing in greeting. We can also modify that greeting because this is

a mutable variable and if we then print out this new value, we will see that the message

字幕列表影片播放

Kotlin課程--初學者教程。 (Kotlin Course - Tutorial for Beginners)

access

expression

instance

fancy