C # Bahasa Fundamental Bab 1, C # dan. Pemrograman NET menunjukkan C yang sangat sederhana # program yang mencetak string teks "Hello World!" ke layar konsol dan memberikan analisis baris-demi-baris program itu. Namun, bahkan bahwa program sederhana cukup kompleks bahwa kita harus melewatkan beberapa detail. Dalam bab ini, kita akan memulai eksplorasi mendalam tentang sintaks dan struktur bahasa C #. Sintaks dari suatu bahasa adalah urutan kata kunci, di mana Anda meletakkan titik koma, dan sebagainya. Semantik adalah apa yang Anda mengekspresikan dalam kode, dan bagaimana kode Anda cocok bersama-sama. Sintaks adalah sepele dan tidak penting, tetapi karena compiler sticklers mutlak untuk sintaks yang benar, programmer pemula membayar banyak perhatian untuk sintaks sampai mereka merasa nyaman. Untungnya, Visual Studio 2008 membuat sintaks mengelola lebih mudah sehingga Anda dapat fokus pada semantik, yang jauh lebih penting. Dalam bab ini, kami akan memperkenalkan pernyataan dan ekspresi, blok bangunan dari setiap program. Anda akan belajar tentang variabel dan konstanta, yang memungkinkan Anda menyimpan nilai untuk digunakan dalam program anda. Kami juga akan mulai penjelasan jenis, dan kita akan melihat string, yang Anda lihat secara singkat dalam program Hello World. Ini semua hal yang sangat dasar, tapi itu dasar yang Anda butuhkan untuk mulai mendapatkan mewah. Tanpa variabel, aplikasi Anda tidak bisa benar-benar memproses data. Semua variabel membutuhkan jenis, dan variabel yang digunakan dalam ekspresi. Anda akan melihat bagaimana semua ini cocok rapi bersama-sama. Laporan Dalam C #, instruksi program lengkap disebut pernyataan dan setiap pernyataan diakhiri dengan tanda titik koma (;). Lupa titik koma adalah kesalahan yang sangat umum untuk programmer pemula, tapi Visual Studio akan menangkap Anda jika Anda melakukannya. Program terdiri dari urutan pernyataan, seperti berikut: Salinan int myVariable; / / pernyataan myVariable = 23; / / pernyataan yang lain int anotherVariable = myVariable; / / belum pernyataan lainCompiler dimulai pada awal file kode sumber dan membaca ke bawah, mengeksekusi setiap pernyataan dalam urutan di mana compiler pertemuan itu. Ini akan sepenuhnya jelas, dan sangat membatasi, kalau bukan karena percabangan. Percabangan memungkinkan Anda untuk mengubah urutan di mana pernyataan dievaluasi, dan bahkan mengambil jalan yang berbeda tergantung pada nilai variabel Anda, tapi mari kita tidak maju dari diri kita sendiri. Kita akan sampai ke percabangan dalam Bab 5, Branching.Jenis

C # adalah bahasa sangat diketik. Itu berarti bahwa setiap objek yang Anda buat atau menggunakan dalam program C # harus memiliki jenis tertentu. Dengan kata lain, Anda harus mendeklarasikan objek menjadi integer atau string atau anjing atau Button. Pada dasarnya, ketik menunjukkan karakteristik objek dan apa yang dapat dilakukan. Jenis datang dalam dua rasa: mereka yang dibangun ke dalam bahasa (jenis intrinsik) dan mereka yang Anda buat sendiri (kelas dan interface, dibahas dalam Bab, Bab 7 Kelas dan Objek dan Bab 13, Interfaces). C # menawarkan sejumlah jenis intrinsik, yang ditunjukkan pada Tabel 3.1, "Jenis-jenis intrinsik dibangun ke dalam C #". Tabel 3.1.Intrinsik jenis dibangun ke C #C # Jenis Ukuran (dalam byte) . NET Jenis Deskripsi

byte1 ByteUnsigned (nilai antara 0 dan 255).

arang2 ArangUnicode karakter (cara modern menyimpan karakter paling, termasuk karakter bahasa internasional).

bool1 BooleanBenar atau salah.

sbyte1 SByteDitandatangani (nilai antara -128 dan 127).

singkat2 Int16Ditandatangani (pendek) (nilai antara -32768 dan 32767).

ushort2 UInt16Unsigned (pendek) (nilai antara 0 dan 65.535).

int4 Int32Ditandatangani nilai integer antara -2147483648 dan 2147483647.

uint4 UInt32Unsigned bilangan bulat nilai antara 0 dan 4294967295.

mengapung4 TunggalFloating-point nomor. Memegang nilai-nilai dari sekitar + / -1,5 x 10-45 sampai sekitar + / -3,4 x 1038 dengan tujuh angka penting.

ganda8 GandaGanda presisi floating-point. Memegang nilai-nilai dari sekitar + / -5,0 x 10-324 sampai sekitar + / -1,8 x 10308 dengan 15 sampai 16 angka signifikan.

desimal12 DesimalFixed-presisi hingga 28 digit dan posisi titik desimal. Jenis ini biasanya digunakan dalam perhitungan keuangan. Membutuhkan akhiran "m" atau "M" ketika Anda mendeklarasikan sebuah konstanta.

panjang8 Int64Ditandatangani bilangan bulat mulai dari -9.223.372.036.854.775.808 ke 9.223.372.036.854.775.807.

ulong8 UInt64Unsigned integer mulai dari 0 sampai sekitar 1,85 x 1019.

Setiap jenis memiliki nama (seperti int) dan ukuran (seperti 4 byte). Ukuran memberitahu Anda berapa banyak byte setiap objek dari jenis ini menempati di memori. Programmer umumnya tidak suka membuang-buang memori jika mereka bisa menghindarinya, namun dengan biaya memori hari ini, Anda tidak perlu khusus tentang biaya memori jenis. Sebagian besar waktu, jika Anda menggunakan bilangan bulat Anda akan menggunakan int, bahkan jika pendek akan baik-baik. Demikian juga, ganda adalah jenis yang umum digunakan untuk angka desimal, meskipun float baik-baik saja dalam kebanyakan kasus. Kolom Keterangan pada Tabel 3.1, "Jenis-jenis intrinsik dibangun ke C #" daftar nilai minimum dan maksimum yang dapat Anda pegang di objek dari setiap jenis. Tip

Setiap tipe C # sesuai dengan jenis yang mendasari NET.. Jadi, apa C # panggilan int,. NET panggilan sebuah Int32. Ini menarik hanya jika Anda peduli tentang berbagi objek di seluruh bahasa.

