Статические члены и методы класса

static int Val = 100;

public static int

ValDiv2()
{
return Val/2;
}
}








class SDemo
{
static void Main()
{
Console.WriteLine("Исходное значение переменной" + StaticDemo.Val);

StaticDemo.Val = 8;

Console.WriteLine("Текущее значение переменной StaticDemo.Val равно " + StaticDemo.Val);
Console.WriteLine("StaticDemo.ValDiv2(): " + StaticDemo.ValDiv2());
}
}

статического метода недопустим.
class StaticError
{

public int Denom = 3;

// обычная переменная экземпляра
public static int Val = 1024; // статическая переменная


static int ValDivDenom()
{
return Val/Denom; // не подлежит компиляции!
}
}

метода недопустим.
using System;
 
class AnotherStaticError
{
// Нестатический метод

void NonStaticMeth()
{
Console.WriteLine("В методе NonStaticMeth().");
}
 
static void staticMeth()
{
NonStaticMeth(); // не подлежит компиляции!
}
}

статического метода по ссылке на объект.
class MyClass
{
//

Нестатический метод.
void NonStaticMeth()
{
Console.WriteLine("В методе NonStaticMeth().");
}
 
public static void staticMeth(MyClass ob)
{
ob.NonStaticMeth(); // все верно!
}
}

объектов.
class CountInst
{
static int count = 0;

// Инкременировать подсчет при создании объекта.
public CountInst()
{
count++;
}

// Декременировать подсчет при уничтожении объекта.
~CountInst()
{
count--;
}


public static int GetCount()
{ return count; }
}

class CountDemo
{
static void Main()
{
CountInst ob;

for(int i=0; i < 10; i++) {
ob = new CountInst();
Console.WriteLine("Текущий подсчет: " + CountInst.GetCount());
}
}
}

public int beta;

// Статический конструктор
static

Cons()
{
alpha = 99;
Console.WriteLine("Внутри статического конструктора.");
}

// Конструктор экземпляра
public Cons()
{
beta = 100;
Console.WriteLine("Внутри конструктора экземпляра.");
}
}

class ConsDemo
{
static void Main()
{
Cons ob = new Cons();

Console.WriteLine("Cons.alpha: " + Cons.alpha);

Console.WriteLine("ob.beta: " + ob.beta);
}
}

Console.WriteLine("Без параметров"); }

// Перегрузка метода OvlDemo с

одним целочисленным параметром.
public void OvlDemo(int a)
{ Console.WriteLine("Один параметр: " + a); }

// Перегрузка метода OvlDemo с двумя целочисленными параметрами.
public int OvlDemo(int a, int b)
{
Console.WriteLine("Два параметра: " + a + " " + b);
return a + b; }

// Перегрузка метода OvlDemo с двумя параметрами типа double.
public double OvlDemo(double a, double b)
{
Console.WriteLine("Два параметра типа double: " +a + " "+ b);
return a + b;
} }
class OverloadDemo
{
static void Main()
{
Overload ob = new Overload();
int resI;
double resD;

// Вызвать все варианты метода OvlDemo().
ob.OvlDemo();
Console.WriteLine();

ob.OvlDemo(2);
Console.WriteLine();

resI = ob.OvlDemo(4, 6);
Console.WriteLine("Результат вызова метода ob.OvlDemo(4,6): " + resI);
Console.WriteLine();

resD = ob.OvlDemo(1.1, 2.32);
Console.WriteLine("Результат вызова метода ob.OvlDemo(1.1,2.32): " + resD);
}
}

a);
}
 
public int OvlDemo(int a)
{
Console.WriteLine("Один параметр: " + a);

return a * a;
}

public void MyMeth(int x)
{
Console.WriteLine("В методе

MyMeth(int): " + x);
}

public void MyMeth(double x)
{
Console.WriteLine("В методе MyMeth(double): " + x);
}
}









class TypeConv
{
static void Main()
{
Overload2 ob = new Overload2();

int i = 10;
double d = 10.1;

byte b = 99;
short s = 10;
float f = 11.5F;


ob.MyMeth(i);
ob.MyMeth(d);

ob.MyMeth(b);
ob.MyMeth(s);
ob.MyMeth(f);
}
}

{
Console.WriteLine("В методе MyMeth(int): " + x);
}
 
public void MyMeth(ref int

x)
{
Console.WriteLine("В методе MyMeth(ref int): " + x);
}
ob.MyMeth(i);
ob.MyMeth(ref i);

