Съдържание

• Бързо въведение - C # срещу Java
• Здравей свят! в C #
• Започване на C #: методи и класове
• Използване на методи
• Използване на променливи
• Предаване на аргументи и използване на низове
• Научете C # контрол на потока и изградете прости викторини!
• Следващият път

В тази публикация ще научите за C # програмирането за Android, както и къде се вписва в голямата схема на разработка на Android.

Ако се интересувате от това да станете разработчик на Android, може да останете под впечатлението, че трябва да научите един от два езика: Java или Kotlin. Това са двата езика, официално поддържани от Android Studio, и затова двата езика се фокусират върху много ръководства и ръководства. Разработката на Android е много по-гъвкава и разнообразна от това и има много повече начини да се подходи към нея. Много от тях включват C #.

Прочети:Искам да разработя приложения за Android - кои езици трябва да науча?

C # е езикът за програмиране, който ще използвате, ако решите например да създадете игра в Unity - което също се оказва най-популярното и широко използвано устройство за игра в Play Store. По принцип е полезно да научите C # програмиране, ако изобщо се интересувате от развитието на играта.

Трябва също да научите програмиране на C #, ако искате да използвате Xamarin. Xamarin е инструмент, който позволява на разработчиците да създават приложения, използвайки Visual Studio, които лесно могат да бъдат пренесени както в iOS, така и в Android, идеални за проекти на крос платформа.

Така че, с казаното, определено има основателна причина да научите C # програмиране за Android. Нека да разгледаме какво трябва да знаете.

Бързо въведение - C # срещу Java

C # е обектно-ориентиран език за програмиране, разработен от Microsoft около 2000 г., като целта е да бъде модерен, прост и гъвкав. Подобно на Java (разработена от Sun Microsystem през 1990 г.), тя първоначално се е развила от C ++, гарантирайки, че има много прилики между двете. Например, и двамата използват една и съща „синтактична основа“, което означава, че те ефективно използват много една и съща терминология и структура. Има няколко малки разлики, но ако сте запознати с един език, тогава би трябвало да можете да разберете много от другия, без да е необходимо да сте го научили конкретно. За начинаещи обаче мнозина ще открият, че е малко по-лесно да научат C # програмиране.

Като обектно-ориентирани езици и C #, и Java ще описват обекти чрез класове. Това е модулен подход за програмиране, който позволява да се използват фрагменти от код отново и отново.

Когато C # се различава от Java обаче, е в използването на делегати, подхода му към слушане на събития, виртуални срещу крайни свойства, неявно кастинг и други.

Добрата новина: всъщност не е нужно да знаете какво повечето от това означава, когато за пръв път започнете да изучавате C #. Основното извличане е, че структурата е малко по-лесна за изучаване в C # и обикновено изисква по-малко писане. Това е особено вярно, като се има предвид, че когато научите Java за Android, ще трябва да се запознаете и с многото класове и API, необходими за изграждането на приложения за Android. По този начин може да научите и програмирането на C # като стъпка към Java.

Здравей свят! в C #

Традицията в света на кодирането е, че всеки път, когато научите нов език, трябва да създадете проста програма, която да показва „Hello World!“ На екрана. Това по принцип гарантира, че можете да получите необходимите инструменти и да съставите нещо просто. Това е като четете „тестване, тестване, 1, 2, 3“ в микрофон!

В този случай ще използваме Visual Studio за създаване на приложение за конзола. Така че след като продължите и изтеглите Visual Studio (безплатно е), щракнете върху:

Файл> Ново> Проект

И тогава:

Visual C #> Windows Classic Desktop> App Console (.NET Framework)

Ето как изграждаме приложение, което ще работи в конзолата на Windows.

С това направено структурата на голите кости на вашия проект ще се появи в главния прозорец. Ще ви бъде представен код, който изглежда така:

пространство на имена ConsoleApp3 {class Program {static void Main (string args) {}}}

Сега просто добавете два реда, така:

пространство на имена ConsoleApp3 {class Program {static void Main (string args) {Console.WriteLine ("Здравей, свят!"); Console.ReadKey (); }}}

Това ще напише "Hello World!" На екрана и след това ще изчакате натискането на клавиш. След като потребителят докосне някой клавиш, програмата ще приключи и автоматично ще излезе.

Обърнете внимание, че и тези два реда завършват с точка и запетая. Това е така, защото всяко изявление в C # трябва да завършва с точка и запетая, която съобщава на C #, че редът е завършен (същото е в Java). Единственото изключение е, когато линията е последвана веднага от отворена скоба, която ще обясним след малко.

Натиснете бутона „Старт“ в горната част на екрана и това трябва да стартира приложението, което ви позволява да видите това на практика.

Класовете са части от код, които описват обекти, които са ефективно части от данни

И така, какво точно става тук?

Започване на C #: методи и класове

За да научите C # програмиране за Android, трябва да разберете класове и методи.

Класовете са части от код, които описват обекти, които са ефективно части от данни. Не е нужно да се тревожите твърде много за това, за да започнете: просто знайте, че страницата с код, с която работите в момента, се нарича „клас“ и че можете да взаимодействате с други класове в рамките на вашия проект. Проектът може да има само един клас, като целият ви код работи оттам, или може да има няколко.

В рамките на всеки клас ще имате и методи. Тези методи са фрагменти от код, към които можете да се обърнете по всяко време от този клас - а понякога и извън него.

В този случай се извиква класът програма, Това се определя точно в горната част от реда, който гласи: class Program. И ако отворите прозореца „Solution Explorer“ вдясно, ще можете да намерите Program.cs. Името на класа винаги е същото като името на файла.

След това използваме къдрава скоба, за да съдържаме целия код, който следва. Къдравите скоби ни казват, че всичко, което следва, принадлежи заедно. По този начин, докато скобата се затвори, всички следващи кодове са част от програмата.

Следва първият ни метод, дефинирайте следния ред:

статична празнота Main (string args)

След това се последват от по-отворени скоби, което означава, че следващият бит код е част от метода "Main" (който все още е в класа на програмата). И точно там поставихме нашия „Здравей свят“.

„Статична празнота“ по същество ни казва, че този метод прави нещо самостоятелно (вместо да манипулира данните, които да се използват от по-широката програма) и че не може да бъде препратен от външни класове. Нещата "string args" ни позволяват да предаваме информация в метода, за да манипулираме по-късно. Те се наричат ​​„параметри“ и „аргументи“. Отново не е нужно да се притеснявате за нищо от това все още. Просто знайте, че „статична празнота“, последвана от дума, скоби и къдрави скоби, поставя началото на нов метод.

Следващите два реда са тези, които добавихме: те получават конзолата и след това получават достъп до нейните команди, за да запишат на екрана и чакат натискане на клавиш.

И накрая, ние затваряме всички скоби: първо методът, след това класът, а след това „пространството на имената“, което е името на проекта, към който принадлежи класът (в случая „ConsoleApp3“ - направих предишни тестови приложения по този начин) ,

Объркани ли сте? Не се притеснявайте, предстои да има повече смисъл.

Използване на методи

Така че методите са групи от кодове с имена. За да демонстрираме защо използваме методи, може да бъде полезно да създадем нов и да го приложим като пример.

Така че, създайте нов метод, който живее в рамките на класа на програмата (така че трябва да бъде в тези къдрави скоби, но извън къдравите скоби, принадлежащи на "Main").

Наречете това „NewMethod“ и поставете двата реда, които току-що написахте тук. Това трябва да изглежда така:

клас програма {static void Main (string args) {} статичен void NewMethod () {Console.WriteLine ("Здравей свят!"); Console.ReadKey (); }}

Сега добавете препратка към NewMethod в основния си метод, като така:

static void Main (string args) {ar ​​NewMethod (); }