Jenis intrinsik tidak sangat fleksibel, meskipun Anda akan menggunakan mereka banyak. Anda dapat menggunakannya untuk menambahkan dua angka bersama, dan mereka dapat menampilkan nilai-nilai mereka sebagai string. User-defined jenis dapat melakukan lebih banyak, kemampuan mereka ditentukan oleh metode yang Anda buat, yang kita akan sampai ke dalam Bab 8, Di dalam Metode.Objek dari jenis intrinsik disebut variabel, dan kita akan bicara tentang orang-orang kemudian dalam bab ini. Numerik Jenis Sebagian besar jenis intrinsik digunakan untuk bekerja dengan nilai-nilai numerik (byte, sbyte, pendek, ushort, int, uint, float, double, desimal, panjang, dan ulong).Anda dapat membagi menjadi dua tipe numerik set: unsigned dan ditandatangani. Nilai unsigned (byte, ushort, uint, ulong) dapat terus hanya nilai-nilai positif. Sebuah nilai ditandatangani (sbyte, pendek, int, panjang) dapat memegang nilai-nilai positif atau negatif, tetapi dalam rentang yang berbeda nilai. Sebagai contoh, pendek dan ushort adalah nilai-nilai baik 16-bit, yang berarti mereka dapat memegang salah satu dari 65.536 nilai yang mungkin (216). Ushort memegang hanya positif (unsigned) nomor, sehingga jangkauan adalah dari 0 sampai 65.535 (bukan 65.536, karena Anda perlu satu tempat untuk nol). Sebuah singkat ditandatangani, dan dapat memegang nilai-nilai dari -32768 sampai 32767 (sekali lagi, bukan 32.768, karena Anda perlu satu tempat untuk nol). Anda juga dapat mengkategorikan jenis ke yang digunakan untuk nilai-nilai integer (bilangan bulat) dan yang digunakan untuk floating-point nilai (angka-angka pecahan atau rasional). Byte, sbyte, ushort, uint, ulong, pendek, int, dan tipe lama semua memegang nilai-nilai seluruh nomor. Tip

Jenis byte dan sbyte tidak digunakan sangat sering, dan kami tidak akan menjelaskan mereka dalam buku ini.

Jenis ganda dan float memegang nilai-nilai pecahan. Meskipun ganda lebih besar dari float, dan Anda akan berpikir mengapung itu sudah cukup sebagian besar waktu, compiler mengasumsikan bahwa setiap nomor dengan titik desimal di dalamnya adalah ganda kecuali jika Anda mengikuti nomor dengan huruf f. Artinya, 4,7 diasumsikan ganda, tapi 4.7f adalah float. Jenis nilai desimal ditambahkan ke bahasa untuk mendukung aplikasi ilmiah dan keuangan, untuk menggunakannya, Anda tambahkan m sampai akhir, seperti yang Anda lakukan dengan f untuk float. Jenis float dan double memiliki jumlah yang sangat sedikit ketidaktepatan pada mereka jika nilai-nilai yang sangat besar atau sangat kecil-bukan sesuatu yang Anda akan perlu khawatir tentang dalam buku ini, tentu, tapi mungkin menyebabkan masalah jika Anda sedang mencoba untuk melakukan sangat tepat ilmiah atau perhitungan keuangan, itulah sebabnya mengapa ada desimal.Biasanya, Anda memutuskan ukuran integer untuk digunakan (pendek, int, atau panjang) berdasarkan besarnya nilai yang Anda inginkan untuk menyimpan. Sebagai contoh, ushort hanya dapat memegang nilai-nilai dari 0 sampai 65.535, sedangkan uint dapat memegang nilai-nilai dari 0 sampai 4294967295. Yang sedang berkata, dalam kehidupan nyata sebagian besar waktu Anda hanya akan mendeklarasikan variabel numerik Anda menjadi tipe int, kecuali ada alasan yang baik untuk melakukan sebaliknya. (Kebanyakan programmer memilih jenis ditandatangani kecuali mereka memiliki alasan yang baik untuk menggunakan nilai unsigned ini, sebagian, hanya masalah tradisi..) Misalkan Anda perlu melacak persediaan untuk sebuah gudang buku. Anda berharap untuk rumah hingga 40.000 atau bahkan 50.000 eksemplar buku masing-masing. Sebuah singkat ditandatangani hanya dapat menyimpan hingga 32.767 nilai-nilai. Anda mungkin tergoda untuk menggunakan unsigned pendek (yang dapat menyimpan hingga 65.535 nilai-nilai), tapi lebih mudah dan lebih baik untuk hanya menggunakan int ditandatangani (dengan nilai maksimum 2147483647). Dengan cara itu, jika Anda memiliki buku terlaris pelarian, program anda tidak akan pecah (jika Anda mengantisipasi menjual lebih dari 2 miliar eksemplar buku Anda, mungkin Anda akan ingin menggunakan panjang!).Tip

Sepanjang buku ini, kita akan menggunakan int di mana pun ia bekerja, bahkan jika pendek atau byte mungkin alternatif yang dapat digunakan. Memori murah hari ini, dan waktu pemrogram mahal. Ada beberapa situasi di mana perbedaan dalam penggunaan memori akan signifikan (misalnya, jika Anda akan mengadakan 1 miliar nilai-nilai di memori), tapi kita akan menjaga hal-hal sederhana dengan menggunakan tipe int bila memungkinkan.

Jenis nonnumeric: char dan bool Selain tipe numerik, bahasa C # menawarkan dua jenis lainnya: char dan bool.Tipe char digunakan dari waktu ke waktu ketika Anda perlu mengadakan karakter tunggal. Tipe char dapat mewakili karakter sederhana (A), sebuah karakter Unicode (\ u0041), atau urutan escape ('\ n'). Kita tidak akan membahas karakter Unicode dalam buku ini, dan Anda akan melihat escape sequence kemudian, di mana kami akan menjelaskan mereka dalam konteks. Bila Anda merujuk ke char dalam kode Anda, Anda perlu mengelilingi dengan tanda kutip tunggal, seperti ini: 'A'.Jenis yang penting yang tersisa adalah bool, yang memegang nilai Boolean. Sebuah nilai Boolean adalah salah satu yang bisa benar atau salah. Nilai Boolean sering digunakan dalam pemrograman C #, karena Anda akan melihat seluruh buku ini. Hampir setiap perbandingan (yang myDog lebih besar dari yourDog?) Menghasilkan nilai Boolean. Tip

Jenis bool bernama setelah George Boole (1815-1864), seorang matematikawan Inggris yang diterbitkan Sebuah Investigasi ke dalam Hukum Thought, di mana Apakah Didirikan Teori Matematika Logika dan Probabilitas, dan dengan demikian menciptakan ilmu aljabar Boolean.

