c concepts constructor
Този урок обяснява някои от важните концепции в програмирането на C #, като конструктор, деструктори, статичен клас, структури и преброявания:
В един от предишните ни уроци за Обекти и класове научихме какво са клас и обект.
Обектът е подобен на обект от реалния свят, а класът е логическа колекция от подобни видове обекти. Това е един от най-фундаменталните типове в C #. В този урок ще се потопим дълбоко в другите свързани понятия C #.
=> Разгледайте пълната серия за обучение на C # тук
В този урок ще научим за някои важни аспекти на класовете и как можем да ги използваме в нашите програми. Ще се опитаме да създадем прости C # програми въз основа на концепциите, които научихме в предишните ни уроци.
Какво ще научите:
- Какво е конструктор в C #?
- Деструктори в C #
- Статични членове в клас
- Статичен клас в C #
- Структури в C #
- Разлика между структурата и класа
- Структура: Определение
- Преброява в C #
- Свойства в C #
- Заключение
- Препоръчително четене
Какво е конструктор в C #?
Конструкторът е специален тип метод в програмния език C #, който се извиква или извиква автоматично при създаване на обект от дадения клас.
Основната му функция е да инициализира членовете на данните на новосъздадения обект. Една от най-отличителните черти на конструктора е името му. Той има същото име като класа.
Конструкторите са основно два вида:
- По подразбиране
- Параметризирано
C # конструктор по подразбиране
Както подсказва името, конструкторът по подразбиране е основният конструктор на клас. Той няма никакъв аргумент и се извиква директно по време на създаването на обект.
public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } public static void Main(string[] args) { Program p = new Program(); } }
Резултатът от следната програма ще бъде:
Извикан е конструктор
Обяснение
Дефинирали сме конструктор „Програма“ в класа „Програма“. Сега, когато инициализираме класа вътре в основния метод, конструкторът се извиква автоматично.
Следователно, какъвто и да е кодов фрагмент, който сме запазили в конструктора, ще бъде извикан. Тук сме отпечатали съобщение „Конструкторът е извикан“ в рамките на фигурните скоби на конструктора, така че когато инициализираме класа, конструкторът по подразбиране ще се инициализира и съобщението ще бъде отпечатано като изход.
Параметризиран конструктор
Както подсказва името, параметризираните конструктори са конструкторът с параметри. Тези конструктори се използват за предаване на различни стойности на обектите.
public class Details { public Details(int a, int b){ int c = a+b; Console.WriteLine('The sum is: '+ c); } } public class Program { public static void Main(string[] args) { Details d = new Details(2, 3); } }
Резултатът от следната програма ще бъде:
как да стартирам json файл
Сумата е: 5
Обяснение
В предишния ни пример с конструктора по подразбиране имаме основния си метод в същия клас. В този пример имаме основния метод в различен клас.
Имаме един клас, наречен „Подробности“, който съдържа параметризиран конструктор, приемащ две цели числа. Вътре в конструктора отпечатваме сумирането на целите числа. Имаме друг клас, наречен „Програма“, който съдържа основния ни метод. Вътре в основния метод сме инициализирали класа „Подробности“.
Както беше обяснено по-рано, когато даден клас се инициализира, неговите конструктори се извикват автоматично. По този начин в този случай е извикан нашият метод на конструктор „Подробности“ и когато предадем параметъра по време на инициализация, той отпечатва изхода.
Деструктори в C #
Деструкторите са точно обратното на конструкторите. Това е специален метод за класа, който се извиква, когато обект на клас излезе извън обхвата. Подобно на конструктора, името на деструктора също е точно същото като това на името на класа, но с префикс „~“ (тилда).
Деструкторът нито приема параметри, нито връща стойност. Деструкторът унищожава обектите на класа, поради което се използва главно за освобождаване на памет след изпълнението на програмата. Друго важно нещо, което трябва да се отбележи за деструктора, е, че той нито може да бъде претоварен, нито може да бъде наследен.
Пример за деструктори:
public class Program { public Program(){ Console.WriteLine('Constructor has been invoked'); } ~Program(){ Console.WriteLine('Destructor has been invoked'); } public static void Main(string[] args) { Program p = new Program(); } }
Резултатът от следната програма ще бъде:
Извикан е конструктор
Извикан е деструктор
Обяснение
Използвахме същия пример, който използвахме, за да научим конструктор. Току-що добавихме деструктор в програмния клас (~ Program). Когато инициализираме обекта на класа, конструкторът се извиква и обектът на класа се създава. Това отпечатва фразата „Конструкторът е извикан“ в конзолата.
Когато изпълнението е завършено и обектът на класа излезе извън обхвата, програмата се насочва към деструктор. След това се извиква деструкторът, който от своя страна унищожава обекта. Тук отпечатахме съобщение вътре в деструктора, което се отпечатва в конзолата след извикването на деструктора.
Статични членове в клас
Членовете на класа могат да бъдат обявени за статични с помощта на ключовата дума static. Когато обектът е деклариран като статичен, независимо от броя на създадените обекти, ще има само едно копие на статичния обект.
Да бъдеш статичен предполага, че ще има единичен екземпляр на члена, който ще съществува за даден клас. Това означава, че стойността на статичната функция или променливите вътре в класа могат да бъдат извикани, без да се създава обект за тях.
Статичните променливи се използват за деклариране на константи, тъй като техните стойности могат да бъдат получени директно чрез извикване на класа, вместо да се създава екземпляр от него.
Пример:
public class Details { public static void stat(){ Console.WriteLine('Static method invoked'); } } public class Program { public static void Main(string[] args) { Details.stat(); } }
Резултатът от следната програма ще бъде:
Извикан статичен метод
Обяснение
В горния пример създадохме клас „Подробности“, който съдържа статичен метод „stat“. Имаме друг клас „Програма“, който съдържа основния метод. В предишните ни теми видяхме как можем да инициализираме клас за достъп до методи. Но както обсъждахме, статичните членове на класа могат да бъдат достъпни с инициализация на обект на клас.
По този начин в основния метод току-що извикахме метода, използвайки класа директно, без да създаваме никакъв обект. Изходът на програмата изпълнява кода, написан в статичния метод. В този случай сме отпечатали съобщение на конзолата.
Статичен клас в C #
Статичният клас е подобен на нормалния клас в C #. Статичният клас може да има само статични членове и не може да бъде инстанциран. Използва се статичен клас, за да се гарантира, че класът не е инстанциран. Статичният клас се декларира чрез използване на ключовата дума static преди ключовата дума по време на декларацията.
Пример:
public static class Details { public static void multiply(int a, int b){ int c = a*b; Console.WriteLine('Multiplication result is: '+c); } } public class Program { public static void Main(string[] args) { Details.multiply(2,8); } }
Резултатът от следната програма ще бъде:
Резултатът от умножението е: 16
Обяснение
В горния пример създадохме статичен клас „Подробности“, а вътре в статичния клас създадохме друг статичен метод „умножение“. Вътре в метода има някои кодови фрагменти, които искаме да изпълним. Имаме и друг клас „Програма“ с основния метод.
Вътре в основния метод ние извикахме метода multiply, присъстващ в статичния клас. Ако погледнете нашия основен метод, ще видите, че не сме инициализирали или създали обект за статичния клас, вместо това директно сме извикали класа от основния метод.
По този начин, когато директно извикаме метода multiply, използвайки името на класа и чрез предоставяне на параметри, той изпълнява кода и отпечатва изхода.
отваряне на .7z файлове на mac
Структури в C #
Обект от тип стойност в C # се нарича структура. Помага на потребителя да съхранява свързани данни от няколко различни типа данни в една променлива. Както беше посочено, структурата е обект от тип стойност, който съдържа полета, методи, конструктори, оператори, събития и др. Структурата се декларира с помощта на ключовата дума “struct”.
Характеристики на конструкциите:
- Може да включва константи, методи, свойства, индекс, оператори, конструктори и др.
- Не може да има конструктор по подразбиране.
- Той може да реализира интерфейс, но не може да наследява с други структури или класове.
- Структурите трябва да бъдат инициализирани чрез използване на нова ключова дума за използване.
Разлика между структурата и класа
Структурата и Класът може да се чувстват сходни помежду си по някакъв начин, но те имат няколко разлики.
Разликите включват:
- Структурата е тип стойност, докато класът е референтен тип.
- Новата ключова дума е необходима за инициализиране на структури.
- Структурите могат да имат само параметризиран конструктор, а от друга страна, клас може да има както конструктори по подразбиране, така и параметризирани.
Структура: Определение
Структура може да бъде дефинирана с помощта на ключовата дума struct. Структурата може да дефинира нов тип данни с няколко различни члена за програмата.
Структурата може да бъде инициализирана по начин, подобен на този на инициализация на обект, т.е.с помощта на новата ключова дума. Тъй като структурата е обект от тип стойност, тя работи по-бързо от обект на клас. Където и да е необходимо да съхраняваме данни, трябва да използваме структура. От друга страна, ако трябва да прехвърлите данни, препоръчително е да използвате клас, отколкото структура.
Пример:
public struct Cuboid { public int length; public int width; public int height; } public class Program { public static void Main(string[] args) { Cuboid cb = new Cuboid(); cb.length = 10; cb.width = 20; cb.height = 30; Console.WriteLine('The volume of cuboid is: {0}', (cb.length*cb.width*cb.height)); } }
Резултатът от следната програма ще бъде:
Обемът на кубоида е: 6000
Обяснение
В горния пример дефинирахме структурен кубоид, вътре в който съхраняваме типове данни за дължина, ширина и височина на кубоида. Имаме друга програма за клас, където имаме основния си метод.
В основния метод ние инициализираме структурата “Cuboid”, като използваме новата ключова дума. След това използвахме обекта за извикване и присвояване на стойности на типовете данни, съхранявани в структурата. След това извършихме операция върху променливите от структурата и отпечатахме резултата на конзолата.
Така че, ако искате да използвате някакви свойства, събития или методи, структурата трябва да бъде инициализирана с помощта на новата ключова дума, в противен случай ще ви даде грешка при компилация.
Преброява в C #
Enum е набор от целочислени константи и подобно на структура той също е обект от тип стойност. Използва се главно за деклариране на списък с цели числа чрез използване на ключовата дума “enum” в пространство от имена, клас или дори структура. В enum предоставяме име на всяка от целочислените константи, за да можем да ги препращаме, използвайки съответните им имена.
Enum може да има фиксиран брой константи. Помага за подобряване на безопасността и може също да бъде преминат.
Характеристики на Enum
- Enum подобрява четливостта и поддръжката на кода, като предоставя смислени имена на константите.
- Enum не може да се използва с константите от типа низ.
- Enum може да включва константи като int, long, short, byte и т.н.
- По подразбиране стойността на enum константите започва с нула
Деклариране на изброяване
Синтаксисът за деклариране на enum е даден по-долу.
enum { list of integer constants };
Всички enum константи имат стойности по подразбиране. Стойността започва от 0 и се придвижва нагоре един по един.
Пример:
public enum Cuboid{ length, width, height } public class Program { public static void Main(string[] args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }
Резултатът от следната програма ще бъде:
Дължината е: 0
Ширината е: 1
Височината е: 2
Обяснение
Работихме с подобен пример, който научихме по време на struct. В този пример създадохме преброяване на име Cuboid. Това изброяване съдържа три члена, т.е. дължина, ширина и височина.
Имаме друга програма за клас, в която имаме основния си метод. Използван е изричен глас за преобразуване на променливи от тип enum в цяло число, след което сме съхранили техните стойности в различни променливи в основния метод и ги отпечатали в конзолата.
По подразбиране стойността на първото изброяване ще бъде нула, второто ще има 1 и така нататък. Следователно, когато отпечатахме стойностите, получихме гореспоменатия изход.
Промяна на стойността на Enum
Enum също така позволява на потребителите да променят началния индекс по подразбиране на членовете. След като промените началния индекс на променливата, следващите членове ще актуализират своите стойности в нарастваща последователност.
Нека присвоим стойност на първия член на преброяването, който дефинирахме в предишния ни пример, и да видим какво ще се случи:
public enum Cuboid { length = 10, width, height } public class Program { public static void Main(string[] args) { int l = (int)Cuboid.length; int w = (int)Cuboid.width; int h = (int)Cuboid.height; Console.WriteLine('The length is :{0}”, l); Console.WriteLine('The width is :{0}”, w); Console.WriteLine('The height is :{0}”, h); } }
Резултатът от следната програма ще бъде:
Дължината е: 10
Ширината е: 11
Височината е: 12
Обяснение
Когато присвоим на първия член на преброяването стойност, тогава всички следващи членове на преброяването ще бъдат присвоени с нарастването на тази стойност. Както дефинирахме, първата стойност е 10, следващата стойност става 11 и следващата става 12.
Потребителят може да присвои всякаква стойност според своя избор и всички членове на изброяването ще получат автоматично присвояване с увеличаването на дефинираните от потребителя стойности.
Свойства в C #
Свойствата в C # са основно именуваният член на интерфейса, класовете и структурата. Свойствата са разширение на член променливи / метод на struct или class. Те се използват за четене, запис или промяна на стойността на частните полета.
Свойствата се получават точно като полетата. Те имат аксесоари, които могат да се използват за получаване, задаване и изчисляване на стойностите. Също така можем да поставим логика, докато задаваме стойности в свойствата. Може да се използва и с частния клас, който ограничава достъпа отвън, но в същото време позволява на потребителя да използва свойства за получаване или задаване на стойности.
Какво представляват Accessors?
Аксесоари на собственост съставляват изявленията, които могат да се използват за четене, запис или изчисляване на дадено свойство. Декларацията за собственост може да съдържа get, set или и двете.
Пример:
public class Cube { private int side; //Declare a Side property of type integer public int Side{ get{ return side; } set{ side = value; } } } public class Program { public static void Main(string[] args) { Cube cb = new Cube(); cb.Side = 5; Console.WriteLine('The volume of cube is :{0}', (cb.Side * cb.Side* cb.Side)); } }
Когато горният кодов фрагмент е успешно компилиран и изпълнен, се наблюдава следният изход.
Обемът на куба е: 125
Обяснение
В горния пример имаме клас „Cube“, вътре в който сме декларирали свойство „Side“ от тип integer. След това имаме get и set свойство, където сме се върнали и сме предоставили стойността на променливата страна.
jaj на алгоритъма на dijkstra, използваща приоритетна опашка
Имаме друг клас „Програма“ с основния метод, в който инициализираме класа Cube и предоставихме стойността за свойството Side, след което отпечатахме изчисления резултат на конзолата.
Заключение
В този урок научихме за членовите функции на класа. Функция член може да работи с всеки обект от класа, където тя присъства. Научихме и за конструктори и деструктори.
Конструкторите се инициализират автоматично по време на създаването на обект на клас, докато деструкторите разрушават класа и се използват главно за премахване на разпределението на паметта след завършване на изпълнението. Конструкторите могат да бъдат от два типа, т.е.по подразбиране и параметризирани.
Деструкторът не приема никакъв параметър, нито връща никаква стойност. И конструкторите, и конструкторите имат имена, които са абсолютно еднакви с името на класа. Също така научихме за статичните променливи и статичния клас и как те могат да бъдат достъпни без да се използват екземпляри на клас. Разбрахме, че статичният клас може да има само статични членове.
Също така обсъдихме структури или структури. Структурите са обекти от стойност на стойност и трябва да бъдат инициализирани за достъп.
Бяха обсъдени също така Enum и свойствата на C #. Enum е набор от именувани целочислени константи. Подобно на структурата, той също е обект от тип стойност. Преброяването ще има своите членове и всеки член ще има собствена стойност по подразбиране.
В края обсъдихме свойствата, които са продължение на променливите / метода на член на struct или class. Те се използват за получаване, задаване или промяна на стойността на частните полета.
=> Вижте нашата пълна серия за обучение C # тук
Препоръчително четене
- Статично в C ++
- Наследяване в C ++
- Класове и обекти в C ++
- Използване на Selenium Select Class за работа с падащи елементи на уеб страница - Урок № 13 за Selenium
- Полиморфизъм по време на изпълнение в C ++
- Приятелски функции в C ++
- Подигравка на частни, статични и невалидни методи с помощта на Mockito
- C # класове и обекти: задълбочен урок с примери