След това ще "извикате" току-що създадения метод, по същество насочвайки програмата в тази посока. Натиснете Старт и ще видите същото, което се случва както преди. С изключение на сега, ако искате, можете да напишете „NewMethod ();“ колкото пъти искате и да продължите да повтаряте текста, без да се налага да пишете много код.

По време на огромна програма, възможността да се препращат фрагменти от код като този става невероятно мощна. Това е едно от най-важните неща, които трябва да разберете, когато се опитате да научите C # програмиране за Android.

Можем да създадем толкова много методи, колкото ни харесват по този начин и по този начин да имаме много кокетно и организирано парче код. В същото време можем да посочим и методи, които са „вградени“ в C # и към всички библиотеки, които бихме могли да използваме. „Main“ е един пример за метод „вграден“. Това е методът, с който ще започнат всички програми и C # разбира, че трябва да се изпълни първо. Ако не сложите нищо тук, нищо няма да се случи!

Аргументите, които са включени в скобите в този случай, са необходими само защото това е начинът, по който Microsoft е проектирал основния метод. Ние обаче сме добре да оставим нашите скоби празни.

Използване на променливи

Сега е време всъщност да направим нещо малко интересно в нашия код. По-конкретно, нека да разгледаме как бихте използвали променливи, за да направите програмата по-динамична. Това е едно от най-важните неща, които трябва да разберете, ако искате да научите C # програмиране.

Променливата по същество е контейнер за част от данните. Отхвърлете ума си към гимназията по математика и може би си спомняте да видите такива неща:

10 + х = 13
Намерете х

Тук "x" е променлива и разбира се стойността, която представлява, е "3".

Точно така работи и променлива в програмирането. Освен тук, променлива може да представлява много различни видове данни: включително текст.

За да създадем нова променлива, първо трябва да кажем на C # какъв тип данни ще се използват.

Така че във вашия NewMethod () метод, първо ще създадете вашата променлива, а след това ще й присвоите стойност. Тогава ще го добавим към нашата команда „WriteLine“:

int номер; число = 10; Console.WriteLine ("Здравей, свят!" + Номер);

Използвахме тип променлива, наречена „цяло число“, която може да бъде всяко цяло число. В C #, ние се отнасяме към тях с помощта на „int“. Въпреки това, ние просто бихме могли лесно да използваме „float“ например, което е „променлива с плаваща запетая“ и ни позволява да използваме десетични знаци.

Ако стартирате този код, той трябва да напише „Hello World! 10 ”на екрана. И разбира се, можем да променим стойността на „числото“ по всяко време, за да променим стойността.

Тъй като „числото“ е създадено в NewMethod (), не можем да имаме достъп до него от другаде в нашия код. Но ако го поставим извън всички методи, той ще стане достъпен в световен мащаб. За да направим това, трябва да се уверим, че променливата също е статична:

клас програма {static int number = 10; static void Main (string args) {NewMethod (); } static void NewMethod () {Console.WriteLine ("Здравей, свят!" + номер); Console.ReadKey (); }}

И накрая, има още един начин да предадем тези данни наоколо и това би било да ги използваме като аргумент, като по този начин ги предадем в нашия метод. Това може да изглежда така:

static void Main (string args) {int number = 10; Console.WriteLine ("Здравей, как се казваш?"); NewMethod (брой); } статичен невалиден NewMethod (int номер) {Console.WriteLine ("Здравей свят!" + номер); Console.ReadKey (); }}

Тук ние определяме нашия метод NewMethod като се нуждае от един аргумент, който трябва да бъде цяло число и който ще бъде посочен в метода като „число“. Правим това като просто добавим тази информация към къдравите скоби. След това, когато извикаме метода от където и да е другаде в програмата, трябва да „предадем“ тази стойност в скобите. Можете да създадете методи с множество параметри, като в този случай просто разделяте изброените променливи със запетаи.