Jenis dan Kesalahan Kompilator Compiler akan membantu Anda dengan mengeluh jika Anda mencoba untuk menggunakan tipe tidak benar. Compiler mengeluh dalam salah satu dari dua cara: itu masalah peringatan atau isu kesalahan. Tip

Anda sangat dianjurkan untuk mengobati peringatan sebagai kesalahan. Hentikan apa yang Anda lakukan, mencari tahu mengapa ada peringatan, dan memperbaiki masalah. Jangan pernah mengabaikan peringatan kompiler kecuali Anda yakin bahwa Anda tahu persis mengapa peringatan itu dikeluarkan dan bahwa Anda tahu sesuatu compiler tidak. Untuk memiliki Visual Studio menegakkan ini untuk Anda, ikuti langkah berikut: 1. Klik kanan pada sebuah proyek di Solution Explorer, dan pilih Properties dari menu pop-up. 2. Klik pada tab Build pada jendela Properties. 3. Dalam "Perlakukan semua peringatan sebagai kesalahan" bagian halaman, pilih tombol radio Semua.

Pemrogram bicara tentang waktu desain, waktu kompilasi, dan runtime. Waktu desain adalah ketika Anda sedang merancang program, waktu kompilasi adalah ketika Anda mengkompilasi program, dan runtime (kejutan!) ketika Anda menjalankan program. Sebelumnya dalam proses pembangunan Anda bahwa Anda menggali bug, semakin baik. Hal ini lebih mudah untuk memperbaiki bug di logika Anda pada waktu desain daripada memperbaiki bug setelah telah ditulis ke dalam kode. Demikian juga, lebih baik (dan lebih murah) untuk menemukan bug dalam program anda pada waktu kompilasi dari pada runtime. Tidak hanya itu lebih baik, lebih dapat diandalkan. Sebuah bug waktu kompilasi akan gagal setiap kali Anda menjalankan compiler, tetapi bug runtime dapat bersembunyi. Bug runtime dapat menyelinap di bawah celah dalam logika Anda dan mengintai di sana (kadang-kadang selama berbulan-bulan), mengulur waktu, menunggu untuk keluar saat itu akan menjadi yang paling mahal (atau paling memalukan) bagi Anda. Ini akan menjadi tema konstan dari buku yang Anda ingin compiler untuk menemukan bug. Compiler adalah teman anda (meskipun kita akui, pada waktu itu terasa seperti musuh Anda). Semakin banyak bug compiler menemukan, lebih sedikit bug pengguna Anda akan menemukan. Sebuah bahasa sangat diketik seperti C # compiler membantu menemukan bug dalam kode Anda. Berikut caranya: misalkan Anda memberitahu compiler bahwa milo adalah tipe Anjing. Beberapa waktu kemudian Anda mencoba untuk menggunakan milo untuk menampilkan teks (memanggil metode ShowText). Ups, s Anjing tidak menampilkan teks. Kompiler Anda akan berhenti dengan kesalahan: Salinan Anjing tidak mengandung definisi untuk 'ShowText'Sangat bagus. Sekarang Anda bisa mengetahui apakah Anda menggunakan objek yang salah atau Anda disebut metode yang salah. Visual Studio. NET benar-benar menemukan kesalahan bahkan sebelum compiler tidak. Ketika Anda mencoba untuk menambahkan metode, segera setelah Anda mengetikkan karakter titik, IntelliSense muncul daftar metode yang valid untuk membantu Anda, seperti yang ditunjukkan pada Gambar 3.1, "adalah IntelliSense teman Anda. Ketika Anda mulai mengetikkan sebuah metode, IntelliSense helpfully menyediakan daftar metode yang mungkin, untuk memastikan bahwa Anda memilih satu yang valid. ". Gambar 3.1.IntelliSense adalah teman Anda.Ketika Anda mulai mengetik sebuah metode, IntelliSense mem-bantu memberikan daftar metode yang mungkin, untuk memastikan bahwa Anda memilih satu yang valid.

Ketika Anda mencoba untuk menambahkan metode yang tidak ada, tidak akan berada dalam daftar. Itu adalah petunjuk yang cukup baik bahwa Anda tidak menggunakan obyek dengan benar. WriteLine () dan Output

. NET Framework menyediakan metode yang berguna untuk menampilkan output pada layar dalam aplikasi konsol: System.Console.WriteLine (). Bagaimana Anda menggunakan metode ini akan menjadi lebih jelas karena Anda maju melalui buku ini, tetapi fundamental yang langsung. Anda memanggil metode, dan dalam kurung Anda lulus dalam string yang Anda ingin dicetak ke konsol (layar), seperti pada aplikasi Hello World dalam Bab 1, C # dan Pemrograman NET..Itu berguna; string adalah teks tetap, dan Anda mungkin ingin untuk output nilai yang dapat berubah, tergantung pada isi program Anda. Untuk itu, Anda juga dapat lulus dalam parameter substitusi. Sebuah parameter substitusi adalah hanya tempat untuk nilai yang ingin ditampilkan. Sebagai contoh, Anda mungkin lulus dalam parameter substitusi {0} sebagai bagian dari string, dan kemudian ketika Anda menjalankan program, Anda akan mengganti nilai diadakan di Myint variabel sehingga nilainya ditampilkan di mana parameter {0} muncul di WriteLine () pernyataan. Berikut adalah cara kerjanya. Setiap parameter substitusi adalah angka antara kawat gigi, dimulai dengan 0 untuk parameter pertama, 1 untuk berikutnya, dan seterusnya. Jadi, jika Anda menggunakan hanya satu parameter substitusi, mungkin terlihat seperti ini: Salinan System.Console.WriteLine ("Usia siswa: {0}", Myint);Perhatikan bahwa Anda mengikuti string dikutip dengan koma dan kemudian nama variabel. Nilai variabel akan diganti menjadi parameter. Jika Myint memiliki nilai 15, pernyataan ditunjukkan sebelumnya menyebabkan berikut untuk menampilkan: Salinan Usia siswa: 15Jika Anda memiliki lebih dari satu parameter, nilai variabel akan diganti dalam urutan mereka muncul dalam metode, seperti pada berikut ini: Salinan System.Console.WriteLine ("Umur siswa pertama: {0}, usia siswa kedua: {1} ", Myint, myOtherInt);Jika Myint memiliki nilai 15 dan myOtherInt memiliki nilai 20, ini akan menyebabkan berikut untuk menampilkan: Salinan Umur siswa pertama: 15, dan usia siswa kedua: 20.Ada karakter khusus lainnya yang dapat Anda gunakan untuk memformat output, seperti ini: Salinan System.Console.WriteLine ("Siswa usia: \ nFirst mahasiswa: \ t {0} \ n Kedua mahasiswa: \ t {1} ", Myint, myOtherInt);Hal ini menghasilkan output yang terlihat seperti ini: Salinan Siswa usia: Pertama siswa: 15 Kedua siswa: 20Karakter yang dimulai dengan karakter garis miring (\) disebut karakter escape. Slash adalah sinyal untuk compiler bahwa apa yang berikut adalah karakter melarikan diri. Kode dan slash bersama-sama dianggap sebagai karakter tunggal. Karakter escape \ t menunjukkan tab, dan karakter \ n menunjukkan baris baru (feed line, atau carriage return). String di sini akan mencetak karakter usia Mahasiswa: diikuti oleh (\ n) baris baru, mahasiswa kemudian teks Pertama: diikuti oleh tab (\ t), maka nilai parameter pertama ({0}), dan baris baru karakter (\ n), maka mahasiswa teks Kedua: diikuti oleh tab (\ t), dan akhirnya nilai parameter kedua ({1}).Anda akan melihat lebih banyak tentang WriteLine () di bab berikutnya. Variabel dan Penugasan

AC variabel # kira-kira sama dengan variabel yang Anda ingat dari kelas aljabar kelas kesembilan Anda: itu adalah tempat untuk nilai. Untuk memasukkan lebih teknis, variabel adalah turunan dari tipe intrinsik (seperti int) yang dapat menyimpan suatu nilai: Salinan int myVariable = 15;Anda menginisialisasi sebuah variabel dengan menulis jenisnya (int dalam kasus ini), identifier, dan kemudian menetapkan nilai ke variabel. Tanda sama dengan (=) adalah operator penugasan. Anda tidak menentukan suatu persamaan dalam arti matematis, Anda mengatakan compiler untuk mengatur isi dari variabel di sebelah kiri dari operator dengan nilai apa pun yang di sebelah kanan operator. Dalam kasus khusus ini, Anda mengatakan "myVariable adalah int, dan itu ditugaskan nilai 15." Ada operator lain, dan kami akan menutupi mereka dalam Bab 4, Operator, tetapi Anda perlu tahu tentang tugas sekarang karena variabel yang tidak lebih baik tanpa itu. Suatu identifier adalah hanya sebuah nama sewenang-wenang Anda menetapkan ke metode, variabel, kelas, atau elemen lainnya. Dalam hal ini, pengenal variabel adalah myVariable.Anda dapat mendefinisikan variabel tanpa menginisialisasi mereka, cuma meninggalkan tugas dan nilai: Salinan int myVariable;Anda kemudian dapat memberikan nilai pada myVariable nanti dalam program anda: Salinan int myVariable; / / Beberapa kode lain di sini myVariable = 15; / / menetapkan 15 sampai myVariableAnda juga dapat mengubah nilai variabel kemudian dalam program ini. Itulah sebabnya mereka disebut variabel; nilai-nilai mereka dapat bervariasi, dan itulah yang membuat mereka berguna. Salinan int myVariable; / / Beberapa kode lain di sini myVariable = 15; / / menetapkan 15 sampai myVariable / / Beberapa kode lain di sinimyVariable = 12; // now it is 12Technically, a variable is a named storage location (that is, stored in memory) with a type. After the final line of code in the previous example, the value 12 is stored in the named location myVariable . Example 3.1, "You initialize a variable by declaring its type and assigning it a value; later, you can assign it a different value" illustrates the use of variables. To test this program, open Visual Studio .NET and create a console application, just as you did with Hello World in Chapter 1, C# and .NET Programming . Type in the code shown in bold in Example 3.1, "You initialize a variable by declaring its type and assigning it a value; later, you can assign it a different value". Example 3.1. You initialize a variable by declaring its type and assigning it a value; later, you can assign it a different value Salinan using System; menggunakan System.Collections.Generic; menggunakan System.Linq; menggunakan System.Text;

namespace Example_3_1_ _ _ _Using_variables { class Values { static void Main( ) { int myInt = 7; System.Console.WriteLine("Initialized, myInt: {0}", myInt); myInt = 5; System.Console.WriteLine("After assignment, myInt: {0}", myInt); } } }Press Ctrl-F5, or select Debug Start Without Debugging to build and run this application. As we mentioned in Chapter 1, C# and .NET Programming , if you press F5, the console window will disappear almost immediately; using Ctrl-F5 allows the window to stick around so that you can read it. Outputnya terlihat seperti ini: SalinanInitialized, myInt: 7After assignment, myInt: 5Example 3.1, "You initialize a variable by declaring its type and assigning it a value; later, you can assign it a different value" initializes the variable myInt to the value 7 , displays that value, reassigns the variable with the value 5 , and displays it again. Definite Assignment C# requires definite assignment ; you have to initialize a variable, or assign a value to it, before you can "use" it-that is, before you can output it or manipulate it in any way. To test this rule, change the line that initializes myInt in Example 3.1, "You initialize a variable by declaring its type and assigning it a value; later, you can assign it a different value" to: Salinan int Myint;Simpan program yang telah direvisi yang ditunjukkan pada Contoh 3.2, "Anda harus menginisialisasi variabel sebelum Anda dapat menggunakannya, kode ini tidak dapat dikompilasi". Contoh 3.2. Anda harus menginisialisasi variabel sebelum Anda dapat menggunakannya, kode ini tidak dapat dikompilasi Salinan using System; menggunakan System.Collections.Generic; menggunakan System.Linq; menggunakan System.Text;

namespace Example_3_2_ _ _ _Definite_Assignment { Nilai kelas { static void Main () { int Myint; System.Console.WriteLine ("diinisialisasi, Myint: {0}", Myint); Myint = 5; System.Console.WriteLine ("Setelah tugas, Myint: {0}", Myint); } } }Ketika Anda mencoba untuk mengkompilasi Contoh 3.2, "Anda harus menginisialisasi variabel sebelum Anda dapat menggunakannya, kode ini tidak dapat dikompilasi", C # compiler akan membuka jendela Daftar Kesalahan dalam IDE, dan akan menampilkan pesan kesalahan berikut: Salinan Penggunaan variabel lokal ditugaskan 'Myint'Anda tidak dapat menggunakan variabel terinisialisasi dalam C #, melakukan ini melanggar aturan tugas tertentu. Dalam kasus ini, "menggunakan" yang berarti variabel Myint diteruskan ke WriteLine ().Jadi, apakah ini berarti Anda harus menginisialisasi setiap variabel? Tidak, tapi jika Anda tidak menginisialisasi variabel Anda, Anda harus memberikan nilai untuk itu sebelum Anda mencoba untuk menggunakannya. Contoh 3.3, "perbaikan Kode ini Contoh 3.2," Anda harus menginisialisasi variabel sebelum Anda dapat menggunakannya, kode ini tidak dapat dikompilasi ", Anda tidak perlu menginisialisasi variabel ketika Anda menciptakannya, tetapi Anda harus menetapkan beberapa nilai untuk itu sebelum Anda menggunakannya "menggambarkan program dikoreksi. Contoh 3.3. Kode ini perbaikan Contoh 3.2, "Anda harus menginisialisasi variabel sebelum Anda dapat menggunakannya, kode ini tidak dapat dikompilasi", Anda tidak perlu menginisialisasi variabel ketika Anda menciptakannya, tetapi Anda harus menetapkan beberapa nilai untuk itu sebelum Anda menggunakannya Salinan using System; menggunakan System.Collections.Generic; menggunakan System.Linq; menggunakan System.Text;

namespace Example_3_3_ _ _ _Definite_assignment { Nilai kelas { static void Main () { int Myint; / / Kode lain di sini ... Myint = 7; / / tetapkan untuk itu System.Console.WriteLine ("Ditugaskan, Myint: {0}", Myint); Myint = 5; System.Console.WriteLine ("dipindahkan, Myint: {0}", Myint); } } }Anda bahkan dapat menetapkan nilai yang sama untuk beberapa variabel, seperti ini: Salinan int a, b, c, d; a = b = c = d = 5;Dalam kasus ini, a, b, c, dan d semua akan memiliki nilai 5. Ini bekerja karena C # compiler melakukan tugas paling kanan pertama, yaitu, d = 5. Itu tugas sendiri mengembalikan nilai, nilai 5. Compiler kemudian menetapkan bahwa nilai kembali ke c. Itu tugas kedua juga mengembalikan nilai, dan seterusnya, sampai semua variabel telah ditetapkan. Secara implisit diketik Variabel Ada satu jenis tambahan dari variabel kita bisa mendiskusikan, sekarang Anda mengerti tugas: variabel diketik implisit. C # compiler dapat menentukan jenis variabel dengan menganalisis jenis nilai yang Anda tetapkan untuk itu. Sebagai contoh, lihatlah laporan tugas: Salinan firstVariable var = 6; var secondVariable = 3,5; thirdVariable var = "Aku string!";Compiler memberikan firstVariable sebagai tipe int, secondVariable sebagai tipe double, dan thirdVariable sebagai tipe string. Anda tidak harus secara eksplisit menetapkan jenis. Sangat jelas, meskipun: variabel-variabel yang diketik, dan jika Anda kemudian mencoba untuk menetapkan sebuah objek dari tipe yang salah kepada mereka Anda akan menghasilkan kesalahan kompilator. Dan sekali jenis implisit ditetapkan, tidak dapat diubah, bahkan secara eksplisit. Jika Anda mencoba untuk melakukan sesuatu seperti ini, Anda akan mendapatkan pesan kesalahan: Salinan firstVariable = secondVariable;Sama seperti jika Anda telah secara eksplisit menyatakan firstVariable menjadi tipe int, setelah itu secara implisit diketik, Anda tidak dapat menetapkan nilai dari sebuah variabel tipe double untuk itu, karena Anda akan kehilangan bagian dari nilai, seperti yang akan Anda lihat dalam Bab 4, Operator.Anda mungkin bertanya-tanya: jika compiler dapat menentukan jenis variabel untuk Anda, mengapa tidak hanya menggunakan var sepanjang waktu, bukan mengganggu dengan secara eksplisit mendeklarasikan jenis? Alasan utama adalah bahwa jenis implisit membuat kode Anda sulit untuk dibaca, dan dengan demikian sulit untuk mempertahankan. Ini lebih dari cukup alasan untuk menghindari menggunakan var kecuali bila diperlukan. Alasan kedua adalah bahwa compiler dapat menebak salah, dan dengan demikian memperkenalkan kesalahan kecil tapi jahat ke dalam kode Anda. Jika Anda menulis sebuah program matematika, dan Anda menggunakan var tugas Anda seperti ini: Salinan var a = 12; var b = 7;compiler akan memutuskan bahwa kedua a dan b harus bertipe int. Tetapi jika Anda berpikir mereka harus bertipe double, dan kemudian mencoba sesuatu seperti ini: Salinan a = 7.4; b = 5,5;Anda akan mendapatkan error, karena compiler tidak bisa membaca pikiran Anda. Pengecoran

Anda dapat menyebabkan compiler untuk mengabaikan aturan keselamatan jenis dan mengobati satu jenis objek seolah-olah sebuah objek dari tipe lain, jika jenis yang kompatibel. Hal ini disebut casting. Casting dapat berupa implisit atau eksplisit. Konversi implisit terjadi secara otomatis; compiler menangani untuk Anda. Jika Anda memiliki pendek, dan Anda menetapkan ke variabel bertipe int, compiler secara otomatis (dan diam-diam) gips untuk Anda. Anda tidak perlu mengambil tindakan apapun. Ini aman, karena sebuah variabel int dapat menyimpan nilai apapun yang mungkin telah dalam variabel pendek.Salinan singkat myShort = 5; / / Kode lain di sini ... int Myint = myShort; / / konversi implisitProgrammer sering berbicara tentang hal ini seolah-olah sedang pendek berubah menjadi int. Apa yang sebenarnya terjadi adalah bahwa compiler yang menerima pendek di mana mereka mengharapkan untuk menemukan int, karena itu adalah hal yang aman untuk dilakukan. Konversi implisit hanya bekerja bila tidak ada kemungkinan hilangnya data, meskipun. Lihatlah ini: Salinan int Myint; ganda myDouble = 4,7; Myint = myDouble;Jika Anda mencoba tugas itu, compiler memberikan Anda sebuah pesan kesalahan karena Anda tidak bisa menekan angka desimal ke ruang integer. Anda akan kehilangan bagian fraksional (.7). Pada kenyataannya, bahkan jika Anda menulis: Salinan int Myint; ganda myDouble = 4 Myint = myDouble;compiler masih akan menghasilkan kesalahan. Meskipun tidak ada bagian pecahan kalah dalam kasus ini (ganda adalah memegang seluruh nomor), compiler tidak dapat mengambil kesempatan bahwa sesuatu akan terjadi yang dapat mengubah kondisi, sehingga hanya menolak semua tugas ganda ke sebuah int.Ini adalah di mana konversi eksplisit datang dalam-ketika ada bahaya kehilangan data. Sebagai contoh, meskipun compiler akan membiarkan Anda mengkonversi int ke double secara implisit (tidak ada kesempatan Anda bisa kehilangan data), tidak akan membiarkan Anda implisit mengubah double ke int, seperti yang Anda lihat. Jika Anda kebetulan tahu bahwa itu benar-benar aman dalam situasi khusus Anda untuk membuat tugas-jika Anda tahu apa yang Anda lakukan-Anda dapat memaksa compiler untuk menerima tugas dengan cast eksplisit. Sekali lagi, beberapa programmer berbicara tentang "casting dua kali lipat ke integer," tapi kau tidak benar-benar mengubah variabel baik di semua, Anda hanya memerintahkan compiler untuk mengabaikan keselamatan jenis-aturan untuk saat ini dan menerima penugasan dari nilai yang dimiliki oleh variabel ganda untuk variabel integer. Compiler akan mematuhi, dan justru akan membuang bagian pecahan. Anda menetapkan konversi eksplisit dengan menempatkan jenis yang ingin Anda tetapkan dalam kurung, langsung di depan variabel dengan nilai berisiko: Salinan int myDouble = 4,7; / / Kode lain di sini ... Myint int = (int) myDouble; / / konversi eksplisitKata kunci (int) diperlukan untuk membuat konversi eksplisit; tanpa itu compiler akan menghasilkan kesalahan. Perhatikan, meskipun, bahwa dalam kasus ini, Anda mengiris nilai pecahan dari ganda, dan Myint akan memiliki hanya bagian integral (4), itulah sebabnya mengapa kita mengatakan Anda harus tahu apa yang Anda lakukan. Kadang-kadang Anda memerlukan konversi eksplisit (meskipun tidak sering), tetapi biasanya ketika Anda mengambil suatu objek keluar dari koleksi dan Anda perlu untuk mengubahnya menjadi "nyata" jenisnya, semua yang akan kita bahas pada bab selanjutnya . Bahkan kemudian, Anda menguji untuk memastikan objek yang Anda miliki adalah apa yang Anda pikirkan. Dengan semacam ini konversi eksplisit, Anda hampir dijamin untuk kehilangan nilai cepat atau lambat. Konstanta

Variabel merupakan alat yang kuat, tapi kadang-kadang anda ingin menggunakan nilai yang ditetapkan, salah satu yang nilainya Anda ingin memastikan tetap konstan. Sebuah konstanta adalah seperti variabel dalam hal ini dapat menyimpan sebuah nilai. Namun, tidak seperti variabel, Anda tidak dapat mengubah nilai konstan sementara program berjalan. Sebagai contoh, Anda mungkin perlu untuk bekerja dengan Fahrenheit titik beku dan titik didih air dalam sebuah program simulasi percobaan kimia. Program anda akan lebih jelas jika Anda nama variabel yang menyimpan nilai-nilai FreezingPoint dan BoilingPoint, tetapi Anda tidak ingin izin nilai-nilai mereka harus diubah saat program sedang dijalankan. Solusinya adalah dengan menggunakan sebuah konstanta. Konstanta datang dalam tiga rasa: literal, konstanta simbolis, dan enumerations.Literal Konstanta Sebuah konstanta literal hanya nilai. Misalnya, 32 adalah konstanta literal. Ia tidak memiliki nama, itu hanya nilai literal. Dan Anda tidak dapat membuat nilai 32 mewakili nilai lain. Nilai 32 selalu 32. Anda tidak dapat menetapkan nilai baru untuk 32, dan Anda tidak dapat membuat 32 mewakili nilai 99 tidak peduli seberapa keras Anda mungkin mencoba. Anda akan menggunakan konstanta literal banyak, tapi Anda mungkin tidak akan berpikir mereka seperti itu. Konstanta Simbolis Konstanta simbolis menetapkan nama untuk nilai konstan. Anda mendeklarasikan sebuah konstanta simbolik menggunakan sintaks berikut: Salinan Jenis identifier const = nilai;Kata kunci const diikuti oleh jenis, identifier, operator penugasan (=), dan nilai untuk menetapkan ke konstan. Hal ini mirip dengan mendeklarasikan variabel kecuali bahwa Anda mulai dengan kata kunci const dan konstanta simbolik harus diinisialisasi. Setelah diinisialisasi, sebuah konstanta simbolik tidak dapat diubah. Sebagai contoh, dalam deklarasi berikut, 32 adalah konstanta literal dan FreezingPoint adalah konstanta simbolik dari tipe int:Salinan const int FreezingPoint = 32;Contoh 3.4, "Program ini mendefinisikan dua konstanta simbolis dan output nilai-nilai mereka, itu tidak akan mengkompilasi, meskipun, karena upaya untuk menetapkan nilai baru untuk sebuah konstanta" menggambarkan penggunaan konstanta simbolis. Contoh 3.4. Program ini mendefinisikan dua konstanta simbolis dan output nilai-nilai mereka, itu tidak akan mengkompilasi, meskipun, karena upaya untuk menetapkan nilai baru untuk konstan Salinan using System; menggunakan System.Collections.Generic; menggunakan System.Linq; menggunakan System.Text;

namespace Example_3_4_ _ _ _Symbolic_Constants { Nilai kelas { static void Main () { const int FreezingPoint = 32; / / derajat Fahrenheit const int BoilingPoint = 212;

System.Console.WriteLine ("Titik beku air: {0}", FreezingPoint); System.Console.WriteLine ("Titik didih air: {0}", BoilingPoint);

BoilingPoint = 21; } } }Contoh 3.4, "Program ini mendefinisikan dua konstanta simbolis dan output nilai-nilai mereka, itu tidak akan mengkompilasi, meskipun, karena upaya untuk menetapkan nilai baru untuk sebuah konstanta" menciptakan dua konstanta integer simbolis: FreezingPoint dan BoilingPoint. (Lihat "Konvensi Penamaan" sidebar untuk sebuah diskusi tentang bagaimana untuk nama konstanta simbolis.) Konstanta ini melayani tujuan yang sama dengan menggunakan nilai-nilai literal 32 dan 212 untuk titik beku dan titik didih air, masing-masing, dalam ungkapan yang mengharuskan mereka. Namun, karena memiliki nama konstanta, mereka menyampaikan makna jauh lebih banyak. Ini mungkin tampak lebih mudah untuk hanya menggunakan nilai-nilai harafiah 32 dan 212 bukannya pergi ke kesulitan menyatakan konstanta, tetapi jika Anda memutuskan untuk beralih program ini untuk Celcius, Anda dapat menginisialisasi ulang konstanta ini pada waktu kompilasi ke 0 dan 100, masing-masing, dan semua sisa kode harus terus bekerja. Jika Anda mencoba untuk menjalankan program yang ditunjukkan pada Contoh 3.4, "Program ini mendefinisikan dua konstanta simbolis dan output nilai-nilai mereka, itu tidak akan mengkompilasi, meskipun, karena upaya untuk menetapkan nilai baru untuk sebuah konstanta", Anda akan menerima error berikut: Salinan Sisi kiri dari penugasan harus properti, variabel atau indexerItu karena tugas di baris ini adalah ilegal: Salinan BoilingPoint = 21;Anda tidak dapat menetapkan nilai baru ke konstan, sehingga compiler mengeluh. Untuk memperbaiki masalah ini, hanya komentar keluar garis menyinggung dengan menambahkan dua garis miring di depannya, seperti ini: Salinan / / BoilingPoint = 21;Sekarang program ini berjalan seperti yang diharapkan, tanpa kesalahan. Konvensi PenamaanMicrosoft telah mengeluarkan instruksi tentang bagaimana Anda harus nama variabel, konstanta, dan objek lain dalam program Anda. Mereka mendefinisikan dua jenis konvensi penamaan: Camel dan notasi notasi Pascal. Dalam notasi Camel, namanya dimulai dengan huruf kecil. Nama berbentuk frase (seperti "tombol saya") ditulis tanpa spasi dan tidak ada garis bawah dan dengan setiap kata setelah yang pertama dikapitalisasi. Dengan demikian, nama yang benar untuk "tombol saya" adalah myButton.Notasi Pascal adalah seperti notasi Unta kecuali bahwa huruf pertama juga huruf besar (FreezingPoint).Microsoft menunjukkan bahwa variabel ditulis dengan notasi Camel dan konstanta dengan notasi Pascal. Dalam bab-bab selanjutnya, Anda akan belajar bahwa variabel anggota diberi nama menggunakan notasi Camel, sedangkan metode dan kelas yang diberi nama menggunakan notasi Pascal. Enumerations Enumerations memberikan alternatif yang kuat untuk konstanta literal atau simbolik sederhana. Pencacahan adalah jenis nilai yang berbeda, yang terdiri dari satu set konstanta bernama (disebut daftar pencacah). Pada Contoh 3.4, "Program ini mendefinisikan dua konstanta simbolis dan output nilai-nilai mereka, itu tidak akan mengkompilasi, meskipun, karena upaya untuk menetapkan nilai baru untuk sebuah konstanta", Anda menciptakan dua konstanta yang terkait: Salinan const int FreezingPoint = 32; const int BoilingPoint = 212;Anda mungkin ingin menambahkan beberapa konstanta yang berguna lainnya untuk daftar ini juga, seperti: Salinan const int LightJacketWeather = 60; const int SwimmingWeather = 72; const int WickedCold = 0;Perhatikan, bagaimanapun, bahwa proses ini agak rumit,. Juga, sintaks ini tidak menunjukkan hubungan logis antara konstanta-mereka mengatur berbagai hanya nilai-nilai yang tidak terkait Anda tahu bahwa konstanta ini semua mengacu pada suhu, namun compiler tidak memiliki cara untuk mengetahui bahwa. C # menyediakan membangun alternatif, pencacahan, yang memungkinkan Anda untuk konstanta kelompok logis terkait, seperti berikut: Salinan Suhu enum { WickedCold = 0, FreezingPoint = 32, LightJacketWeather = 60, SwimmingWeather = 72, BoilingPoint = 212, }Tip

Entri dalam pencacahan dipisahkan dengan koma. Banyak programmer ingin meninggalkan tanda koma setelah entri terakhir dalam penghitungan sebagai kemudahan untuk menambahkan nilai lebih kemudian. Programmer lain menemukan ini, di terbaik, ceroboh. Kode akan mengkompilasi cara baik.

The syntax for specifying an enumeration uses the enum keyword, as follows: Salinanenum identifier [:base-type]{enumerator-list};Tip

In a specification statement such as the preceding example, the square brackets indicate an optional element. Thus, you can declare an enum with no base type, simply by leaving it out (leave out the square brackets as well).

There are also optional attributes and modifiers you can use, but you don't need them right now. An enumeration begins with the keyword enum , which is generally followed by an identifier; in this case, Temperatures : Salinanenum TemperaturesThe base type is the underlying type for the enumeration. You might specify that you are declaring constant int s, constant long s, or something else. If you leave out this optional value (and often you will), it defaults to int , but you are free to use any of the integral types ( ushort , long ) except for char . For example, the following fragment declares an enumeration with unsigned integers ( uint ) as the base type: Salinanenum ServingSizes : uint { Small = 1, Regular = 2, Large = 3 }Notice that an enum declaration ends with the enumerator list, which contains the constant assignments for the enumeration, each separated by a comma. Example 3.5, "An enumeration represents a set of values that you don't want to change while your program is running" rewrites Example 3.4, "This program defines two symbolic constants and outputs their values; it won't compile, though, because of the attempt to assign a new value to a constant" to use an enumeration. Example 3.5. An enumeration represents a set of values that you don't want to change while your program is running Salinan using System; menggunakan System.Collections.Generic; menggunakan System.Linq; menggunakan System.Text;

namespace Example_3_5_ _ _ _Enumerations { class Values { // declare the enumeration enum Temperatures { WickedCold = 0, FreezingPoint = 32, LightJacketWeather = 60, SwimmingWeather = 72, BoilingPoint = 212, }

static void Main( ) { System.Console.WriteLine("Freezing point of water: {0}", (int)Temperatures.FreezingPoint); System.Console.WriteLine("Boiling point of water: {0}", (int)Temperatures.BoilingPoint); } } }In Example 3.5, "An enumeration represents a set of values that you don't want to change while your program is running", you declare an enumerated constant called Temperatures . When you want to use any of the values in an enumeration in a program, the values of the enumeration must be qualified by the enumeration name. That is, you can't just refer to FreezingPoint ; instead, you use the enumeration identifier ( Temperature ) followed by the dot operator and then the enumerated constant ( FreezingPoint ). This is called qualifying the identifier FreezingPoint . Thus, to refer to the FreezingPoint , you use the full identifier Temperature.FreezingPoint . You might want to display the value of an enumerated constant to the console, as in the following: SalinanConsole.WriteLine("The freezing point of water is {0}", (int) Temperature.FreezingPoint);To make this work properly, you must cast the constant to its underlying type ( int ). In this case, you are saying, "Treat this enumerated constant as an int ." Because you know the underlying type is int , this is safe to do. (See "Casting" earlier in this chapter.) In Example 3.5, "An enumeration represents a set of values that you don't want to change while your program is running", the values in the two enumerated constants FreezingPoint and BoilingPoint are both cast to type int ; then that integer value is passed to WriteLine( ) and displayed. Each constant in an enumeration corresponds to a numerical value. In Example 3.5, "An enumeration represents a set of values that you don't want to change while your program is running", each enumerated value is an integer. If you don't specifically set it otherwise, the enumeration begins at 0 and each subsequent value counts up from the previous. Thus, if you create the following enumeration: Salinanenum SomeValues { Pertama, Kedua, Third = 20, Keempat }the value of First will be 0, Second will be 1, Third will be 20, and Fourth will be 21. String