int x) { //...

массив, содержащий стек
int tos; // индекс

вершины стека

// Сконструировать пустой объект класса Stack по заданному размеру стека.
public Stack(int size)
{
stck = new char[size];
tos = 0;
}
// Сконструировать объект класса Stack из существующего стека.
public Stack(Stack ob) {

stck = new char[ob.stck.Length];
for(int i=0; i < ob.tos; i++)
stck[i] = ob.stck[i];
tos = ob.tos;
}

// Поместить символы в стек.
public void Push(char ch
{ stck[tos] = ch;
tos++; }
//Извлечь символы из стека
public char Pop()
{
tos--;
return stck[tos];
}}






class StackDemo
{
static void Main()
{
Stack stk1 = new Stack(10);
char ch;
int i;

// Поместить ряд символов в стек stk1.
Console.WriteLine("Поместить симвоы A-J в стек stk1.");
for(i=0; i<10; i++)
stk1.Push((char) ('A' + i));

// Создать копию стека stck1.
Stack stk2 = new Stack(stk1);

// Вывести содержимое стека stk1.
Console.Write("Содержимое стека stk1: ");
while( … ) {
ch = stk1.Pop();
Console.Write(ch);
}

Console.WriteLine();

Console.Write("Содержимое стека stk2: ");
while ( …) {
ch = stk2.Pop();
Console.Write(ch);
}
Console.WriteLine("\n");
} }

// ... Тело конструктора, которое может быть пустым.
}

op (тип_параметра операнд)
{
// операции
}
 
// Общая форма перегрузки бинарного оператора
 
public static

возвращаемый_тип operator op (тип_параметра1 операнд1,
тип_параметра2 операнд2)
{
// операции
}

// Координаты точки в трехмерном пространстве

public int x, y, z;
public MyArr(int x, int y, int z)
{ this.x = x; this.y = y; this.z = z; }

// Перегружаем бинарный оператор +
public static MyArr operator +(MyArr obj1, MyArr obj2)
{
MyArr arr = new MyArr();
arr.x = obj1.x + obj2.x;
arr.y = obj1.y + obj2.y;
arr.z = obj1.z + obj2.z;
return arr;
}
// Перегружаем бинарный оператор -
public static MyArr operator -(MyArr obj1, MyArr obj2)
{
MyArr arr = new MyArr();
arr.x = obj1.x - obj2.x;
arr.y = obj1.y - obj2.y;
arr.z = obj1.z - obj2.z;
return arr;
}
}
class Program
{
static void Main(string[] args)
{
MyArr Point1 = new MyArr(1, 12, -4);
MyArr Point2 = new MyArr(0, -3, 18);

MyArr Point3 = Point1 + Point2;
Console.WriteLine("\nPoint1 + Point2 = "
+ Point3.x + " " + Point3.y + " " + Point3.z);
Point3 = Point1 - Point2;
Console.WriteLine("\nPoint1 - Point2 = "
+ Point3.x + " " + Point3.y + " " + Point3.z);
Console.ReadLine();
}}}

int x, y, z;
public MyArr(int x,

int y, int z)
{ this.x = x; this.y = y; this.z = z; }

// Перегружаем унарный оператор -
public static MyArr operator -(MyArr obj1)
{
MyArr arr = new MyArr();
arr.x = -obj1.x; arr.y = -obj1.y; arr.z = -obj1.z;
return arr;
}

// Перегружаем унарный оператор ++
public static MyArr operator ++(MyArr obj1)
{
obj1.x += 1; obj1.y += 1; obj1.z +=1;
return obj1; }

// Перегружаем унарный оператор --
public static MyArr operator --(MyArr obj1)
{
obj1.x -= 1; obj1.y -= 1; obj1.z -= 1;
return obj1; } }
class Program
{
static void Main(string[] args)
{
MyArr Point1 = new MyArr(1, 12, -4);
MyArr Point2 = new MyArr(0, -3, 18);

Point3 = -Point1;
Console.WriteLine("-Point1 = " + Point3.x + " " + Point3.y + " " + Point3.z);

Point2++;
Console.WriteLine("Point2++ = "
+ Point2.x + " " + Point2.y + " " + Point2.z);

Point2--;
Console.WriteLine("Point2-- = "
+ Point2.x + " " + Point2.y + " " + Point2.z);
Console.ReadLine();
}}}

return s + " " + obj1.x + "

" + obj1.y + " " + obj1.z;
}
public static MyArr operator +(MyArr obj1, int i)
{
MyArr arr = new MyArr();
arr.x = obj1.x + i;
arr.y = obj1.y + i;
arr.z = obj1.z + i;
return arr;
}
...
string s = Point2 + "Координаты точки Point2:";
Console.WriteLine(s);

int x, y, z;
public MyArr(int x,

int y, int z)
{ this.x = x; this.y = y; this.z = z; }