Има различни сценарии, при които използването на всички тези различни стратегии за жонглиране на данни ще бъде подходящо. Доброто програмиране означава да намерите подходящия за работата!

Предаване на аргументи и използване на низове

Опитайте да стартирате следващото парче код и да видите какво ще се случи:

клас програма {static void Main (string args) {Console.WriteLine ("Здравей, как се казваш?"); NewMethod (Console.ReadLine ()); } статичен void NewMethod (String UserName) {Console.WriteLine ("Здравей" + UserName); Console.ReadKey (); }}

Трябва да откриете, че ще бъдете подканени да въведете името си и че Конзолата след това ви превъзхожда. Този прост код съдържа редица полезни уроци.

Първо виждаме пример как да използваме различен тип променлива, наречена String. A String е поредица от герои, които могат да бъдат име или може да са цяла история.

Така че можете също толкова лесно да напишете UserName = „Адам“. Но вместо това, ние получаваме низ от конзолата с израза: Console.ReadLine ().

Можехме да пишем:

Потребител на струни; User = Console.ReadLine (); NewMethod (Потребител);

Но за да поддържаме кода си възможно най-чист, пропуснахме тези стъпки и поставихме „ReadLine“ директно в скобите.

След това предаваме този низ на нашия NewMethod и поздравяваме потребителя, използвайки метода, който вече сте запознат.

A String е поредица от герои, които могат да бъдат име или може да са цяла история.

Да се ​​надяваме, че сега започвате да разбирате малко за това, защо C # е написана така, както е и как можете да използвате неща като променливи и методи, за да създадете някакъв гъвкав и мощен софтуер.

Но има още един важен аспект, който трябва да знаете, ако искате да научите програмиране на C #: контрол на потока.

Научете C # контрол на потока и изградете прости викторини!

Една от причините да използваме променливи при кодирането е, че лесно можем да редактираме програмите си впоследствие. Друго е, че можете да получите информация от потребителя или да я генерирате произволно.

Но може би най-добрата причина да научите C # променливи е, за да може вашите програми да станат динамични: така че да могат да реагират различно в зависимост от начина, по който се използват.

За тази цел се нуждаем от „контрол на потока“ или „условни отчети“. Това наистина са просто фантастични начини да кажем, че ще изпълняваме код по повече от един начин, в зависимост от стойността на променлива.

И един от най-мощните начини да направите това е с изявление „ако“. В този пример нека поздравим основния ни потребител по различен начин от останалите, като потърсим потребителското му име.

static void NewMethod (String UserName) {Console.WriteLine ("Здравей" + UserName); ако (UserName.Equals ("Адам")) {Console.WriteLine ("Добре дошли обратно сър"); } Console.ReadKey (); }

„Ако“ изявленията работят, като тестват валидността на изявление, което ще влезе в скоби. В този случай ние питаме дали низът UserName е същият като низ „Adam“. Ако това твърдение в скобите е вярно - двата низа са еднакви - тогава ще се изпълни кодът в следващите къдрави скоби. Ако не е, тези редове ще бъдат пропуснати.

По същия начин можем да сравняваме цели числа и поплавъци, и можем да тестваме дали едното е по-голямо от другото и т.н. Можем дори да използваме множество различни, ако изявления вътре един в друг като руски кукли. Ние наричаме тези „вложени ifs“.

Следващият път

Има много повече стратегии, които можете да използвате за контрол на потока - включително неща като оператори за превключване. Надяваме се, че вече можете да видите как можем да използваме тези изявления и техники, за да започнем да правим някои полезни неща. Вече лесно бихте могли да превърнете този код във викторина!

В крайна сметка C # с инструменти като Unity ще ви позволи да изградите напълно функционални игри!

Но за да направим наистина впечатляващи инструменти и игри, има още няколко неща, които трябва да проучим. Така че изненада! Ще има част втора!

В следващия урок ще разберете как да създавате бримки, които се повтарят във времето, както и как да създавате нови класове и да взаимодействате с тях. Ще се видим тогава!