Kandungan

• Pengenalan ringkas - C # vs Java
• Hai dunia! dalam C #
• Bermula dengan C #: kaedah dan kelas
• Menggunakan kaedah
• Menggunakan pembolehubah
• Meluluskan hujah dan menggunakan tali
• Belajar kawalan aliran C # dan buat kuiz sederhana!
• Lain kali

Dalam siaran ini, anda akan belajar tentang pengaturcaraan C # untuk Android, serta di mana ia sesuai dalam skema besar pembangunan Android.

Sekiranya anda berminat menjadi pemaju Android, anda mungkin berada di bawah tanggapan bahawa anda perlu belajar salah satu daripada dua bahasa: Java atau Kotlin. Ini adalah dua bahasa yang disokong secara rasmi oleh Android Studio, dan dengan itu kedua-dua bahasa memberi tumpuan kepada banyak panduan dan tutorial. Perkembangan Android jauh lebih fleksibel dan berbeza daripada itu, dan terdapat banyak lagi cara untuk mendekatinya. Kebanyakannya melibatkan C #.

Baca:Saya mahu membangunkan aplikasi Android - bahasa mana yang patut saya pelajari?

C # adalah bahasa pengaturcaraan yang akan anda gunakan jika anda memilih untuk membina permainan dalam Unity misalnya - yang juga menjadi enjin permainan yang paling popular dan digunakan secara meluas di Play Store. Secara umumnya, berguna untuk mempelajari pengaturcaraan C # jika anda sama sekali berminat dalam pembangunan permainan.

Anda juga harus belajar pengaturcaraan C # jika anda ingin menggunakan Xamarin. Xamarin adalah alat yang membolehkan pemaju membina aplikasi menggunakan Visual Studio yang boleh dengan mudah dialihkan kepada kedua iOS dan Android, sesuai untuk projek platform silang.

Jadi, dengan itu berkata, ada alasan yang pasti untuk belajar pengaturcaraan C # untuk Android. Mari kita lihat apa yang anda perlu ketahui.

Pengenalan ringkas - C # vs Java

C # adalah bahasa pengaturcaraan berorientasikan objek yang dibangunkan oleh Microsoft pada tahun 2000, dengan matlamat menjadi moden, mudah, dan fleksibel. Seperti Java (yang dibangunkan oleh Sun Microsystem pada tahun 1990), ia mula berkembang dari C ++, memastikan terdapat banyak persamaan di antara keduanya. Sebagai contoh, kedua-duanya menggunakan "asas sintaksis" yang sama, yang bermaksud bahawa mereka menggunakan banyak istilah dan struktur yang sama. Terdapat beberapa perbezaan kecil, tetapi jika anda biasa dengan satu bahasa, maka anda harus dapat memahami banyak yang lain tanpa perlu mempelajari secara khusus. Bagi pemula sekalipun, ramai akan mendapati bahawa ia sedikit lebih mudah untuk mempelajari pengaturcaraan C #.

Sebagai bahasa berorientasikan objek, kedua-dua C # dan Java akan menerangkan objek melalui kelas. Ini adalah pendekatan modular untuk pengaturcaraan, yang membolehkan coretan kod digunakan berulang-ulang.

Di mana C # berbeza dari Jawa walaupun, dalam penggunaan perwakilan, pendekatannya untuk mendengar peristiwa, harta maya vs harta akhir, pemutus tersembunyi, dan banyak lagi.

Berita baik: anda sebenarnya tidak perlu tahu apa yang paling bermakna ini apabila anda mula mula belajar C #. Takeaway utama adalah bahawa struktur itu hanya sedikit lebih mudah untuk belajar dalam C # dan cenderung memerlukan kurang menaip. Ini amat penting memandangkan apabila anda belajar Java untuk Android, anda juga perlu membiasakan diri dengan banyak kelas dan API yang diperlukan untuk membina aplikasi Android. Oleh itu, anda mungkin juga mempelajari pengaturcaraan C # sebagai batu loncatan ke Jawa.

Hai dunia! dalam C #

Tradisi dalam dunia kod adalah bila-bila masa anda mempelajari bahasa baru, anda harus membuat program mudah untuk memaparkan "Hello World!" Di skrin. Ini pada dasarnya memastikan bahawa anda dapat mendapatkan alat yang diperlukan dan berjalan dan menyusun sesuatu yang mudah. Ia seperti membaca "ujian, ujian, 1, 2, 3" ke dalam mikrofon!

Dalam kes ini, kami akan menggunakan Visual Studio untuk membuat aplikasi konsol. Jadi sebaik sahaja anda pergi ke hadapan dan memuat turun Visual Studio (percuma), klik:

Fail> Baru> Projek

Dan kemudian:

Visual C #> Desktop Windows Klasik> Apl Konsol (Rangka Kerja.NET)

Inilah cara kami membina aplikasi yang akan dijalankan dalam konsol Windows.

Dengan itu, struktur tulang telanjang projek anda akan muncul di tetingkap utama. Anda akan dibentangkan dengan kod yang kelihatan seperti ini:

namespace ConsoleApp3 {Program kelas {static void Main (string args) {}}}

Sekarang tambahkan dua baris, seperti:

namespace ConsoleApp3 {Program kelas {static void Main (string args) {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}}

Ini akan menulis "Hello World!" Ke skrin, dan kemudian menunggu akhbar utama. Sebaik sahaja pengguna menyentuh sebarang kekunci, program akan berakhir dan akan keluar secara automatik.

Perhatikan bahawa kedua-dua garisan ini berakhir dengan titik koma. Ini kerana setiap pernyataan dalam C # mesti berakhir dengan titik koma, yang berkomunikasi dengan C # bahawa garisan selesai (ia sama di Jawa). Satu-satunya pengecualian ialah apabila garisan itu diikuti serta-merta oleh pendakap terbuka, yang akan dijelaskan dalam seketika.

Tekan butang "Mula" di bahagian atas skrin, dan itu harus melancarkan aplikasi, membolehkan anda melihatnya dalam amalan.

Kelas adalah kepingan kod yang menggambarkan objek, yang merupakan kepingan data yang berkesan

Jadi, apa sebenarnya yang berlaku di sini?

Bermula dengan C #: kaedah dan kelas

Untuk mempelajari pengaturcaraan C # untuk Android, anda perlu memahami kelas dan kaedah.

Kelas adalah kepingan kod yang menggambarkan objek, yang merupakan kepingan data yang berkesan. Anda tidak perlu terlalu bimbang tentang perkara ini untuk bermula dengan: hanya tahu bahawa halaman kod yang anda sedang kerjakan sekarang disebut "kelas" dan anda boleh berinteraksi dengan kelas lain dalam projek anda. Projek boleh mempunyai hanya satu kelas, dengan semua kod anda berfungsi dari sana, atau ia boleh mempunyai banyak.

Di dalam setiap kelas, anda juga akan mempunyai kaedah. Kaedah ini adalah coretan kod yang boleh anda rujuk pada bila-bila masa dari dalam kelas itu - dan kadang-kadang dari luarnya.

Dalam kes ini, kelas dipanggil Program. Ini ditakrifkan tepat di atas dengan baris yang berbunyi: Program kelas. Dan jika anda membuka tetingkap "Solution Explorer" di sebelah kanan, anda akan dapat mencari Program.cs. Nama kelas sentiasa sama dengan nama fail.

Kami kemudian menggunakan pendakap kerinting untuk mengandungi semua kod yang berikut. Kurungan keriting memberitahu kami bahawa segala yang berikut adalah bersama. Oleh itu, sehingga pendakap ditutup, semua kod berikut adalah sebahagian daripada Program.

Ini diikuti dengan kaedah pertama kami, tentukan dengan baris berikut:

void statik Utama (string args)

Ini kemudian diikuti dengan lebih banyak kurungan yang terbuka, yang bermaksud bahawa sedikit kod berikutnya adalah sebahagian daripada kaedah "Main" (yang masih dalam kelas Program). Dan di sinilah kami meletakkan "Hello World" kami.

"Statik tidak sah" pada dasarnya memberitahu kita bahawa kaedah ini melakukan sesuatu yang mandiri (daripada memanipulasi data yang akan digunakan oleh program yang lebih luas) dan ia tidak boleh dirujuk oleh kelas luar. Barang-barang "args string" membolehkan kita untuk menyampaikan maklumat ke dalam kaedah untuk memanipulasi kemudian. Ini dipanggil "parameter" dan "argumen". Sekali lagi, anda tidak perlu bimbang tentang perkara itu. Hanya tahu bahawa "statik tidak sah" diikuti dengan kata, tanda kurung, dan kurungan keriting, menandakan permulaan kaedah baru.

Dua baris berikut adalah yang kami tambahkan: mereka mendapat konsol dan kemudian mengakses arahannya untuk menulis ke skrin dan menunggu akhbar utama.

Akhirnya, kami menutup semua kurungan kami: mula-mula kaedah, kemudian kelas, dan kemudian "ruang nama" yang merupakan nama projek yang dimiliki oleh kelas (dalam kes ini "ConsoleApp3" - saya telah membuat aplikasi ujian sebelumnya dengan cara ini) .

Bingung? Jangan bimbang, ia akan lebih masuk akal.

Menggunakan kaedah

Oleh itu kaedah adalah kumpulan kod dengan nama. Untuk menunjukkan mengapa kami menggunakan kaedah, dapat membantu membuat yang baru dan meletakkannya sebagai contoh.

Jadi, buat kaedah baru yang tinggal dalam kelas Program (jadi ia perlu berada di dalam kurungan kurungan, tetapi di luar kurungan kurungan kepunyaan "Main").

Panggil "NewMethod" ini, dan kemudian letakkan dua baris yang anda tulis di sini. Ini sepatutnya kelihatan seperti:

Program kelas {static void Main (string args) {} static void NewMethod () {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}

Sekarang tambah rujukan kepada NewMethod dalam kaedah Utama anda, seperti:

statik void Utama (string args) {ar ​​NewMethod (); }

Ini akan kemudian "memanggil" kaedah yang baru anda buat, pada dasarnya mengarahkan program ke arah itu. Tekan Start dan anda akan melihat perkara yang sama berlaku seperti dahulu. Kecuali sekarang jika anda mahu, anda boleh menulis "NewMethod ();" sebanyak yang anda mahu dan terus mengulangi teks tanpa perlu menulis banyak kod.

Sepanjang program yang besar, dapat merujuk coretan kod seperti ini menjadi sangat kuat. Ini adalah salah satu perkara yang paling penting untuk difahami apabila anda cuba mempelajari pengaturcaraan C # untuk Android.

Kita boleh mencipta banyak kaedah yang kita suka dengan cara ini dan cara itu mempunyai sekeping kod yang sangat kemas dan teratur. Pada masa yang sama, kita juga boleh menggunakan kaedah rujukan yang "dibina" untuk C # dan mana-mana perpustakaan yang mungkin kita gunakan. "Utama" adalah satu contoh kaedah "terbina". Ini adalah kaedah yang semua program akan bermula, dan C # memahami ia harus dilaksanakan terlebih dahulu. Jika anda tidak meletakkan apa-apa di sini, maka tiada apa yang akan berlaku!

Oleh itu, hujah-hujah yang dimasukkan dalam kurungan dalam kes ini hanya diperlukan kerana itu adalah cara Microsoft merancang kaedah utama. Walau bagaimanapun kami tidak dapat meninggalkan tanda kurung kami.

Menggunakan pembolehubah

Kini sudah tiba masanya untuk melakukan sesuatu yang sedikit menarik dalam kod kami. Khususnya, mari kita lihat bagaimana anda akan menggunakan pembolehubah untuk menjadikan program lebih dinamik. Ini adalah salah satu perkara yang paling penting untuk difahami jika anda ingin mempelajari pengaturcaraan C #.

Pembolehubah pada dasarnya adalah sebuah bekas untuk sekeping data. Luangkan minda anda kembali ke matematik sekolah tinggi, dan anda mungkin ingat melihat perkara seperti ini:

10 + x = 13
Cari x

Di sini, "x" adalah pembolehubah, dan sudah tentu nilai yang diwakili adalah "3".

Ini juga bagaimana pemboleh ubah berfungsi dalam pengaturcaraan. Kecuali di sini, pemboleh ubah boleh mewakili banyak jenis data yang berlainan: termasuk teks.

Untuk membuat pemboleh ubah baru, pertama kita perlu memberitahu C # jenis data yang akan digunakan untuk mengandunginya.

Jadi di dalam kaedah NewMethod () anda, mula-mula anda akan membuat pemboleh ubah anda, dan kemudian anda akan memberikannya nilai. Kemudian kami akan menambahnya kepada arahan "WriteLine" kami:

nombor int; nombor = 10; Console.WriteLine ("Hello World!" + Nombor);

Kami telah menggunakan jenis pembolehubah yang dikenali sebagai "integer" yang boleh menjadi nombor keseluruhan. Dalam C #, kita merujuk kepada ini menggunakan "int". Bagaimanapun, kita boleh dengan mudah menggunakan "float" sebagai contoh, iaitu "pembolehubah titik terapung" dan membolehkan kita menggunakan tempat perpuluhan.

Sekiranya anda menjalankan kod ini, sekarang harus menulis "Hello World! 10 "ke skrin. Dan tentu saja, kita boleh mengubah nilai "nombor" pada bila-bila masa untuk mengubahnya.

Kerana "nombor" dicipta dalam NewMethod (), kami tidak dapat mengaksesnya dari tempat lain di kod kami. Tetapi jika kita meletakkannya di luar semua kaedah, maka ia akan menjadi tersedia di seluruh dunia. Untuk melakukan itu, kita perlu memastikan bahawa pemboleh ubah juga statik bagaimanapun:

kelas Program {static int number = 10; void statik Utama (string args) {NewMethod (); } static void NewMethod () {Console.WriteLine ("Hello World!" + nombor); Console.ReadKey (); }}

Akhir sekali, terdapat satu lagi cara kita boleh lulus data ini di sekeliling, dan itu akan menggunakannya sebagai hujah, dengan itu lulus ke dalam kaedah kami. Ini mungkin kelihatan seperti itu:

statik void Utama (string args) {int number = 10; Console.WriteLine ("Hai di sana, whats your name?"); NewMethod (nombor); } static void NewMethod (nombor int) {Console.WriteLine ("Hello World!" + nombor); Console.ReadKey (); }}

Di sini, kami menentukan kaedah NewMethod kami sebagai memerlukan satu hujah, yang sepatutnya menjadi integer, dan yang akan dirujuk dalam kaedah sebagai "nombor". Kami melakukan ini dengan hanya menambahkan maklumat itu kepada kurungan keriting. Kemudian, apabila kita memanggil kaedah dari tempat lain di dalam program, kita perlu "lulus" nilai tersebut dalam kurungan. Anda boleh membuat kaedah dengan pelbagai parameter, yang mana anda hanya memisahkan pembolehubah yang disenaraikan dengan koma.

Terdapat pelbagai senario di mana menggunakan semua strategi yang berbeza untuk menyesuaikan data akan sesuai. Pengaturcaraan yang baik bermakna mencari yang tepat untuk kerja!

Meluluskan hujah dan menggunakan tali

Cuba jalankan sekeping kod berikut dan lihat apa yang berlaku:

Program kelas {static void Main (string args) {Console.WriteLine ("Hai di sana, whats your name?"); NewMethod (Console.ReadLine ()); } NewMethod statik void (String UserName) {Console.WriteLine ("Hello" + UserName); Console.ReadKey (); }}

Anda harus mendapati bahawa anda digesa untuk memasukkan nama anda, dan Konsol kemudian akan memenangi anda. Sekeping kod ringkas ini mengandungi beberapa pelajaran yang berguna.

Pertama, kita melihat contoh cara menggunakan jenis pembolehubah yang berbeza, yang disebut String. String adalah satu siri watak, yang boleh menjadi nama, atau boleh menjadi satu cerita keseluruhan.

Jadi, anda boleh dengan mudah menulis UserName = "Adam". Tetapi sebaliknya, kami mendapat rentetan dari konsol dengan pernyataan: Console.ReadLine ().

Kita boleh menulis:

Pengguna String; Pengguna = Console.ReadLine (); NewMethod (Pengguna);

Tetapi untuk memastikan kod kami menjadi kemas, kami melangkau langkah tersebut dan meletakkan "ReadLine" secara langsung di dalam kurungan.

Kami kemudian lulus rentetan kepada NewMethod kami, dan kami menyambut pengguna, menggunakan kaedah yang sudah anda kenal.

String adalah satu siri watak, yang boleh menjadi nama, atau boleh menjadi satu cerita keseluruhan.

Mudah-mudahan, anda kini mula memahami sedikit tentang mengapa C # ditulis dengan cara itu, dan bagaimana anda boleh menggunakan perkara seperti pemboleh ubah dan kaedah untuk menghasilkan beberapa perisian yang fleksibel dan berkuasa.

Tetapi ada satu aspek yang lebih penting yang perlu anda ketahui jika anda ingin belajar pengaturcaraan C #: kawalan aliran.

Belajar kawalan aliran C # dan buat kuiz sederhana!

Salah satu sebab yang kita gunakan pembolehubah ketika pengekodan, adalah supaya kita dapat dengan mudah mengedit program kami. Satu lagi adalah supaya anda boleh mendapatkan maklumat daripada pengguna, atau menjana secara rawak.

Tetapi mungkin sebab terbaik untuk mempelajari pembolehubah C #, supaya program anda dapat menjadi dinamik: sehingga mereka dapat bertindak balas dengan cara yang berbeza bergantung pada bagaimana ia digunakan.

Untuk itu, kita perlu "kawalan aliran", atau "kenyataan bersyarat". Ini adalah cara yang paling mewah untuk mengatakan bahawa kita akan melaksanakan kod dalam lebih daripada satu cara, bergantung pada nilai pembolehubah.

Dan salah satu cara yang paling berkuasa untuk melakukannya ialah dengan kenyataan "jika". Dalam contoh ini, berikan salam kepada pengguna utama kami secara berbeza daripada yang lain dengan melihat nama pengguna mereka.

statik void NewMethod (String UserName) {Console.WriteLine ("Hello" + UserName); jika (UserName.Equals ("Adam")) {Console.WriteLine ("Selamat kembali tuan"); } Console.ReadKey (); }

"Jika" pernyataan berfungsi dengan menguji kesahihan pernyataan, yang akan masuk dalam kurungan. Dalam kes ini, kami bertanya sama ada string UserName adalah sama dengan rentetan "Adam". Sekiranya pernyataan itu dalam kurungan adalah benar - kedua-dua rentetan adalah sama - maka kod dalam kurungan kurungan berikut akan dilaksanakan. Jika tidak, maka garis-garis tersebut akan dilangkau.

Begitu juga, kita boleh membandingkan bilangan bulat dan terapung, dan kita boleh menguji untuk melihat jika seseorang lebih besar daripada yang lain, dan lain-lain. Kita juga boleh menggunakan pelbagai berbeza jika kenyataan di dalam satu sama lain seperti anak patung Rusia. Kami memanggil "if bersarang" ini.

Lain kali

Terdapat banyak lagi strategi yang boleh anda gunakan untuk kawalan aliran - termasuk perkara seperti pernyataan suis. Mudah-mudahan sekalipun, anda sudah dapat melihat bagaimana kami boleh menggunakan pernyataan dan teknik ini untuk memulakan beberapa perkara yang berguna. Anda boleh dengan mudah mengubah kod ini menjadi kuiz!

Akhirnya C # dengan alat seperti Perpaduan akan membolehkan anda membina permainan berfungsi sepenuhnya!

Tetapi untuk benar-benar membuat alat dan permainan yang mengagumkan, terdapat beberapa perkara yang perlu kita pelajari. Jadi terkejut! Akan ada bahagian dua!

Dalam pelajaran seterusnya, anda akan mengetahui cara membuat gelung yang melelehkan dari masa ke masa, serta cara membuat kelas baru dan berinteraksi dengan mereka. Jumpa awak nanti!