// Перегружаем логический оператор ==
public static bool operator ==(MyArr obj1, MyArr obj2)
{
if ((obj1.x == obj2.x) && (obj1.y == obj2.y) && (obj1.z == obj2.z))
return true;
return false;
}
// Теперь обязательно нужно перегрузить логический оператор !=
public static bool operator !=(MyArr obj1, MyArr obj2)
{
if ((obj1.x != obj2.x) || (obj1.y != obj2.y) || (obj1.z != obj2.z))
return true;
return false;
}
}
class Program
{
static void Main(string[] args)
{
MyArr myObject1 = new MyArr
(4, 5, 12);
MyArr myObject2 = new MyArr
(4, 5, 12);
if (myObject1 == myObject2)
Console.WriteLine("Объекты равны");
Console.ReadLine();
}

true(тип_параметра операнд)
{
// Возврат логического значения true или false.
}
 
public static bool

operator false(тип_параметра операнд)
{
// Возврат логического значения true или false.
}

public static bool operator false(MyArr obj)

{
if ((obj.x <= 0) || (obj.y <= 0) || (obj.z <= 0))
return true;
return false;
}
 
// Обязательно перегружаем оператор true
public static bool operator true(MyArr obj)
{
if ((obj.x > 0) && (obj.y > 0) && (obj.z > 0))
return true;
return false;
}
if (myObject1)
Console.WriteLine("Все координаты объекта myObject1 положительны");

&(MyArr obj1, MyArr obj2)
{
if (((obj1.x > 0) && (obj1.y

> 0) &&
(obj1.z > 0))
& ((obj2.x > 0) && (obj2.y > 0) &&
(obj2.z > 0)))
return true;
return false;
}
 
// Перегружаем логический оператор !
public static bool operator !(MyArr obj1)
{
if ((obj1.x > 0) && (obj1.y > 0) &&
(obj1.z > 0))
return false;
return true;
}
 


…
 
MyArr myObject1 = new MyArr(4, 5, 12);
MyArr myObject2 = new MyArr( -2, 1, 10);
 
if (myObject1 & myObject2)
Console.WriteLine("У объектов все координаты положительные");
else
Console.WriteLine("Есть отрицательные или равные нулю координаты");
 
if (!myObject2)
Console.WriteLine("Во втором объекте есть отрицательные координаты");

y, z;
public MyArr(int x, int y,

int z)
{ this.x = x; this.y = y; this.z = z; }
// Перегружаем логический оператор &
public static MyArr operator &(MyArr obj1, MyArr obj2) {
if (((obj1.x > 0) && (obj1.y > 0) && (obj1.z > 0))
& ((obj2.x > 0) && (obj2.y > 0) && (obj2.z > 0)))
return obj1;
return new MyArr(0,0,0);
}
// Перегружаем логический оператор |
public static MyArr operator |(MyArr obj1, MyArr obj2)
{
if (((obj1.x > 0) || (obj1.y > 0) || (obj1.z > 0))
| ((obj2.x > 0) || (obj2.y > 0) || (obj2.z > 0)))
return obj1;
return new MyArr(0, 0, 0);
}
// Перегружаем оператор true
public static bool operator true(MyArr obj)
{
if ((obj.x > 0) || (obj.y > 0) || (obj.z > 0))
return true;
return false;
}
// Перегружаем оператор false
public static bool operator false(MyArr obj)
{
if ((obj.x > 0) && (obj.y > 0) && (obj.z > 0))
return false;
return true;
}
// Вспомогательный метод
public static bool And(MyArr obj1, MyArr obj2)
{
if (obj1 && obj2)
return true;
return false;
}
}


class Program
{
static void Main(string[] args)
{
const string STR = "Координаты объектов";
MyArr obj1 = new MyArr( 4, 5, 12);
MyArr obj2 = new MyArr( 10, 3, 5);
if (MyArr.And(obj1, obj2))
Console.WriteLine(STR + " obj1 и obj2 находятся в допустимых пределах");
else Console.WriteLine(STR + "obj1 или obj2 находятся в НЕдопустимых пределах");
}

static implicit operator целевой_тип(исходный_тип v)
{return значение;}

* op1.у * op1.z;
}
…
 
MyArr a = new MyArr (1, 2,

3);
int i;
i = a; // преобразовать в тип int

return op1.x * op1.y * op1.z;
}
 
…
MyArr a

= new MyArr (1, 2, 3);
int i;
i = (int)a * 2 - (int)b; // явно требуется приведение типов

Name, Family;
public byte Age;

public UserInfo(string Name,
string Family, byte Age)
{
this.Name = Name;
this.Family = Family;
this.Age = Age;
}
// Явное преобразование типа UserInfo к string
public static explicit operator string(UserInfo obj)
{
return "Информация о пользователе: " + obj.Name+" "+obj.Family+"("+obj.Age+" лет)";
}
}


class Program
{
static void Main(string[] args)
{
UserInfo ui1 = new UserInfo
("Alexandr", "Erohin", 26);
string s = (string)ui1;
Console.WriteLine(s);
Console.ReadLine();
}