ООП. Заголовочные файлы, указатели, перегрузка операций и т д. Кроссплатформенность языка

• Название: Заголовочные файлы, указатели, перегрузка операций и т д. Кроссплатформенность языка
• Дата: 19.03.2021
• Размер: 60.07 Kb.
• Имя файла: ООП.docx
• Тип: Документы; #186450
• страница: 1 из 4

Характерные особенности языка Java

1. Синтаксис языка Java похож на синтаксис языка C++, однако он существенно упрощен, в частности отсутствуют заголовочные файлы, указатели, перегрузка операций и т.д.

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

3. Интерпретатор. Покомандно конвертирует и исполняет машинный эквивалент.

4. Совместимость версий языка. Все встроенные типы имеют одинаковый размер и набор операций, вне зависимости от реализации.

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

6. Большое количество различных библиотек, позволяющих облегчить жизнь программиста, за счёт использования определённых в них классов и методов.

7. Компилятор Java позволяет выявить такие ошибки, которые в других языках выявляются во время выполнения программы.

8. Наличие сборщика мусора. Автоматически отыскивает неиспользуемые блоки памяти и возвращает их в пул свободной памяти.

Основные конструкции языка

Типы данных

В Java существует 8 примитивных типов данных.

а) Для целых типов:

int (4 байт)

short (2 байта)

long (8 байт)

byte (1 байт)

б) Для типов с плавающей точкой:

float (4 байта)

double (2 байта)

в) Также есть логический тип boolen (Который подразумевает два значения: true или false)

г) Символьный тип

char –UTF-16

д) Для вещественных значений существуют 3 специальные константы:

NaN – «не число»

POSITIVE_INFINITY – «+ бесконечность»

NEGATIVE_INFINITY – «- бесконечность»

Объявление переменных и констант

<тип> <имя>

<тип> <имя>=<значение>

Int a,b;

Double pi=3.14;

Для констант существует ключевое слово final(Которого говорит о том, что от этой константы запрещено наследование)

final <тип> <имя>=<значение>

Константы в Java принято именовать большими буквами

Final double PI=3.14

Существует специальный класс Math, который содержит математические функции и константы, например:

Math.PI

Math.E

Double Math.sin (double x) т.е возвращает тип double

Double Math.sqrt (double x)

Pow (a,a) =x^a

Int x=2;

Int y= (int) Math. Pow (x,2);

Math.round (x)

Все массивы в Java являются динамическими

<тип>[] <имя> - это объявление массива

Int []a;

A=new int [100];

a.length

<имя массива>.length

Int [] [] a = new int [100] [100]

a.length – Это количество строк

a[0].length – это количество столбцов

Можно одновременно объявить и инициализировать:

Int [ ] a = {1;2;3;4;5}

Int [ ] a = new int [10];

For (int i=0; i
A[i]=I;

Комплект математических операций

+, -,*,/,%

x=x+4

x+=4 – это сокращённая запись строки выше

15/2=7

15.0/2=7.5

15%2=1

n++ ++n

n-- --n

int n=6;

int m=6;

int a=2*++n;

int b=2*m++

==, !=, <,> <=, >=

Приведение типов – это явное преобразование типов.

Задается с помощью следующего синтаксиса:

(<новый тип>) <переменная>;

Double x=8.99;

Int y=(int) x;

Таким образом мы явно задаем тип.

Основные операторы

1. 
   <переменные>=<выражение>
   

Главное, чтобы тип выражения совпадал с типом переменной.

2. 
   {
   

“блок»

}

Задает область видимости переменных, соответственно в двух вложенных блоках не может быть переменных с одинаковым именем.

3)Условный оператор

If (условие) on 1;

Else on 2;

If (условие ) оператора double static void main (String [Jargs])

{

Int a, b;

// ввод a, b

Int m;

If(a>=b)

M=a;

Else

m=b;

// вывод m

}

4) Оператор с предусловием

While (условие)

Int n;

Int s=0;

// ввод n;

While (n!=0)

{

S+=n%10;

n/=10;

}

5) Оператор с постусловием

Do

Операторы

While (условие)

Int n;

// ввод n;

Int s=0;

Do

{

S+=n%10;

n/=10;

while (n!=0)

}

6) Оператор с счётчиком

