Какие свойства присутствуют не у всех объектов класса

Почти всё современное программирование построено на принципах ООП, поэтому их должен понимать каждый разработчик. Узнайте основы из этой статьи.

nbsp;4.0 Transitional//EN” “https://www.w3.org/TR/REC-html40/loose.dtd”>

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

Цикл состоит из статей, посвященных различным аспектам ООП:

Что такое классы и объекты.
Особенности работы с объектами.
Модификаторы доступа, инкапсуляция.
Полиморфизм и перегрузка методов.
Наследование и ещё немного полиморфизма.
Абстрактные классы и интерфейсы.
Практикум.

Все примеры в этой серии мы рассмотрим на языке C#. Для наглядности они будут связаны с разработкой игр, потому что в них активно используются объекты.

Перед чтением этой серии статей вам нужно ознакомиться с такими понятиями:

переменные и типы данных;
условные конструкции;
циклы;
коллекции (желательно).

Работа будет происходить в Visual Studio 2019, но вполне подойдет и VS 2017.

В конце каждой статьи будут задания, которые помогут закрепить тему. Выполнив задание, загружайте его на GitHub и пишите в комментариях ссылку на репозиторий — я постараюсь проверить каждое решение и дать обратную связь (но я всего лишь человек).

Выполнять задания не обязательно, но без практики просто невозможно осилить такую сложную тему, как ООП. Если же вам все равно лень выполнять задания, можете просто посмотреть мой вариант решения, который я также буду публиковать в комментариях.

Какие свойства присутствуют не у всех объектов класса

Евгений Кучерявый

Пишет о разработке сайтов, в свободное время создает игры. Мечтает открыть свою студию и выпускать ламповые RPG.

Объектно-ориентированное программирование (сокращенно ООП) — это парадигма разработки программных систем, в которой приложения состоят из объектов.

Объекты — это сущности, у которых есть свойства и поведение. Обычно объекты являются экземплярами какого-нибудь класса. Например, в игре может быть класс Character (персонаж), а его экземплярами будут hero или npc.

Свойства — это данные, которые связаны с конкретным объектом:

здоровье;
очки;
деньги;
сила;
ловкость;
интеллект;
скорость;
координаты.

Поведение объекта определяется с помощью методов — специальных блоков кода, которые можно вызывать из разных частей программы. Например, у того же объекта Character могут быть следующие методы:

идти;
атаковать;
говорить;
подобрать;
выбросить;
использовать.

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

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

Такую парадигму используют многие популярные языки:

C#;
Java;
Python;
JavaScript;
PHP;
Kotlin;
Swift;
Objective-C;
C++.

Плюсы	Минусы
Легко читается. Не нужно выискивать в коде функции и выяснять, за что они отвечают.	Потребляет больше памяти. Объекты потребляют больше оперативной памяти, чем примитивные типы данных.
Быстро пишется. Можно быстро создать сущности, с которыми должна работать программа.	*Снижает производительность.* Многие вещи технически реализованы иначе, поэтому они используют больше ресурсов.
Проще реализовать большой функционал. Так как на написание кода уходит меньше времени, можно гораздо быстрее создать приложение с множеством возможностей.	Сложно начать. Парадигма ООП сложнее функционального программирования, поэтому на старт уходит больше времени.
Меньше повторений. Не нужно писать однотипные функции для разных сущностей

Изучая C#, разработчик в первый же день сталкивается с классами и объектами. Например, вот как выглядит первая программа любого новичка:

using System;

namespace OOPConsole
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(“Hello World!”);
}
}
}

Здесь создается класс Program, у которого есть метод Main () — с него начинается выполнение программы, поэтому его называют точкой входа.

Для вывода текста используется следующий оператор:

Console.WriteLine(“Hello, World!”);

Тут программа обращается к объекту Console и вызывает метод WriteLine (), который выводит переданное значение в консоль.

Также у объекта Console есть разные свойства:

Console.ForegroundColor = ConsoleColor.Red;
Console.BackgroundColor = ConsoleColor.Blue;

Если бы не было объекта, было бы сложно определить, цвет какого фона и какого шрифта будет указываться, потому что их в программе может быть несколько.

Вот что выведет программа:

Чтобы создать класс, откройте в Visual Studio меню Project и выберите пункт Add Class…:

Затем введите его название и нажмите Add:

Программа создаст отдельный файл с таким кодом:

namespace OOPConsole
{
class Character
{
}
}

Разберем его по порядку.

Namespace — это пространство имен, в котором находится класс. Оно необходимо для того, чтобы не возникало конфликтов с именами классов и переменных из подключаемых библиотек. Например, можно создать свой класс Console, и это не будет ошибкой, потому что он будет находиться в другом пространстве имен.

OOPConsole.Console.WriteLine();
System.Console.WriteLine();

Затем в коде следует ключевое слово class, которое говорит о том, что нужно создать класс с определенным именем. В данном случае — Character.

Всё, что находится внутри фигурных скобок, относится к этому классу. Несмотря на то что он пустой, уже можно создать его экземпляр — объект. Это называется объявлением или инстанцированием.

Чтобы объявить объект, нужно перейти к методу Main и использовать следующий код:

Character hero = new Character();

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

Теперь можно добавить поля и свойства для класса. Поле объявляется как обычная переменная:

class Character
{
int health = 100;
int x = 50;
int y = 25;
}

Теперь у объекта есть свои поля, но к ним нельзя обратиться извне, потому что закрыт доступ (подробнее об этом — в статье про инкапсуляцию). Чтобы его открыть, нужно поставить перед каждым полем ключевое слово public. То же слово нужно поставить перед словом class.

public class Character
{
public int health = 100;
public int x = 50;
public int y = 25;
}

Теперь можно вернуться к созданному объекту и обратиться к его полю здоровья:

Console.WriteLine(hero.health);

Вот что будет выведено:

Если доступ к полям открыт, то с ними можно проводить вычисления или просто получать их значение. Если же нужно запретить доступ к определенным полям — используйте свойства.

Это специальные конструкции, которые позволяют обращаться к полям. Чтобы создать свойства, нужно сначала закрыть доступ к полям с помощью уровня доступа private — тогда они будут доступны только изнутри класса:

public class Character
{
private int health = 100;
private int x = 50;
private int y = 25;
}

Теперь нельзя узнать здоровье или координаты объекта или изменить их. Чтобы снова открыть к ним доступ, создайте свойства:

public int Health
{
get
{
return this.health;
}

set
{
this.health = value;
}
}

public int X {
get
{
return this.x;
}
}

Тут указывается уровень доступа public, затем тип свойства и его имя. Имена свойств принято начинать с заглавной буквы, и они должны соответствовать имени поля. Внутри свойства встречаются две конструкции:

get (геттер — позволяет получить значение свойства). В ней возвращается значение, которое идет после ключевого слова return;
set (сеттер — позволяет изменить значение). В ней указывается поле, которое нужно изменить, используя значение value.

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

Такие манипуляции нужны для того, чтобы доступ к полям осуществлялся только так, как это нужно разработчику. Например, можно создать свойство, значение которого будет зависеть от выполнения условия:

public bool IsAlive
{
get
{
return this.health > 0 ? true : false;
}
}

Значение, которое будет возвращено, зависит от здоровья персонажа. Если оно ниже нуля, то будет передано false, а если выше — true.

Вот как это работает в программе:

Console.WriteLine($”Hero’s health: {hero.Health} | Hero is alive: {hero.IsAlive}”);
hero.Health = 0;
Console.WriteLine($”Hero’s health: {hero.Health} | Hero is alive: {hero.IsAlive}”);

Вот что будет выведено на экран:

Теперь можно приступить к работе с поведением объектов. Оно реализуется с помощью методов — специальных блоков кода, которые позволяют избежать повторений в проекте.

Методы являются аналогами функций (возвращают значение) и процедур (не возвращают), но с той разницей, что они являются частью какого-то класса. Например, можно в классе Character создать метод Move (), который будет отвечать за движение персонажа.

public void Move(string direction)
{
switch (direction)
{
case “forward”:
this.x++;
break;
case “backward”:
this.x–;
break;
case “up”:
this.y++;
break;
case “down”:
this.y–;
break;
}
}

Сначала указывается уровень доступа public, затем тип возвращаемого значения (в данном случае используется void, что говорит компилятору о том, что ничего возвращать не нужно). Затем идет название метода и круглые скобки.

Внутри скобок указываются аргументы, которые принимает метод (в данном случае направление движения), — от переданных аргументов зависит результат работы метода.

Вот пример вызова метода:

Character hero = new Character();

string command = string.Empty;

while (command != “exit”)
{
Console.WriteLine($”You are at {hero.Coordinates}. Where to go?”);
command = Console.ReadLine();

hero.Move(command);
}

Пользователь видит свои координаты и вводит направление движения, а персонаж двигается с помощью метода Move (). Всё это повторяется, пока не будет введена команда exit.

Вот как это выглядит:

Если же нужно, чтобы метод что-то возвращал, то указывается его тип и используется оператор return:

public bool Collide(Character ch)
{
if (ch.X == this.x && ch.Y == this.y)
{
return true;
}
else
{
return false;
}
}

Этот метод принимает в качестве аргумента объект класса Character и сравнивает координаты. Если они равны, то метод возвращает значение true, а иначе — false.

Вот как это можно использовать:

Character hero = new Character();

Character npc = new Character();

bool collide = hero.Collide(npc);

if (collide)
{
Console.WriteLine(“Objects are on the same position.”);
}
else
{
Console.WriteLine(“Objects are not on the same position.”);
}

Console.ReadKey();

Приведенная выше программа сравнит координаты двух объектов и выведет результат. Так как объекты создаются с одинаковыми полями, то они будут равны:

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

Вот пример того же класса с конструктором:

public class Character
{
private string name;
private int health;
private int x;
private int y;

public Character(string name, int x, int y)
{
this.name = name;
this.x = x;
this.y = y;
this.health = 100;
Console.WriteLine($”Object {this.name} was created at {this.Coordinates}.”);
}

}

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

Character hero = new Character(“Player”, 50, 20);
Character npc = new Character(“Enemy”, 20, 30);
Console.ReadKey();

Вот что выведет программа:

Создайте консольную игру, в которой игрок сможет управлять персонажем с помощью команд. Возможности, которые должны быть в игре:

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

Это лишь вступление в ООП, и еще многое предстоит изучить, чтобы начать применять его в полную силу. Например, нужно понять, как технически работают классы, как они хранятся в памяти, почему их называют ссылочными типами и так далее.

ООП — сложная, но эффективная парадигма программирования. Ее стоит знать всем, кто хочет создавать программы и найти работу, потому что почти все популярные языки ее поддерживают, а работодатели — требуют.

130 часов — и вы научитесь писать программы на языке, созданном Microsoft. Мы создадим 5 проектов для портфолио, даже если до этого никогда не программировали. После прохождения обучения — гарантированное трудоустройство.

Источник

Независимо от того, какой язык программирования вы собираетесь изучать: PHP, Javascript или др. языки программирования, при изучении объектно-ориентированного подхода к программированию, обязательно нужно разобраться с понятиями класса и объекта.

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

Но, для того, чтобы в нашей программе появился объект, нужно совершить два действия:

1) Его нужно описать. Какие свойства и методы есть у этого объекта.

2) Его нужно создать

Что значит описать объект? Описание объекта – это определение его свойств и методов, которые этот объект может принимать. Т.е. мы начинаем создавать программу и пишем, что у нас будет некий объект (например, Employee или Работник).

У этого объекта будет свойства first_name (имя), last_name (фамилия), age (возраст).

Этот объект при запросе к нему может выдавать его имя (getFirstName()), фамилию getLastName()), возраст (getAge()).

Обратите внимание, что в конце метода ставятся круглые скобки (). Они обозначают то, что это является методом. Остальное является свойствами, характеристиками объекта.

Что же значит создать объект?

Создание объекта – это некий процесс обращения к конкретному экземпляру описанного объекта. После описания объекта он имеет некую абстрактную форму и когда мы обращаемся к какому-то конкретному работнику, к какому-то конкретному экземпляру этого описания: работник 1, работник 2, работник 3. У нас может быть множество работников, которые соответствуют этой схеме.

Когда мы с вами обращаемся к какому-то конкретному экземпляру этой сущности работника, то мы создаем некий объект, т.е. некий экземпляр существующего описания этого объекта.

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

Экземпляры классов = объекты.

Объект – это просто что-то конкретное, а класс – это некое абстрактное понятие, которое просто содержит описательную часть.

Класс – это что-то вроде чертежа объекта, т.е. прежде чем мы создадим какую-то деталь, проектировщик должен сделать ее чертеж. Написать, что у этой детали будут такие-то свойства (высота, ширина, длина). Когда чертеж будет выполнен, мы отдаем его какому-то мастеру, и он уже создает экземпляры из этого класса. Деталей, которые могут быть созданы из этого чертежа огромное количество.

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

И нужно понимать, что

Чертеж НЕ равно деталь

Класс НЕ равно объект

Общий алгоритм работы с объектно-ориентированным подходом в программировании:

Создали класс
Создали экземпляр класса (объект)
Обращаемся к свойствам и методам экземпляра класса.

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

Источник

2. Объекты: свойства и методы.

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

Программные объекты обладают свойствами и могут использовать методы обработки данных.

Классы объектов являются «шаблонами», определяющими наборы свойств,
методов и событий, по которым создаются объекты. Основными классами объектов
являются объекты, реализующие графический интерфейс проектов.

Объект, созданный по «шаблону» класса объектов, является экземпляром класса и наследует весь
набор свойств, методов и событий данного класса. Каждый экземпляр класса
объектов имеет уникальное для данного класса имя.

Основой для создания графического интерфейса проекта является объект «форма» (рис.).

Какие свойства присутствуют не у всех объектов класса На основании класса объектов Form можно создавать экземпляры
объектов «форма», которые получают имена Form1, Form2 и т. д.

Свойства объекта (Properties). Каждый класс объектов обладает определенным набором свойств. Так,
например, класс объектов Form обладает
несколькими десятками различных свойств, которые определяют размеры объекта
«форма», цвет формы, положение на экране монитора и т. д. (табл.).

Таблица. Некоторые свойства
объекта «форма»

Свойство	Значение по умолчанию	Комментарий
Name	Form1	Имя объекта, используется в программном коде для обращения к объекту
Text	Form1	Текст в левом верхнем углу формы
BackColor	Control	Серый цвет фона формы
Font	MS Sans Serif, обычный, 8	Шрифт, его начертание и размер

Различные экземпляры
класса объектов обладают одинаковым набором свойств, однако значения свойств у
них могут отличаться. Первоначальные значения свойств объектов можно установить
с использованием диалогового окна Свойства
(Properties) системы программирования.

Какие свойства присутствуют не у всех объектов класса

Так, для объекта
«форма» Form1 можно установить требуемое
значение любого свойства. Для этого необходимо выбрать свойство из списка и
изменить его значение.

Значения свойств
объектов можно изменять в программном коде. Для присваивания свойству объекта
нового значения в левой части строки программного кода необходимо указать имя
объекта и затем — название свойства, которые в соответствии с правилами
точечной нотации разделяются между собой точкой. В правой части строки необходимо
записать конкретное значение свойства:

Объект.Свойство
= ЗначениеСвойства

Например, новая
надпись «Первый проект» в левом верхнем углу объекта Form1 (значение свойства Text) появится в результате выполнения программного кода:

Form1.Text = “Первый
проект”

Методы объекта (Methods). Объекты могут использовать различные методы обработки
данных. Методы имеют аргументы, которые позволяют задать значения параметров
выполняемых действий.

Для использования
метода в строке программного кода необходимо указать имя объекта и затем метод,
которые в соответствии с правилами точечной нотации разделяются между собой
точкой. В скобках при необходимости записываются аргументы метода, разделяемые
запятыми:

Объект.Метод (apr1,
арг2)

Например, с помощью
метода Scale (х, у) можно изменить
размеры формы или элемента управления. Аргументы метода x и y являются коэффициентами масштабирования по
горизонтали и вертикали, т. е. позволяют увеличить или уменьшить ширину и
высоту элемента управления. Например, можно в два раза увеличить размер объекта
по оси X и в
два раза его уменьшить по оси Y:

Me.Scale(2,0.5)

Если производятся операции над самой формой,
то вместо ее имени (например, Form1) в программном коде используется имя Me.

Источник