Си шарп: создание приложений для windows

страница №5

...укций сравнения
Оператор if в инструкции сравнения может применять несколько инструкций,
объединенных арифметическими операторами. В качестве последних
используются операторы (&& - И), (I I -ИЛИ) и (! - НЕ).
Рассмотрим пример использования составных инструкций в блоке if.
using System;
namespace C_Sharprograrr.ming
{
class Conditions
{
static void Main(string[] args)
{
int nl = 5;
int n2 - 0;
iff (nl == 5) SS (n2 == 5))
Console.WriteLine("Инструкция И верка");
else
Console.WriteLine("Инструкция и не верна"];
if((nl == 5| || (п2 == 5))
Console.WriteLine("Инструкция ИЛИ верна");
else
Console.WriteLine("Инструкция ИЛИ не верна");
В данном примере каждая инструкция if проверяет сразу два условия.
Первое if условие использует оператор (&&) для проверки условия. Необходимо,
чтобы сразу два условия в блоке if были истинны. Только тогда
выражение будет считаться верным:
i f ! ( n i == 5) &s (n2 - 5) )
При этом не всегда выполняются все выражения в блоке if. Если первое
выражение однозначно определяет результат операции, то второе уже не
проверяется. Так, если бы условие nl == 5 было ложным, то условие п2 ==
5 уже не проверялось бы, поскольку его результат перестал бы играть роль.
Второе выражение использует оператор (II) для проверки сложного
условия:
i f ( ( n l = = 5 ] | : ( n 2 - 5 ) )
В данном случае для верности всего выражения достаточно истинности
лишь одного из условий. И тогда действует правило проверки условий
до выяснения однозначности результата. То есть, если условие nl
== 5 верно, то п2 == 5 уже проверяться не будет. Это свойство может
сыграть очень важную роль при разработке кода программ. Давайте
рассмотрим пример.
using Syscem;
namespace C_Sharprogramming
{
class Conditions
{
static void Main(string[] args)
{
сопнс int MAX_VALUE - 3;
inс nl - 1;
int n2 = 1;
if(i++nl " MAX_VALUE) 5Б (++n2 " MAK_VALUE))
Console.WriteLine("Операция SS nl:-(0 } n2: = {1}", nl, n2);
if(i+ + nl " MAX_VALUE + 1) II (i- + n2 " MAX_ VALUE + 1) )
Console.WriteLine("Операция I I nl:-{0} n2:-{l;", nl, n2);
Результат работы программы будет следующий:
Операция && nl:=2 п2:=2
Операция 11 nl:=3 п2:=2
70 Раздел I I . Фундаментальные понятия
Заметьте, что первый оператор if нарастил значения обеих переменных,
потому как осуществлялась проверка обоих условий. Второй оператор
if выполнил инкремент только переменной nl. Причина в том, что
условие (++nl"MAX_VALUE+l) уже однозначно определяет весь блок if
как истинный, поэтому дальнейшая проверка не выполняется, как и все
действия, связанные с проверкой оставшихся условий.
Оператор switch как альтернатива оператору условия
Достаточно часто встречаются ситуации, когда вложенные условные
операторы выполняют множество проверок на совпадение значения переменной,
но среди этих условных операторов только один является истинным.

if (myValue == 10) Console.WriteLine("myValue равно 10");
else
if (myValue -= 20) Console.WriteLine("myValue равно 20 " ) ;
else
if (myValue -= 30} Console.WriteLine("myValue равно 30 " ) ;
else ....

Когда вы имеете такой сложный набор условий, лучше всего воспользоваться
оператором switch, который является более удобной альтернативой
оператору if.
Логика оператора switch следующая: "найти значение, соответствующее
переменной для сравнения, и выполнить соответствующее действие".
Иными словами, он работает как оператор выбора нужного действия.
switch (выражение)
{
case константное выражение: инструкция
выраженке перехода
[default:: инструкция]
Вы видите, что, подобно оператору условия if...else, выражение условия
помещено в круглые скобки в начале оператора switch.
Внутри оператора switch есть секция выбора -case и секция действия
по умолчанию -default. Секция выбора нужна для определения действия,
которое будет выполняться при совпадении соответствующего константного
выражения выражению в switch. В этой секции обязательно нужно
указать одно или несколько действий. Секция default может в операторе
switch не указываться. Она выполняется в том случае, если не совпала ни
одна константная инструкция из секции выбора.
Оператор case требует обязательного указания значения для сравнения
(constant-expression) - константного выражение (литеральная или
символическая константа, или перечисление), а также блока инструкций
(statement) и оператора прерывания действия (jump-statement).
Если результат условия совпадет с константным значением оператора
case, то будет выполняться соответствующий ему блок инструкций. Как
Ветвление программ 71
правило, в качестве оператор перехода используют оператор break, который
прерывает выполнение оператора switch. Альтернативой ему может
быть и другой оператор - goto, который обычно применяют для перехода
в другое место программы.
Чтобы вы могли увидеть, как оператор switch заменяет сложный набор
условий, приведем пример той же программы, но с использованием оператора
switch:
switch ( nyVslue )
case 10:
Console.WriteLine("myValue равно 10" | ;
break;
case 20:
Console.WriteLine("myValue равно 20");
break;
case 30: Console.WriteLine("myValue равно 30"];
break;
}
В этом примере мы проверяем значение переменной myValue на равенство
ее одному из следующих значений: 10, 20, 30. Если, например, myValue
будет равно 10, то на экран выведется строка:
myValue is 10
В языке С и C++ вы можете автоматически перейти к секции следующего
case, если в конце предыдущего не стоит инструкция перехода break
или goto. Таким образом, на C++ вы можете написать:
case I: statmentl;
case 2: sza;:ment2;
break;
В этом примере на C++ после выполнения statementl будет автоматически
выполняться секция statment2.
В С# это работать не будет. Автоматический переход от case 1 к следующей
секции case 2 будет выполняться только в том случае, если секция
case 1 окажется пустой (не будет содержать ни одной инструкции). В
противном же случае перехода к выполнению case 2 не произойдет, так
как в С# каждая непустая секция инструкций оператора case должна
содержать в себе оператор break.
case 1: Console.WriteLine("Выражение секции 1");
case 2:
Здесь case 1 содержит инструкцию, поэтому вы не сможете автоматически
перейти к выполнению case 2. Такой код вообще не будет компилироваться.
Если вы хотите перейти после выполнения case 1 к выполнению
case 2, то должны явно указать это при помощи оператора
goto:
case I: Console.WriteLine("Выражение секции 1");
goto case 2
case 2:
72 Раздел I I . Фундаментальные понятия
Однако другая форма использования оператора switch позволит обойтись
без инструкции goto:
case I:
case 2:
Console.WriteLine("Выражение секций 1 и 2");
Такой принцип работы оператора switch используется в случае, когда
необходимо выполнить одно и то же действие (или часть действия) для
разных значений условного оператора.

using System;
namespace SwitchStaterr.ent
class MyClass
static void Main(string[j args)
i
int user - 0;
user = Convert.Tolnt32(Console.ReadLine(I ];
switch(user)
case 0:
Console.WriteLine("Здравствуйте Userl");
break;
case 1 :
Console.WriteLine("Здравствуйте User2");
break;
case 2:
Console.WriteLine("Здравствуйте User3");
break;
default:
Console.WriteLine("Здравствуйте новый пользователь");
break;
}
]
}
Этот пример выводит на экран сообщение с приветствием пользователя
в зависимости от введенного на экране значения. Так, если вы введете
число 1, то на экране появится сообщение "Здравствуйте User2".
В данном примере для выбора выражения, выводящего сообщение на
экран, использовалось числовое значение {0, 1 или 2}. Если же вы введете
иное значение, нежели представленное в массиве, то на экране появится
сообщение "Здравствуйте новый пользователь".
Ветвление программ 73
Объявление переменных внутри case инструкций
Рассмотрим случай, когда вам необходимо создать в программе
сложную case инструкцию. Для придания программе большей читабельности
создание переменных, необходимых для использования,
лучше всего объявлять непосредственно перед их применением. Так,
если каждый блок case использует свой набор переменных, то и объявление
переменных следует делать внутри блоков case. Посмотрите на
следующий код:
using System;
namespace C_Sharp_Programming
{
class Part
{
public static void Main()
{
Console.WriteLinc("1: ввод наименования товара\п2: ввод количеств;:
товара");
int Choice - Convert.Tolnt32(Console.ReadLine());
switch(Choice]
case 1 :
string Kane;
Console.Write("Введите наименование товара " ) ;
Name = Console.ReadLine();
break;
case 2:
int Count;
Console.Write("Введите количество товара " ) ;
Name = Console.ReadLine();
Count = Convert.Tolnt32(Console.ReadLine()) ;
break;
default:
break;
t
Знатоки C++ могут без труда увидеть, что на C++ такая switch инструкция
компилироваться не будет. Причина этому - объявление переменных
внутри блоков case. Однако разработчики С# постарались и предусмотрели
возможность создания переменных внутри case блоков. Поэтому
на С# такой код является рабочим.
74 Раздел I I . Фундаментал ьные понятия
Switch и работа со строками
В приведенном примере переменная user была целочисленного типа. Если
вам необходимо использовать в качестве условия оператора switch переменную
строкового типа, то вы можете сделать это следующим образом:
сазе "Сергей":
Если строк для сравнения много, то по аналогии с целочисленной
переменной user используйте несколько инструкций case.

Вот пример использования строковой переменной в качестве условия
оператора switch.
using System;
namespace SwitchStatement

1

class MyClass
{
static void Main(string[] args)
{
string user;
user ^ Console.ReadLineО ;
switch(user)
{
case "userl":
Console.WriteLine("Здравствуйте пользователь один");
break;
case "user2":
Console.WriteLine ("Здравствуйте пользователь два");
break;
case "user3":
Console.WriteLine ("Здравствуйте пользователь три");
break;
default:
Console.WriteLine("Здравствуйте новый пользователь");
break;
В данном случае для идентификации пользователя вам необходимо
применить не числовое значение, а строку. Если вы введете строку "userl",
то на экране появится сообщение "Здравствуйте пользователь один".
8. ЦИКЛИЧЕСКИЕ ОПЕРАТОРЫ
С# включает достаточно большой набор циклических операторов, таких
как for, while, do...while, а также цикл с перебором каждого элемента
foreach (плохо знакомый программистам С, но хорошо известный VB-npoграммистам).
Кроме того, С# поддерживает операторы перехода и возврата,
например goto, break, continue и return.
ОПЕРАТОР goto
Оператор goto был основой для реализации других операторов цикла.
Но он был и базой многократных переходов, вследствие чего возникла
запутанность кода программы. Поэтому опытные программисты стараются
его не использовать, но для того чтобы узнать все возможности
языка, рассмотрим и этот оператор.
Он используется следующим образом:
1. Создается метка в коде программы Label 1.
2. Организуется переход на эту метку goto Labell.
Имя метки Labell обязательно должно заканчиваться двоеточием. Оно
указывает на точку в программе, с которой будет выполняться программа
после использования инструкции goto. Обычно инструкция goto привязывается
к условию, как показано в следующем примере:
using System;
public class Labels
{
public static int Main( ]
(
int i = C;
label:
Console.WriteLine ("i: {0 } ", i);
i -i + ;
if (i " 10)
goto label;
return 0;
Здесь мы выводим на экран строку со значением i десять раз (от 0 до 9).
Инструкция goto помогает повторить выполнение одних и тех же инструкций
определенное число раз. В этой программе число повторов опре76
Раздел I I . Фундаментальные понятия
деляется инструкцией if(i " 10). Значит, до тех пор пока переменная i
будет иметь значение меньшее, чем 10, goto будет переносить нас на
метку label:, а значит, вывод строки на экран будет повторяться. То есть
с использованием goto мы можем организовать циклический повтор операций
в программе.
Именно это явление привело к созданию альтернативного метода организации
циклов, такого как while, do..while, for или foreach. Большинство
программистов понимают, что использование goto в программе лучше
заменять чем-нибудь другим, что приведет к созданию программного кода,
более структурированного и понятного, нежели инструкции goto.
ЦИКЛ while
Эта циклическая инструкция работает по принципу: "Пока выполняется
условие - происходит работа". Ее синтаксис выглядит следующим
образом:
whilfi (выражение)

1

инструкция;

I

Как и в других инструкциях, выражение - это условие, которое оценивается
как булево значение. Если результатом проверки условия является
истина, то выполняется блок инструкций, в противном случае в результате
выполнения программы while игнорируется. Рассмотрим пример,
приведенный выше, только с использованием while:
using System;
public class Labels
public static int Main( ]
int i = 0;
while(i " 10)
t
Console.WriteLine("i: (0}", i) ;
iii;
return 0;
По своей функциональности и та, и другая реализация программы работают
абсолютно одинаково, но логика работы несколько изменилась. Заметьте,
что цикл while проверяет значение i перед выполнением блока
statement. Это гарантирует, что цикл не будет выполняться, если проверяемое
условие ложно. Таким образом, если первоначально i примет значение
Циклические операторы 77
10 и более, цикл не выполнится ни разу. Инструкция while является вполне
самостоятельной, а в данном примере ее можно прочитать подобно предложению:
"пока i меньше 10, выводим сообщение на экран и наращиваем i".
ЦИКЛ do... while
Бывают случаи, когда цикл while не совсем удовлетворяет вашим требованиям.
Например, вы хотите проверять условие не в начале, а в конце
цикла. В таком случае лучше использовать цикл do...while.
do{
инструкция
Jwhile (выражение);
Подобно while, выражение - это условие, которое оценивается как булево
значение.
Это выражение можно прочитать как: "выполнить действие; если выполняется
условие - повторить выполнение еще раз". Заметьте разницу
между этой формулировкой и формулировкой работы цикла while. Разница
состоит в том, что цикл do...while выполняется всегда минимум один
раз, до того как произойдет проверка условия выражения.
using System;
public 2lass Labels
public static int Main( ]
int i = 0;
do
Consols . WriteLine ("i : {0 ;• ", i) ;
[while(i " 10) ;
return 0;

1

На этом примере видно, что если первоначально i примет значение 10
и более, цикл выполнится. Затем произойдет проверка условия while (i "
10), результатом которой станет ложь (false), и повтора выполнения цикла
не произойдет. То есть он выполнится один раз. Как вы помните, при
таких же начальных условиях while не выполнился ни разу.
ЦИКЛ for
Если еще раз внимательно посмотреть на примеры (while, do...while,
goto), можно заметить постоянно повторяющиеся операции: первоначальная
инициализация переменной i, ее наращивание на 1 внутри цикла,
78 Раздел I I . Фундаментальные понятия
проверка переменной i на выполнение условия (i " 10). Цикл for позволяет
вам объединить все операции в одной инструкции.
for ( [инициализация ]; [ выражение]; [ наращивание] )
{инструкция}
Продолжим рассмотрение на том же примере, но с использованием
цикла for:
using System;
public class Labels
public static int Main ( )
{
for(int i = 0; i " 10; i++]
{
Console.WriteLine("i: {0}", i);

I

return 0;
Результатом выполнения такого цикла будет вывод на экран информации
вида:

0123456789

Принцип работы такой инструкции очень прост:
1. Происходит инициализация переменной i.
2. Выполняется проверка соответствия условию. Если условие истинно,
то происходит выполнение блока вложенных инструкций; если условие
оказалось ложным, то цикл прекращается и выполняется программа
за фигурными скобками.
3. Наращивается переменная i.
Наращивание переменной внутри цикла происходит на такое число
единиц, на которое вы сами зададите. Операция i++ означает "нарастить
переменную на 1". Если вы хотите использовать другой шаг изменения i,
то смело можете написать так i += 2. В этом случае переменная i будет
изменяться на 2 единицы, и на экране вы увидите:
0 2 4 6 8
ЦИКЛ foreach
Эта инструкция незнакома программистам на языке С, она используется
для перебора массивов и объединений (collection) по элементам. Разговор
о ней пойдет в главе 12.
break И continue
Бывают ситуации, когда необходимо прекратить выполнение цикла
досрочно (до того как перестанет выполняться условие) или при какомЦиклические
операторы 79
то условии не выполнять описанные в теле цикла инструкции, не прерывая
при этом цикла. Для таких случаев очень удобно использовать инструкции
break и continue. Если вы хотите на каком-то шаге цикла его прекратить,
не обязательно выполняя до конца описанные в нем действия,
то лучше всего использовать break. Следующий пример хорошо иллюстрирует
его работу.
using System;
class Values
{
static void Main! )
{
//объявляем флаг для обозначения простых чисел
bool IsPrimeNumber;
forlint i - 100; i " 1; i --)
{
//устанавливаем флаг
IsPrimeNumber = true;
for (int j = i-1; j " 1; j--)
//если существует делитель с нулевым остатком
if(i%j == 0)
{
//сбрасываем флаг IsPrimeNumber = false;
// если не нашлось ни одного делителя
//с нулевым остатком-то число простое
if(IsPrimeNumber == true)
Console.WriteLine("(0}- простое число", i);
Программа выполняет поиск всех простых чисел от 2 до 100. В программе
используется два цикла for. Первый цикл перебирает все числа
от 100 до 2. Заметьте, именно от 100 до 2, а не наоборот. Переменная i
инициализируется значением 100 и затем уменьшается на 1 с каждой
итерацией. Второй цикл перебирает все числа от i до 2. Таким образом,
второй цикл будет повторяться 99 + 98 + 97 + ... + 3+2 раз. То есть первый
раз он выполнится 99 раз, второй - 98 и т. д. В теле второго цикла проверяется
выполнение условия: делится ли число i на число j без остатка
(i%j == о). Если это условие верно, то число i нельзя отнести к разряду
простых. Следовательно, флажок, определяющий число как простое, устанавливается
в false. По окончании работы вложенного цикла проверя80
Раздел I I . Фундаментальные понятия
ется условие - не установился ли флажок, определяющий число как простое,
в false. Если нет, то число является простым, и на экран выводится
соответствующее сообщение.
В данной программе происходит выполнение всех описанных действий
внутри цикла. А что если программа уже отнесла число к разряду
не простых чисел? Зачем в этом случае продолжать проверку на существование
нулевого делителя? В этом нет необходимости. Это лишь дополнительная
загрузка ресурсов программы. Для того чтобы прервать
выполнение вложенного цикла, вы можете воспользоваться инструкцией
break. Для этого необходимо изменить код второго цикла так, как
показано ниже:
for(int j = i-1; j " 1; j-)
\
//если существует делитель с нулевым остатком
if (i%j == 0]
{
//сбрасываем флаг IsPrimeNunber = false;
// дальнейшая проверка бессмысленна
break;
Как только сбросится флаг IsPrimeNumber, вложенный цикл сразу же
прервется и выйдет в основной цикл. Таким образом, количество итераций
сократится многократно, что благоприятно скажется на производительности
работы программы.

Оператор continue в отличие от break не прерывает хода выполнения
цикла. Он лишь приостанавливает текущую итерацию и переходит сразу
к проверке условия выполнения цикла.
for (int j = 0; j " 100; j+l )
{
if (j%2 =-* 0)
continue;
Console.WriteLine("{0}", j);
Такой цикл позволит вывести на экран все нечетные числа. Работает
он следующим образом: перебирает все числа от 0 до 100. Если очередное
число четное - все дальнейшие операции в цикле прекращаются, наращивается
число j, и цикл начинается сначала.
СОЗДАНИЕ ВЕЧНЫХ ЦИКЛОВ
При написании приложений с использованием циклов вам следует
остерегаться зацикливания программы. Зацикливание - это ситуация, при
Циклические операторы 81
которой условие выполнения цикла всегда истинно и выход из цикла
невозможен. Давайте рассмотрим простой пример.
using Systeir.;
namesp5.ce C_Sharp_Programming
clase Cycles
{
public static void Main()
{
int nl, r,2;
rl = 0;
r.2 - nl + 1;
while(nl " n2)
{
C o n s o l e . W r i t e L i n e ( " n l - f C } , n 2 = { ! } " , n l , n 2 ) ;
Здесь условие (nl " n2) всегда истинно. Поэтому выход из цикла невозможен.
Следовательно, программа войдет в режим вечного цикла. Такие
ошибки являются критическими, поэтому следует очень внимательно
проверять условия выхода из цикла.
Однако иногда бывает полезно задать в цикле заведомо истинное условие.
Типичным примером вечного цикла является следующая запись:
while(true)
(...)
"Но ведь такая инструкция приведет к зависанию программы!",-скажете
вы. Да, это возможно, если не задать в теле цикла инструкцию его
прерывания. Рассмотрим пример программы:
using System;
namespace C_Sharp_Programming
{
class Cycles
{
public static void Main()
String Name;
while (true)
{
Console .Write ("Введите ваш имя ")_;
Name = Console.ReadLine();
82 Раздел I I . Фундаментальные понятия
Console.WriteLine("Здравствуйте {0}", Name);
Такая программа не имеет выхода. Что бы не ввел пользователь, программа
выдаст строку приветствия и запросит ввод имени заново. Однако
все изменится, если в программу добавить условие, при выполнении
которого цикл прерывается.
using System;
namespace C_Sharp__Programming
{
class Cycles
{
public static void Main{)
{
string Name;
while(true)
{
Console-Write("Введите ваш имя " ) ;
Name = Console.ReadLine();
if (Name == "")
break;
Console.WriteLine("Здравствуйте {0 ) ", Name);
На этот раз, как только пользователь нажмет клавишу "Enter" без
ввода строки данных, сработает инструкция break, и программа выйдет
из цикла.

Создание вечных циклов оправдывает себя, если существует несколько
условий прерывания цикла и их сложно объединить в одно выражение,
записываемое в блоке условия.
Вечный цикл можно создать не только при помощи оператора while.
Любой оператор цикла может быть использован для создания вечных
циклов. Вот как выглядит та же программа, но с использованием цикла
for:
using System;
namespace C_Sharp_Progr aiming
{
class Cycles
{
public static void Main()
________ ^.к- Циклические операторы 83
(
string Кате;
for (;;)
{
Console.Write("Введите ваш имя " ) ;
Name = Console.ReadLine ();
if (Name == "")
break;
Console.WriteLine("Здравствуйте ( 0 } ", Name)
Да-да, цикл for может не содержать ни инструкции инициализации, ни
инструкции проверки, ни инструкции итерации. Два оператора (;) внутри
цикла for означают вечный цикл.
9. КЛАССЫ
Классы - сердце каждого объектно-ориентированного языка. Как вы помните,
класс представляет собой инкапсуляцию данных и методов для их
обработки. Это справедливо для любого объектно-ориентированного языка,
которые отличаются в этом плане лишь типами данных, хранимых в виде
членов, а также возможностями классов. В том, что касается классов и многих
функций языка, С# кое-что заимствует из C++ и Java и привносит немного
изобретательности, помогающей найти элегантные решения старых проблем.
ОПРЕДЕЛЕНИЕ КЛАССОВ
Синтаксис определения классов на С# прост, особенно если вы программируете
на C++ или Java. Поместив перед именем вашего класса
ключевое слово class, вставьте члены класса, заключенные в фигурные
скобки, например:
class MyClass
{
private long rr.yClassId;
Как видите, этот простейший класс с именем MyClass содержит единственный
член - myClassId.
НАЗНАЧЕНИЕ КЛАССОВ
Сначала пару слов о том, для чего нужны классы. Представьте себе,
что у вас есть некоторый объект, который характеризуется рядом свойств.
Например, работник на некой фирме. У него есть такие свойства, как
фамилия, возраст, стаж и т. п. Так вот, в этом случае удобно каждого
работника описывать не рядом независимых переменных (строкового типа
для фамилии, целого типа для возраста и стажа), а одной переменной
типа Worker, внутри которой и содержатся переменные для фамилии,
возраста и стажа. Здесь самое важное то, что в переменной типа Worker
содержатся другие переменные. Конечно, типа Worker среди встроенных
типов данных нет, но это не беда - мы можем ввести его.
Еще одна важная вещь: в классах помимо переменных разных типов
содержатся функции (или, что то же самое, методы) для работы с этими
переменными. Скажем, в нашем примере с классом Worker логично ввести
специальные функции для записи возраста и стажа. Функции будут,
Классы 85
в частности, проверять правильность вводимой информации. Например,
ясно, что возраст у работника не может быть отрицательным или большим
150. Так вот, наша функция и будет проверять правильность введенного
пользователем возраста.
Давайте рассмотрим первый пример класса. Создайте новое консольное
приложение для С# и введите следующий текст:
using System;
namespace test
{
//Начало класса
class Worker
public int age-0;
public string name;
i
//Конец класса
class Test
i
[STAThread]
static void Main(string[] args)
{
Wcrker wrkl - new Worker();
wrkl.age=34;
wrkl.name="Иванов";
Console .WriteLine (wrkl .name)-" , "-t-wrkl. age) ;
Запустите программу. Она, как и следовало ожидать, выведет на экран
"Иванов, 34".

Давайте кратко обсудим наш код. Во-первых, в строчках
class Worker
{
public int age^-0,-
public string name;
i - - •
мы определили наш класс Worker. Внутри этого класса существуют две
переменные - целая age для возраста и name строкового типа для имени.
Обратите внимание, что, в отличие от C/C++, мы можем задавать некоторое
начальное значение непосредственно сразу после объявления переменной:

public int age=0;
86 Раздел I I . Фундаментальные понятия
Начальное значение задавать вовсе не обязательно - это видно по
переменной name.
Перед переменными мы пишем ключевое слово public. Значение у него
такое же, как и в C++ - это означает, что переменная (или функция)
будет видна вне класса. Если мы не напишем перед переменной никакого
модификатора доступа, или укажем private, то переменная не будет
видна снаружи класса, и ее смогут использовать только функции этого
же класса (т. е. она будет для "внутреннего использования").
Далее в строчке
Worker wrkl = new Worker();
мы заво...

Список страниц

• #
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• ...
• 21
• 22
• 23

Закладка в соц.сетях