For (<начало инициализации счетчика>; < условие повторения> ; <закон изменения счётчика> )

Операторы;

Int [ ] a = new int [10];

For (int i=0; i
A[i] = I;

7) Оператор Break

8) Оператор Continue – осуществляет принудительный переход к следующей итерации цикла

9) Оператор Switch

Switch (выражение)

{

Case метка 1: оператор 1;

Case метка 2: оператор 2;

……………………………………..

Default : оператор n

}

Каждая альтернатива обязательно должна сопровождаться оператором brake в конце

Ввод/Вывод

Для организации ввода данных используется класс Scanner, который расположен в пакете Java.Util. Пользователю необходимо создать объект класса Scanner и связать его со стандартным входным потоком System.in

В классе Scanner, есть следующие основные методы для чтения данных:

1. 
   NextInt ( ) – позволяет прочитать целое число
   
2. 
   NextDouble ( ) – позволяет прочитать число с плавающей точкой
   
3. 
   NextLine ( ) – позволяет прочитать строку
   
4. 
   Next ( ) – позволяет прочитать слово до пробела
   

Для организации вывода на монитор необходимо пользоваться стандартным потоком System.out и определёнными на нём методами print ( ) и println ( )

Пример:

Import java.util*;

Class test

{

Public static void main (String [ ] arg)

{

Scanner sc == new Scanner (System.in)

System.out.println ( «Введите два числа»);

Int a = sc.nextInt ( );

Int b = sc.nextInt ( );

System.out.println (« А + В = » (a+b));

}

Строки в Java не являются примитивным типом, они относятся к классовому типу String.

В классе String есть 11 различных конструкторов.

Самый простой способ создания экземпляра String выглядит следующим образом:

String S = “ Hello, world “;

String s = new String ( «строка»)

Char [ ] c = { ‘a’, ‘b’, ‘c’, ‘d’};

String st = new String (c);

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

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

Boolean equals (string s)

String s == “Hello”;

System.out.println(s.equals(“Hello”); //Выдаст False

Для сравнения:

Boolean equals ignore Case (String s)

Int cimpate to (string s), который возвращает 0 если строки равны

1 – если первая строка больше второй

-1 – если первая строка меньше второй

Int compare to Ignore Case (String s) – это с учетом регистра

Int length( );

Int n=s.length ( ); - это (и строчка выше) без учета регистра

Метод char At возвращает символ, который находится в нужной позиции.

Метод String substr (int beg) возвращает подстроку с заданной позицией

String substring (int beg, int end)

Index of( char c) – возвращает позицию первого вхождения

Классы.

Класс является шаблоном, в котором объявляются поля и методы, с помощью которых эти поля обрабатываются, все элементы заключаются между фигурными скобками и таким образом обеспечивается первое базовое свойство ООП, которое называется инкапсуляция

Инкапсуляция – это скрытие полей внутри класса.

В процессе выполнения Java – программы по заданным шаблонам строятся конкретные представители различных классов.

Конкретных представителей принято называть экземплярами классов или объектами.

Общая структура задания класса выглядит следующим образом:

[ <модификатор доступа>] class <Имя класса>

{

[ <модификатор доступа>] <тип> <Имя переменной 1>;

…………………………………………………………………………………………….

[ <модификатор доступа>] <тип> <Имя переменной n>;

[ <модификатор доступа>] <тип> <Имя метода 1> (<список формальных параметров>)

{

Тело

}

[ <модификатор доступа>] <тип> <Имя метода m > (<список формальных параметров>)

{

Тело

}

}

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

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

В Java предусмотрено 4 модификатора доступа:

1. 
   Public – доступ для всех
   
2. 
   Default – доступ по умолчанию, который выставляется, если мы ничего не написали
   

(т.е пакетный доступ – элемент доступен только внутри пакета)

3) Protected – доступ по иерархии наследования

4) Private – доступ к элементам внутри класса.

Для создания конкретных представителей классов, необходим специальный метод, который называется Конструктором.

Его основное назначение состоит в инициализации полей объекта после его создания. У конструктора нет типа результата, его имя всегда совпадает с именем класса.

Class Point

