Учебники

C # — Классы

Ноябрь 6, 2018

Когда вы определяете класс, вы определяете план для типа данных. На самом деле это не определяет какие-либо данные, но определяет, что означает имя класса. То есть, из чего состоит объект класса и какие операции могут быть выполнены над этим объектом. Объекты являются экземплярами класса. Методы и переменные, которые составляют класс, называются членами класса.

Определение класса

Определение класса начинается с ключевого слова class, за которым следует имя класса; и тело класса, заключенное в пару фигурных скобок. Ниже приводится общая форма определения класса — 

<access specifier> class  class_name {
   // member variables
   <access specifier> <data type> variable1;
   <access specifier> <data type> variable2;
   ...
   <access specifier> <data type> variableN;
   // member methods
   <access specifier> <return type> method1(parameter_list) {
      // method body
   }
   <access specifier> <return type> method2(parameter_list) {
      // method body
   }
   ...
   <access specifier> <return type> methodN(parameter_list) {
      // method body
   }
}

Примечание —

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

  • Тип данных указывает тип переменной, а возвращаемый тип указывает тип данных, которые возвращает метод, если таковые имеются.

  • Чтобы получить доступ к членам класса, вы используете оператор точки (.).

  • Точечный оператор связывает имя объекта с именем члена.

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

Тип данных указывает тип переменной, а возвращаемый тип указывает тип данных, которые возвращает метод, если таковые имеются.

Чтобы получить доступ к членам класса, вы используете оператор точки (.).

Точечный оператор связывает имя объекта с именем члена.

Следующий пример иллюстрирует концепции, которые обсуждались до сих пор —

Live Demo 

using System;

namespace BoxApplication {
   class Box {
      public double length;   // Length of a box
      public double breadth;  // Breadth of a box
      public double height;   // Height of a box
   }
   class Boxtester {
      static void Main(string[] args) {
         Box Box1 = new Box();   // Declare Box1 of type Box
         Box Box2 = new Box();   // Declare Box2 of type Box
         double volume = 0.0;    // Store the volume of a box here

         // box 1 specification
         Box1.height = 5.0;
         Box1.length = 6.0;
         Box1.breadth = 7.0;

         // box 2 specification
         Box2.height = 10.0;
         Box2.length = 12.0;
         Box2.breadth = 13.0;
           
         // volume of box 1
         volume = Box1.height * Box1.length * Box1.breadth;
         Console.WriteLine("Volume of Box1 : {0}",  volume);

         // volume of box 2
         volume = Box2.height * Box2.length * Box2.breadth;
         Console.WriteLine("Volume of Box2 : {0}", volume);
         Console.ReadKey();
      }
   }
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат — 

Volume of Box1 : 210
Volume of Box2 : 1560

Функции-члены и инкапсуляция

Функция-член класса — это функция, определение которой или ее прототип в определении класса аналогичны любой другой переменной. Он работает с любым объектом класса, членом которого он является, и имеет доступ ко всем членам класса для этого объекта.

Переменные-члены — это атрибуты объекта (с точки зрения разработки), и они остаются закрытыми для реализации инкапсуляции. Эти переменные могут быть доступны только с помощью открытых функций-членов.

Давайте изложим вышеупомянутые концепции, чтобы установить и получить значение различных членов класса в классе —

Live Demo 

using System;

namespace BoxApplication {
   class Box {
      private double length;   // Length of a box
      private double breadth;  // Breadth of a box
      private double height;   // Height of a box
      
      public void setLength( double len ) {
         length = len;
      }
      public void setBreadth( double bre ) {
         breadth = bre;
      }
      public void setHeight( double hei ) {
         height = hei;
      }
      public double getVolume() {
         return length * breadth * height;
      }
   }
   class Boxtester {
      static void Main(string[] args) {
         Box Box1 = new Box();   // Declare Box1 of type Box
         Box Box2 = new Box();
         double volume;
         
         // Declare Box2 of type Box
         // box 1 specification
         Box1.setLength(6.0);
         Box1.setBreadth(7.0);
         Box1.setHeight(5.0);
         
         // box 2 specification
         Box2.setLength(12.0);
         Box2.setBreadth(13.0);
         Box2.setHeight(10.0);
         
         // volume of box 1
         volume = Box1.getVolume();
         Console.WriteLine("Volume of Box1 : {0}" ,volume);
         
         // volume of box 2
         volume = Box2.getVolume();
         Console.WriteLine("Volume of Box2 : {0}", volume);
         
         Console.ReadKey();
      }
   }
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат — 

Volume of Box1 : 210
Volume of Box2 : 1560

Конструкторы C #

Конструктор класса — это специальная функция-член класса, которая выполняется всякий раз, когда мы создаем новые объекты этого класса.

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

Live Demo 

using System;

namespace LineApplication {
   class Line {
      private double length;   // Length of a line
      