It is nearly impossible to write a C# program without creating strings, and we wouldn't want to deprive you of them here. Strings are actually complex classes that we'll cover much more thoroughly in Chapter 15, Strings . For now, though, all you need to know is that a string object holds a series of characters. You declare a string variable using the string keyword much as you would create an instance of any type: Salinan String myString;You specify a string literal by enclosing it in double quotes: Salinan "Hello World"You already used a string literal back in Chapter 1, C# and .NET Programming , in the Hello World example. You'll frequently initialize a string variable by assigning it a string literal: Salinanstring myString = "Hello World";Whitespace

In the C# language, spaces, tabs, and newlines are considered to be whitespace (so named because you see only the white of the underlying "page"). Extra whitespace is generally ignored in C# statements. Thus, you can write: SalinanmyVariable = 5;atau: SalinanmyVariable = 5 ;and the compiler will treat the two statements as identical. The key is to use whitespace to make the program more readable to the programmer; the compiler is indifferent. The exception to this rule is that whitespace within a string is treated as literal; it is not ignored. If you write: SalinanConsole.WriteLine("Hello World")each space between "Hello" and "World" is treated as another character in the string. (In this case, there is only one space character.) Problems arise only when you do not leave space between logical program elements that require it. For instance, the expression: Salinanint myVariable = 5 ;is the same as: Salinanint myVariable=5;tetapi tidak sama dengan: SalinanintmyVariable =5;The compiler knows that the whitespace on either side of the assignment operator is extra, but at least some whitespace between the type declaration int and the variable name myVariable is not extra; it is required. This is not surprising; the whitespace allows the compiler to parse the keyword int rather than some unknown term intmyVariable . You are free to add as much or as little whitespace between int and myVariable as you care to, but there must be at least one whitespace character (typically a space or tab). Tip

Visual Basic programmers take note: in C#, the end-of-line has no special significance. Statements are ended with semicolons, not newline characters. There is no line continuation character because none is needed.

Ringkasan

A complete program instruction is called a statement. Each statement ends with a semicolon ( ; ). All objects, variables, and constants must have a specific type. Most of the intrinsic types are used for working with numeric values. You will commonly use int for whole numbers and double or float for fractional values. The char type is used for holding a single character. The bool type can hold only the value true or false. A variable is an instance of a type. You initialize a variable by creating it with an assigned value. You can use the var keyword to create a variable without a type, but only if you assign it immediately. The complier will determine the type of the variable from the value assigned. You can cast a value from one type to another as long as the compiler knows how to turn the original type into the cast-to type. If no information can be lost, you may cast from one type to another implicitly. If information may be lost, you must cast explicitly. You accomplish the cast by prefacing the variable with the name of the type you want to cast to, in parentheses. A constant is similar to a variable, but the value cannot be changed while the program is running. Literal constants are simply values used on their own. Symbolic constants, indicated with the const keyword, are values with assigned names, which you use like variables, but the values cannot change. An enumeration is a value type that consists of a set of named constants. A string object holds a series of characters (such as a word or sentence). A string literal is simply text enclosed by double quotes. You can assign a string to a string variable, just as you would make any other assignment. Extra whitespace (spaces, tabs, and newline characters) is ignored by the compiler, unless it appears within a string. We promised you fundamentals in this chapter, and that's what you got. Just about every programming language you want to learn starts with data types, variables, and assignment. Without variables to hold your data, there isn't much to program with. So, now you know how to hold onto data within the bounds of your program. But what can you do with it? At the moment, you know how to print it out to the screen, and that's about it. That will change in Chapter 4, Operators . There, we'll show you how to manipulate the data with some basic operators, just like you remember from math class. We'll also show you how to compare variables too, which may not sound like much, but it's critically important, as you'll see in Chapter 5, Branching . Test Your Knowledge: Quiz

Question 3-1 . What defines a statement in C#? Question 3-2 . What values can a bool type have? Question 3-3 . What are the two kinds of types in C#, and what's the difference between them? Question 3-4 . What is the difference between a float and a double ? Question 3-5 . What's the definition of a variable? Question 3-6 . What does definite assignment mean? Question 3-7 . Which of the following code statements will compile? Salinanint myInt = 25;long myLong = myInt;int newInt = myLong;Question 3-8 . For each of the following pieces of data, which variable type would you use, and which should be represented with constants? Your age in years The speed of light in meters per second The number of widgets in your warehouse The amount of money in your bank account The text of the US Declaration of Independence Question 3-9 . Given the following declaration, how would you refer to the constant for Green and what would its value be? Salinanenum WavelengthsOfLight { Red = 7000, Orange = 6200, Yellow = 5800, Green = 5300, Blue = 4700, Violet = 4200 }Question 3-10 . How do you indicate a string literal? Test Your Knowledge: Exercises

Exercise 3-1 . We'll start easy for this project. Write a short program that creates five variables, one of each of the following types: int , float , double , char , and string . Name the variables whatever you like. Initialize the variables with the following values: int : 42 float : 98.6 double : 12345.6789 char : Z string : The quick brown fox jumped over the lazy dogs. Then, output the values to the console. Exercise 3-2 . As you gain more experience with programming, you'll frequently find yourself adapting some code that you wrote before, instead of writing a new program from scratch-and there's no time like the present to start. Modify the program in Exercise 3-1 so that after you've output the values of the variables the first time, you change them to the following: int : 25 float : 100.3 double : 98765.4321 char : M string : A quick movement of the enemy will jeopardize six gun boats. Then output the values to the console a second time. Exercise 3-3 . Write a new program to declare a constant double . Call the constant Pi , set its value to 3.14159, and output its value to the screen. Then change the value of Pi to 3.1 and output its value again. What happens when you try to compile this program? Exercise 3-4 . Write a new program and create a constant enumeration with constants for each month of the year. Give each month the value equal to its numeric place in the calendar, so January is 1, February is 2, and so on. Then output the value for June, with an appropriate message.