{

Int x, y;

Point ( int x, int y)

{

This.x=x;

This.y=y;

}

Point ()

{

This (0,0);

}

Double dist (int x, int y)

{

Int dx=this.x-x;

Int dy=this.y-y;

Return Math.sqrt(dx*dx + dy*dy);

}

Double dist (Point p)

{

Return dist (p.get x), (p.get y)

Int get (x) ;

Int get (y);

{

Return x;

{

Return y;

}

}

Ссылка “this” позволяет обратиться к собственным элементам класса.

Public class Test

{

Public static void main (String [ ] args)

{

Scanner sc=new Scanner (System.in);

Int x=sc.nextInt ( );

Int y= sc.nextInt ( );

Point p1=new Point (x,y);

Point p2= new Point ( );

System.out.println(p1.dist(p2));

System.out.println(p1.dist(p3));

В Java все параметры примитивного типа передаются по значению, а все параметры объектного типа передаются по ссылке. В классе можно объявлять методы с одинаковым именем, но разным списком параметров.

Такая техника называется совмещением методов.

Наследование

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

Прямого родителя в Java принято называть суперклассом.

Наследование задается с помощью ключевого слова Extends.

Class <Имя класса> <Имя суперкласса>

В Java в отличии от C++ не было реализовано множественного наследования

Первый пример:

Class Point 3D

{

Int x, y, z;

Point 3D (int x, int y, int z)

{

This.x=x;

This.y=y;

This.z=z;

}

Point 3d ()

{

This(0,0,0)

}

Int get x();

{

Return x;

}

Int get y();

{

Return y;

}

Int get z();

{

Return z;

}

Второй пример:

Class Point 3d extends Point

{

Int z;

Point 3d(int x, int y, int z)

{

Super (x,y);

}

Point 3d()

{

This(0,0,0)

}

Int get z()

{

Return z;

}

}

Код этого класса частично совпадает с кодом класса Point, поэтому в данном случае нужно наследование.

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

Если класс наследник имеет метод с тем же заголовком, но другой реализацией что и суперкласс, то говорят о замещении метода.

Первый пример:

Class Point 3D extends Point

{

Int z;

…………

Double dist (int x, int y)

{

Double dx=(this.x-x)/z;

Double dy=(this.y-y)/z;

Return math.sqrt(x*x + y*y);

};

Double dist (int x, int y, int z)

{

Double dx=this.x-x;

Double dy = this.y-y;

Double dz

Второй пример:

Class Test

{

Public Static void main (String [ ] args)

{

Scanner sc=new Scanner (System.in);

Int x= sc.nextInt( );

Int y= sc.nextInt( );

Int z= sc.nextInt( );

Point 3D p3 = new Point 3D (x, y, z);

Point p = new Point (x,y);

System.out.println(p.dist(0,0))

System.out.println(p3dist(0,0))

System.out.println(p3.dist(0,0,0))

}

}

Первый double – это совмещённый метод, второй double – замещённый метод.

Все три метода вызывают три разные dist

Рассмотрим пример, который показывает как происходит назначение методов в Java

Class A

{

Void met ( )

{

System.out.println(“Inside A”);

}

}

Class B extends A

{

Void met ( )

{

System.out.println(“Inside B”);

}

}

Class test

{

Public static void main (String [ ] args)

{

A*a=new B ( );

A, met( );

}

}

Class B extends A

{

Void met ()

{

System.out.println(“Inside B”);

В данном примере будет вызван метод, определённый в классе B. На этапе сборки Java- машина видит, что переменная a имеет вид A и проверяет наличие метода metв классе A.

Однако во время выполнения программы Java – машина видит, что фактически в переменной a находится экземпляр класса B и соответственно вызывается метод, определённый в классе B met в B.

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

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

Если метод объявлен как final – метод, то не один наследник не может его переопределить.

Использование final– методов обеспечивает выигрыш в скорости выполнения программы, потому что такие методы не могут быть замены. Их вызовы еще на этапе сборки заменены встроенным кодом, т. е в файл блок кода данного метода.

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

Класс также может быть помечен как final, тогда он защищает себя от наследования.

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

Методы без реализации являются абстрактными методами и помечаются ключевым словом abstract.

Класс, содержащий абстрактные методы также должен помечаться как abstract. Поскольку у таких классов отсутствует полная реализация, их представителей нельзя создавать с помощью вызова new.