      public Line() {
         Console.WriteLine("Object is being created");
      }
      public void setLength( double len ) {
         length = len;
      }
      public double getLength() {
         return length;
      }

      static void Main(string[] args) {
         Line line = new Line();    
         
         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength());
         Console.ReadKey();
      }
   }
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат — 

Object is being created
Length of line : 6

Конструктор по умолчанию не имеет параметров, но если вам нужно, конструктор может иметь параметры. Такие конструкторы называются параметризованными конструкторами . Этот метод помогает вам присвоить начальное значение объекту во время его создания, как показано в следующем примере:

Live Demo 

using System;

namespace LineApplication {
   class Line {
      private double length;   // Length of a line
      
      public Line(double len) {  //Parameterized constructor
         Console.WriteLine("Object is being created, length = {0}", len);
         length = len;
      }
      public void setLength( double len ) {
         length = len;
      }
      public double getLength() {
         return length;
      }
      static void Main(string[] args) {
         Line line = new Line(10.0);
         Console.WriteLine("Length of line : {0}", line.getLength()); 
         
         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength()); 
         Console.ReadKey();
      }
   }
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат — 

Object is being created, length = 10
Length of line : 10
Length of line : 6

C # Деструкторы

Деструктор — это специальная функция-член класса, которая выполняется всякий раз, когда объект его класса выходит из области видимости. Деструктор имеет точно такое же имя, как и у класса с префиксом тильда (~), и он не может ни возвращать значение, ни принимать какие-либо параметры.

Деструктор может быть очень полезен для освобождения ресурсов памяти перед выходом из программы. Деструкторы не могут быть унаследованы или перегружены.

Следующий пример объясняет понятие деструктора —

Live Demo 

using System;

namespace LineApplication {
   class Line {
      private double length;   // Length of a line
      
      public Line() {   // constructor
         Console.WriteLine("Object is being created");
      }
      ~Line() {   //destructor
         Console.WriteLine("Object is being deleted");
      }
      public void setLength( double len ) {
         length = len;
      }
      public double getLength() {
         return length;
      }
      static void Main(string[] args) {
         Line line = new Line();

         // set line length
         line.setLength(6.0);
         Console.WriteLine("Length of line : {0}", line.getLength());           
      }
   }
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат — 

Object is being created
Length of line : 6
Object is being deleted

Статические члены класса C #

Мы можем определить членов класса как статические, используя ключевое слово static . Когда мы объявляем член класса статическим, это означает, что независимо от того, сколько объектов класса создано, существует только одна копия статического члена.

Ключевое слово static подразумевает, что для класса существует только один экземпляр члена. Статические переменные используются для определения констант, потому что их значения могут быть получены путем вызова класса без создания его экземпляра. Статические переменные могут быть инициализированы вне функции-члена или определения класса. Вы также можете инициализировать статические переменные внутри определения класса.

В следующем примере демонстрируется использование статических переменных —

Live Demo 

using System;

namespace StaticVarApplication {
   class StaticVar {
      public static int num;
      
      public void count() {
         num++;
      }
      public int getNum() {
         return num;
      }
   }
   class StaticTester {
      static void Main(string[] args) {
         StaticVar s1 = new StaticVar();
         StaticVar s2 = new StaticVar();
         
         s1.count();
         s1.count();
         s1.count();
         
         s2.count();
         s2.count();
         s2.count();
         
         Console.WriteLine("Variable num for s1: {0}", s1.getNum());
         Console.WriteLine("Variable num for s2: {0}", s2.getNum());
         Console.ReadKey();
      }
   }
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат — 

Variable num for s1: 6
Variable num for s2: 6

Вы также можете объявить функцию- член как статическую . Такие функции могут обращаться только к статическим переменным. Статические функции существуют еще до создания объекта. В следующем примере демонстрируется использование статических функций —

Live Demo 

using System;

namespace StaticVarApplication {
   class StaticVar {
      public static int num;
      
      public void count() {
         num++;
      }
      public static int getNum() {
         return num;
      }
   }
   class StaticTester {
      static void Main(string[] args) {
         StaticVar s = new StaticVar();
         
         s.count();
         s.count();
         s.count();
         
         Console.WriteLine("Variable num: {0}", StaticVar.getNum());
         Console.ReadKey();
      }
   }
}

Когда приведенный выше код компилируется и выполняется, он дает следующий результат —

46
Share: