5 Принципов объектно-ориентированного подхода
1. Все является объектом Все данные и программы хранятся в объектах.
2. Каждый объект создается (есть средства для создания объектов), существует какое-то время, потом уничтожается.
3. Программа есть группа объектов, общающихся друг с другом Кроме того, что объект хранит какие-то данные, он умеет выполнять различные операции над своими данными и возвращать результаты этих операций.
Теоретически эти операции выполняются как реакция на получение некоторого сообщения данным объектом.
Практически это происходит при вызове метода данного объекта.
4. Каждый объект имеет свою память, состоящую из других объектов и/или элементарных данных. Объект хранит некоторые данные.
Эти данные — это другие объекты, входящие в состав данного объекта и/или данные элементарных типов, такие как целое, вещественное, символ, и т.п.
5. Каждый объект имеет свой тип (класс) Т.е. в объектно-ориентированном подходе не рассматривается возможность создания произвольного объекта, состоящего из того, например, что мы укажем в момент его создания.
-Все объекты строго типизированы. Мы должны сначала описать (создать) тип (класс) объекта, указав в этом описании из каких элементов (полей) будут состоять объекты данного типа
-Все объекты одного и того же типа могут получать одни и те же сообщения
-Кроме описания структуры данных, входящих в объекты данного типа, описание типа содержит описание всех сообщений, которые могут получать объекты данного типа (всех методов данного класса).
В описании типа мы должны задать не только перечень и сигнатуру сообщений данного типа, но и алгоритмы их обработки.
Гради Буч дает следующее определение объекта:
Объект - это мыслимая или реальная сущность, обладающая характерным поведением и отличительными характеристиками и являющаяся важной в предметной области
Состояние (state) - совокупный результат поведения объекта: одно из стабильных условий, в которых объект может существовать, охарактеризованных количественно;
-- в любой момент времени состояние объекта включает в себя перечень (обычно статический) свойств объекта и текущие значения (обычно динамические) этих свойств.
Поведение (behavior) - действия и реакции объекта, выраженные в терминах передачи сообщений и изменения состояния; видимая извне и воспроизводимая активность объекта
Уникальность (identity) - свойство объекта; то, что отличает его от других объектов
Класс - это шаблон поведения объектов определенного типа с заданными параметрами, определяющими состояние
--Все экземпляры одного класса (объекты, порожденные от одного класса) имеют один и тот же набор свойств и общее поведение, то есть одинаково реагируют на одинаковые сообщения.
--Каждый класс также может иметь специальные методы, которые автоматически вызываются при создании и уничтожении объектов этого класса:
-конструктор (constructor) - выполняется при создании объектов;
-деструктор (destructor) - выполняется при уничтожении объектов.
Обычно конструктор и деструктор имеют специальный синтаксис, который может отличаться от синтаксиса, используемого для написания обычных методов класса.
Структура класса
//Декларирование класса
public class Point {
//Переменные поля (свойства)
private double x, y;
//Конструктор 1
public Point(){
x=0; y=0;}
//Конструктор2
public Point(double x1, double y1){
x=x1; y=y1;}
//Методы класса
public double getx() {return x;}
public double gety() {return y;}
public void setx(double x1) {x=x1;}
public void setx(double y1) {y=y1;}
public double distance() {
double dist=Math.sqrt(x*x+y*y);
return dist;}
public double distance(Point p){
double dist=Math.sqrt(Math.pow(x-p.getx(), 2)+ Math.pow(y-.gety(),2));
return dist;}
}}
-Как только определен новый класс, программист может создавать сколько угодно объектов этого класса (или, как их еще называют, экземпляров класса)
и манипулировать ими так, как будто они представляют собой элементы решаемой задачи.
-Каждый объект может исполнить только определенный запрос.
Запросы, которые программист может посылать объекту, определяются его интерфейсом, и именно тип определяет интерфейс.
Имя типа –> Figure
Интерфейс -> draw()
erase()
move()
setColor()
getColor()
Инкапсуляция (encapsulation)
Это механизм, который связывает код вместе с обрабатываемыми им данными и сохраняет их в безопасности как от внешнего влияния, так и от которая предохраняет код и данные от произвольного доступа из других кодов, определенных вне этой оболочки.
Доступен только интерфейс объекта, через который осуществляется взаимодействие с ним.
Для доступа к свойствам класса принято задействовать специальные методы этого класса для получения и изменения его свойств.
Наследование (inheritance)
Это отношение между классами, при котором класс использует структуру или поведение другого класса (одиночное наследование), или других (множественное наследование) классов.
--Наследование вводит иерархию "общее/частное", в которой подкласс наследует от одного или нескольких более общих суперклассов.
-- Подклассы обычно дополняют или переопределяют унаследованную структуру и поведение.
--Использование наследования способствует уменьшению количества кода, созданного для описания схожих сущностей, а также способствует написанию более эффективного и гибкого кода.
Полиморфизм (имеющий много форм) – св-во, которое позволяет использовать один интерфейс для общего класса действий. Один интерфейс – много методов.
-Целью полиморфизма, применительно к ООП, является использование одного имени для задания общих для класса действий.
Абстрактный класс и интерфейс
С их помощью можно объявлять классы, реализованные лишь частично, полная реализация осуществляется в потомках – расширениях класса.
Используется, когда некоторое поведение (методы) характерно для большинства или всех объектов данного класса, но некоторые аспекты имеют смысл лишь для ограниченного круга объектов, не составляющих суперкласса, те методы конкретизируются в подклассах.
// Абстрактный класс “Фигура”
abstract public class Shape {
// Цвет фигуры
int Color;
// Начальная точка фигуры
Coordinates StartPoint;
// Нарисовать фигуру
abstract public void Draw(); }
// Конкретный класс "Круг“
class Circle extends Shape {
//Нарисовать круг
public void Draw() {
// Здесь реализуется метод рисования //круга } }
Если унаследовать класс от абстрактного, но оставить нереализованным хотя бы один его абстрактный метод, то унаследованный класс также будет абстрактным.
Чтобы избавиться от "абстрактности", необходимо реализовать код для всех абстрактных методов абстрактного класса-предка.
Java предоставляет программисту еще одно средство, родственное классам, - интерфейсы.
Интерфейс - это набор констант и абстрактных методов, которые не содержат никакого кода.
Каждый класс реализующий интерфейс, должен реализовать все его методы.
Если только часть, то класс объявляется абстрактным.
Интерфейсы дают возможность программисту описывать наборы методов, которые должен реализовать класс.
public interface CustomLook {
public abstract void notifyStartPaint();
public abstract void customPaint (); }
public class NewButton implements CustomLook {
public void notifyStartPaint() {
// Код для перехвата начала рисования }
public void customPaint (); }
{ // Код для рисования кнопки нового // внешнего вида } }
-Интерфейсы предоставляют некоторую разновидность множественного наследования, те класс может реализовать несколько интерфейсов.
-Абстрактный класс может содержать частичную реализацию, защищенные компоненты, статические методы и тд, интерфейс ограничивается открытыми методами и константами
-Интерфейс является выражением чистой концепции проектирования, а класс смесь проектирования и конкретной реализации
Определение классов и методов
Java- программа состоит из объектов различных классов, взаимодействующих друг с другом.
Каждое определение Java-класса должно быть в отдельном файле, например MyClass.java и может быть откомпилировано отдельно- MyClass.class
Затем можно скомпилировать файл, содержащий main-метод, без перекомпиляции класса MyClass.java
Класс—это АТД для создания объекта.
Класс определяет структуру объекта и его методы, образующие функциональный интерфейс.
В процессе выполнения Java-программы система использует определения классов для создания представителей классов.
Представители являются реальными объектами. Термины <представитель>, <экземпляр> и <объект> взаимозаменяемы.
Общая форма определения класса.
class <имя_класса> extends <имя_суперкласса> {
type переменная1_объекта;
type переменная2_объекта;
type переменнаяN_объекта;
type имяметода1(список_параметров){
тело метода; }
type имяметода2(список_параметров) {
тело метода } }
В Java используется также понятие абстрактный класс.
С их помощью можно объявлять классы, реализованные лишь частично, полная реализация осуществляется в потомках – расширениях класса
Используется, когда некоторое поведение (методы) характерно для большинства или всех объектов данного класса, но некоторые аспекты имеют смысл лишь для ограниченного круга объектов, не составляющих суперкласса, те методы конкретизируются в подклассах.
// Абстрактный класс “Фигура”
abstract public class Shape {
// Цвет фигуры
int Color;
// Начальная точка фигуры
Coordinates StartPoint;
// Нарисовать фигуру
abstract public void Draw(); }
// Конкретный класс "Круг“
class Circle extends Shape {
//Нарисовать круг
public void Draw() {
// Здесь реализуется метод рисования //круга } }
Если унаследовать класс от абстрактного, но оставить нереализованным хотя бы один его абстрактный метод, то унаследованный класс также будет абстрактным.
Чтобы избавиться от "абстрактности", необходимо реализовать код для всех абстрактных методов абстрактного класса-предка.
Java предоставляет программисту еще одно средство, родственное классам, - интерфейсы.
Интерфейс - это набор констант и абстрактных методов(свойство класса), которые не содержат никакого кода.
Каждый класс реализующий интерфейс, должен реализовать все его методы.
Если только часть, то класс объявляется абстрактным.
Интерфейсы дают возможность программисту описывать наборы методов, которые должен реализовать класс.
public interface CustomLook {
public abstract void notifyStartPaint();
public abstract void customPaint (); }
public class NewButton implements CustomLook {
public void notifyStartPaint() {
// Код для перехвата начала рисования }
public void customPaint (); }
{ // Код для рисования кнопки нового // внешнего вида } }
--Интерфейсы предоставляют некоторую разновидность множественного наследования, те класс может реализовать несколько интерфейсов.
--Абстрактный класс может содержать частичную реализацию, защищенные компоненты, статические методы и тд, интерфейс ограничивается открытыми методами и константами
--Интерфейс является выражением чистой концепции проектирования, а класс смесь проектирования и конкретной реализации
Модификаторы доступа
Во многих языках существуют права доступа, которые ограничивают возможность использования, например, переменной в классе.
Два крайних вида прав доступа: это public, когда поле доступно из любой точки программы, и private, когда поле может использоваться только внутри того класса, в котором оно объявлено.
-Уровень доступа элемента языка является статическим свойством, задается на уровне кода и всегда проверяется во время компиляции.
-Попытка обратиться к закрытому элементу вызовет ошибку.
В Java модификаторы доступа указываются для:
1.типов (классов и интерфейсов) объявления верхнего уровня;
2.элементов ссылочных типов (полей, методов, внутренних типов);
3.конструкторов классов.
Как следствие например, массив также может быть недоступен в том случае, если недоступен тип, на основе которого он объявлен.
Четыре уровня доступа
1.Public 2.Private 3.Protected 4.если не указан ни один из этих трех типов, то уровень доступа определяется по умолчанию (default) иногда его называют пакетным.
1.Открытый (Public) к членам класса всегда можно обращаться из любого места, в котором доступен сам класс; такие члены наследуются в подклассах
2.Закрытый (Private): доступ к членам класса осуществляется только из самого класса
--Если попытаться обратиться к private-данным или методам, то компилятор Java выдаст сообщение об ошибке компиляции.
--Если ваш класс не будет в дальнейшем наследоваться, то лучше использовать модификатор private, а не protected
3.Защищенный (Protected): к данным членам разрешается доступ из подклассов и из методов, входящих в тот же пакет, т.е. наследникам может потребоваться доступ к некоторым элементам родителя, с которыми не приходится иметь дело внешним классам.
-Модификатор доступа protected позволяет обращаться к данным и методам класса лишь самому классу, классам, хранящимся в этом же пакете, и унаследованным классам
-Обычно такой модификатор применяют для того, чтобы закрыть доступ к данным и методам для тех классов, которые не состоят в "родственных отношениях" с защищаемым классом.
-В Java классы считаются родственными, не только если они унаследованы друг от друга, но и просто хранятся в одном и том же пакете.
package Nums;
class First{
protected int protVar;
protected void protMethod() {
System.out.println("protMeth called!");
}}
package Nums;
class Second {// не наследник First
void protAccessMethod() {
First ap = new First();
ap.protVar = 345;
ap.protMethod(); }}
4.Пакетный:(package access) доступ к членам, объявленным без указания атрибута доступа, осуществляется только из того же пакета, где объявлен и сам этот класс.
Более ограниченный по сравнению с protected
Пакет в Java - это коллекция сгруппированных вместе классов, которой присвоено некоторое имя.
-Все классы пакета размещаются в отдельных файлах, причем имя каждого файла совпадает с именем содержащегося в нем класса.
-Единственная новая деталь, отличающая обычный файл от пакетного, состоит в том , что первая строка каждого файла пакета должна иметь следующий вид:
package Имя_пакета;
например,
package mystuff.utilities;
-Классы пакета хранятся в некотором каталоге, пакету присваивается имя, которое можно использовать затем в программах или классах.
-Любое приложение или определение класса может использовать все классы пакета, поместив соответствующий оператор import в начало файла, содержащего это приложение или это определение класса:
import mystuff.utilities;
-Модификатор protected может быть указан для наследника из другого пакета, а доступ по умолчанию допускает обращения из классов-ненаследников, если они находятся в том же пакете.
модификаторы доступа упорядочиваются следующим образом (от менее открытых – к более открытым):
-
private
-
none (package)
-
protected
-
public
--Пакеты доступны всегда, поэтому у них нет модификаторов доступа (можно сказать, что все они public, то есть любой существующий в системе пакет может использоваться из любой точки программы).
--Типы (классы и интерфейсы) верхнего уровня объявления.
При их объявлении существует всего две возможности: указать модификатор public или не указывать его. Если доступ к типу является public, то это означает, что он доступен из любой точки кода.
Если же он не public, то уровень доступа назначается по умолчанию: тип доступен только внутри того пакета, где он объявлен.
--Массив имеет тот же уровень доступа, что и тип, на основе которого он объявлен ( все примитивные типы являются полностью доступными).
--Элементы и конструкторы объектных типов. Обладают всеми четырьмя возможными значениями уровня доступа. Все элементы интерфейсов являются public.
Описание методов
Методы—это подпрограммы, присоединенные к конкретным определениям классов.
Они описываются внутри определения класса на том же уровне, что и переменные объектов.
При объявлении метода задаются тип возвращаемого им результата и список параметров.
Общая форма объявления метода:
тип имя_метода (список формальных параметров) {
тело метода }
Тип результата, который должен возвращать метод может быть любым, в том числе и типом void—в тех случаях, когда возвращать результат не требуется.
class Point {
int х, у;
void init(int a, int b) {
х = а;
y = b; } }
Заголовок состоит из:
1.модификаторов (доступа в том числе);
2.типа возвращаемого значения или ключевого слова void;
3.имени метода;
4.списка аргументов в круглых скобках (аргументов может не быть);
5.специального throws-выражения.
-Для методов доступен любой из 3 возможных модификаторов доступа.
-Также допускается использование доступа по умолчанию.
-Существует модификатор final, который говорит о том, что такой метод нельзя переопределять в наследниках.
-Можно считать, что все методы final-класса, а также все private-методы любого класса, являются final.
-В отличие от объявления переменной здесь запрещается указывать два имени для одного типа:
// void calc (double x, y); - ошибка!
void calc (double x, double y);
-Для каждого аргумента можно ввести ключевое слово final перед указанием его типа.
-В этом случае такой параметр не может менять своего значения в теле метода (то есть участвовать в операции присвоения в качестве левого операнда).
public void process(int x, final double y) {
x=x*x+Math.sqrt(x);
// y=Math.sin(x); - так писать нельзя,
// т.к. y - final! }
Важным понятием является сигнатура (signature) метода.
Сигнатура определяется именем метода и его аргументами (количеством, типом, порядком следования).
Если для полей запрещается совпадение имен, то для методов в классе запрещено создание двух методов с одинаковыми сигнатурами.
class Point {
void get() {}
void get(int x) {}
void get(int x, double y) {}
void get(double x, int y) {} }
// ошибочное использование
void get() {}
int get() {}
void get(int x) {}
void get(int y) {}
public int get() {}
private int get() {}
-Если текущая реализация метода не выполняет никаких действий, тело все равно должно описываться парой пустых фигурных скобок:
public void empty() {}
-Если в заголовке метода указан тип возвращаемого значения, а не void, то в теле метода обязательно должно встречаться return-выражение.
-При этом компилятор проводит анализ структуры метода, чтобы гарантировать, что при любых операторах ветвления возвращаемое значение будет сгенерировано.
// пример вызовет ошибку компиляции
public int get()
{
if (condition)
{ return 5; } }
// правильный метод
public int get() {
if (condition)
{ return 5; }
else { return 3; } }
Значение, указанное после слова return, должно быть совместимо по типу с объявленным возвращаемым значением
--В методе без возвращаемого значения (указано void) также можно использовать выражение return без каких-либо аргументов.
Его можно указать в любом месте метода и в этой точке выполнение метода будет завершено
public void calculate(int x, int y) {
if (x<=0 || y<=0) {
return;
// некорректные входные
// значения, выход из метода } ...
// основные вычисления }
Вызов метода
Вызов метода — это своего рода "приказ" объекту выполнить конкретное действие (описанное операторами в теле метода), используя конкретные данные, содержащиеся в вызывающем объекте.
Способы вызова метода.
1.Метод, определенный в классе, обычно вызывается с использованием объекта класса.
Такой объект называется вызывающим объектом (calling object).
Point p = new Point();
-
p.init(10,12); // p.x ==10, p.y ==12
-
p.init (x1, y1); // p.x ==x1, p.y ==y1
-
p.init (x1+x2, y2^3);
-При обращении к методу формальные параметры метода заменяются фактическими параметрами, т.е. конкретными данными , после чего выполняется тело метода, определенное в описании метода.
-Фактические параметры могут быть const, переменные, выражения соответствующего типа и комбинации этих параметров
-Фактические параметры должны быть определены, вычислены, должны быть определены на момент вызова метода.
2.В некоторых специальных случаях
(для статических методов)
вместо объекта класса в вызове метода используется имя самого класса:
Ans = Math.max (2,3);
S1 = String.valueOf(567.56);
3.Внутри класса, в котором описан метод, он может вызываться по имени в других методах этого класса.
-Переменные, объявленные внутри метода называются локальными переменными.
-Одноименные переменные, объявленные в различных блоках никак между собой не связаны и в памяти размещаются в различных ячейках.
Значение переменных реализации ограничено объектом класса, а локальных переменных – определением метода.
public class BankAccount {
public void showNewBalance () {
double newAmount = amount + (rate/100.0) *amount;
System.out.println("После начисления
процентов на счету стало $"+ newAmount) ; }
public double amount;// перем. реализации
public double rate; // перем. реализации }
public class LocalVariablesDemoProgram { public static void main(String[] args){
BankAccount myAccount = new BankAccount();
myAccount.amount = 100.00;
myAccount.rate = 5;
double newAmount = 10000.00;//лок. в main
myAccount.showNewBalance();
System.out.println("Моя мечта - иметь
на счету в банке $" + newAmount);}}
-В Java запрещается иметь одноименные переменные внутри одного определения метода.
Переменные, объявленные в блоке, являются локальными по отношению к этому блоку и исчезают, когда выполнение этого блока завершается.
-Блок – составной оператор с описаниями.
Переменную нельзя использовать вне блока, в котором она описана.
-При обращении к методу формальные параметры заменяются на фактические (реальные).
-Если формальные параметры имеют примитивные типы, то при замене формальных параметров на фактические используется механизм вызова по значению (call by value)
Формальный параметр, используемый в определении метода, является локальной переменной, которая инициализируется значением фактического параметра
-Между формальными и фактическими параметрами устанавливается взаимнооднозначное соответствие.
В случае рассогласования по типу осуществляется автоматическое преобразование типов:
Byte->short->int->long->float->double
Example.
public double distance(float x1, float y1,
float x2, float y2) {
float xdiff, ydiff;
xdiff = x1 – x2;
ydiff = y1 – y2;
return Math.sqrt(xdiff^2 + ydiff^2);}
…
int x3, x4, y3,y4;
…
double dist = distance (x3,y3,x4,y4); …
Механизмы замены формальных параметров фактическими
Формальный параметр используется в определении метода в качестве заместителя для значения, котрое будет известно(передано) при вызове метода. Передаваемое значение называется фактическим параметром.
uturePopulation = speciesOfTheMoth.projectedPopulation(10);
10 - аргумент
Основные правила создания хорошо инкапсулированных классов:
1.Перед определением класса разместить комментарий, как программист должен представлять себе данные и методы класса (в терминах предметной области)
2.Все переменные реализации в классе должны объявляться с использованием модификатора private
3.Предусмотреть public-методы аксессора и мутатора для чтения и изменения данных в объекте
4.Предусмотреть другие public-методы, необходимые программисту для обработки данных в классе (методы ввода-вывода, например)
5.Перед заголовком каждого public-метода поместите комментарий, как использовать данный метод
6.Сделать все вспомогательные методы закрытыми