0% нашли этот документ полезным (0 голосов)
9 просмотров6 страниц

Java Notes

Загружено:

femehas844
Авторское право
© © All Rights Reserved
Мы серьезно относимся к защите прав на контент. Если вы подозреваете, что это ваш контент, заявите об этом здесь.
Доступные форматы
Скачать в формате TXT, PDF, TXT или читать онлайн в Scribd
0% нашли этот документ полезным (0 голосов)
9 просмотров6 страниц

Java Notes

Загружено:

femehas844
Авторское право
© © All Rights Reserved
Мы серьезно относимся к защите прав на контент. Если вы подозреваете, что это ваш контент, заявите об этом здесь.
Доступные форматы
Скачать в формате TXT, PDF, TXT или читать онлайн в Scribd
Вы находитесь на странице: 1/ 6

Переменные бывают примитивные и ссылочные

Примитивные переменные содержат в себе биты, предсталяющие значение(5, 'o', 'b',


true, 3.1415), а ссылочные переменные содержат в себе биты, описывающие способ
получить объект в куче

Если ссылочная переменная не ссылается ни на какой объект, то она содержит значение


null

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

То, что объект может делать, называется методом

Слово "экземпляр" - синоним слова "объект"

Тип и класс - синонимы //Объект x типа int = объект x класса int

Значения-литералы - то, что присваивается в переменную(после знака "=")

Не существует понятия, как объектная переменная, есть переменная, ссылающаяся на


объект

/*
Dog MyDog - выделение в памяти места для ссылочной переменной MyDog типа Dog

new Dog() - выделение в куче места и создание объекта типа Dog

Dog MyDog = new Dog(); - присваиваем ссылочной переменной MyDog ссылку на объект
Dog()
*/

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

Переменная массива(aboba) - ссылочная переменная такого же типа, как массив(int[]


aboba), которая управляет объектом Array(Массив)

/*
int[] aboba; //Объявляем ссылочную переменную aboba, которая будет ссылаться на
массив типа int

aboba = new int[4]; //Создаём новый массив типа int с 4 элементами и присваиваем
его переменной abooba

nums[0] = 3;
nums[1] = 7;
nums[2] = -5;
nums[3] = 0;

Ссылочная переменная aboba типа целочисленный массив(int[]) содержит ссылку на


объект Array(массив), в котором хранятся переменные типа int
*/

/*
Dog[] pets; //Объявляем ссылочную переменную pets, которая будет ссылаться на
массив типа Dog

pets = new Dog[7]; //Создаём новый массив типа Dog с 7 элементами и присваиваем его
переменной pets(в массиве хранятся не объекты, а ссылки на будущие объекты, самих
объектов ещё нет)

pets[0] = new Dog(); //Теперь в первом элементе массива pets хранится ссылка на
объект типа Dog, у объекта могут быть переменные экземпляра(объекта) и методы
pets[1] = new Dog(); //Тоже самое, но это другой объект типа Dog(их теперь 2) и
ссылка на него хранится в элементе массивы pets номер 2
pets[3] = pets[0]; //Теперь в 4 элементе массива хранится ссылка на объект, ссылка
на который хранится и в первом элементе этого массива(все остальные элементы
массива хранят значение null)
*/

/*
Dog[] dogs = new Dog[4]; //Объявляем ссылочную переменную dogs, которая будет
ссылаться на массив типа Dog, создаём в массив из 4 элементов, которые будут
ссылаться на объекты типа Dog

dogs[1] = new Dog(); //Создаём объект типа Dog и присваиваем ссылку на него во
второй элемент массива dogs
dogs[1].name = "Абоба"; //Изменяем переменную экземпляра на "Абоба"(ссылка на
экземпляр хранится во втором элементе массива, а ссылка на массив хранится в
ссылочной переменной aboba)
dogs[1].bark(); //Вызываем метод bark() у экземпляра, ссылка на который хрнаится во
втором элементе массива
*/

Объекты характеризуются состояние и поведением, которые представлены переменными


экземпляра и методами

Методы используют значения переменных экземпляра

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

Объекты названы классами, их свойства названы полями, а совершаемые действия с ними


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

Метод ИСПОЛЬЗУЕТ ПАРАМЕТРЫ, вызывающий код ПЕРЕДАЁТ АРГУМЕНТЫ

Аргументы - это значения, которые вы передаёте методам. АРГУМЕНТ превращается в


ПАРАМЕТР. В свою очередь, это не что иное, как локальная переменная, то есть
переменная с именем и типом, которая может быть использована внутри метода

/*
void bark(int numOfBarks) { // numOfBarks - параметр
while(numOfBarks > 0) {
System.out.println("Гав!");
numOfBarks = numOfBarks - 1;
}
}
-----------------------------------------------------------------------
Dog psina = new Dog();

psina.bark(3); // Вызывает метод 3 раза(3 - аргумент)


*/

/*
int giveSecret(); {
return 42;
}

int theSecret = life.giveSecret(); // Биты, представляющие значение 42, вернулись


из метода giveSecret() и были присвоены переменной theSecret.
*/

/*
void takeTwo(int x, int y) {
int z = x + y;
System.out.println(z);
}
-----------------------------------------------------------------------
void go() {
int lol = 7;
int bob = 1;
t.takeTwo(lol, bob);
}
*/

Переменные экземпляра нужно помечать как private, а геттеры и сеттеры как public

Переменные экземпляра(поля) объявляются внутри класса, а локальные переменные


внутри метода

/*
Значения по умолчанию у переменных экземпляра:

Целые 0

Дробные 0.0

Булевые false

Ссылки null
*/

Локальные переменные не содержат значений по умолчанию

Используйте ==, чтобы сравнить примитивы или проверить, ссылаются ли переменные на


один и тот же объект

Используйте метод .equals() для проверки идентичности двух разных объектов //


Например, можно проверить два объекта типа String, содержащих одинаковую
последовательность символов

Integer.parseInt("3") // Преобразует строку в int

/*
for(int i, i < 10, i++) { // выполнить что-то 10 раз

}
*/

/*
int[] nums = new int[3];
nums[0] = 7;
nums[1] = 8;
nums[2] = 9;
for(int i = 0; nums[2] < 11; i++) {
if(i == 3) {
System.out.println("----------------------------------");
i = 0;
}
System.out.println(nums[i]);
nums[i]++;
}

System.out.println("----------------------------------");
System.out.println(nums[0]);
System.out.println(nums[1]);
System.out.println(nums[2]);
*/

z = x++ // Сделать переменную z равной переменной x, а потом увеличить на 1


(постинкремент)

z = ++x // Сделать переменную z равной переменной x, но перед этим увеличить x на


1(преинкремент)

z = x-- // Сделать переменную z равной переменной x, а потом уменьшить x на


1(постдекремент)

z = --x //Сделать переменную z равной переменной x, но перед этим уменьшить на


1(предекремент)

/*
int[] numbers;
numbers = new int[6];
numbers[0] = 100;
numbers[1] = 99;
numbers[2] = 98;
for(int i : numbers) { // Каждое выполнение цикла переменаая i будет равняться
последующему элементу массива(цикл будет выполняться, пока не переберёт все
элементы)
if(i == 98) {
System.out.println("Да");
} else {
System.out.println("Нет");
}
}
*/

/*
void go() {
super.go(); // С помощью ключевого слова super можно сначала вызвать метод
родительского класса, а потом дополнить его, при этом переопределив(void go())
//Дополнение
}
*/

Члены класса - это переменные экземпляра и методы, которые были созданы в


классе(если класс дочерний, то всё, что было унаследовано от класса-родителя это
тоже члены класса(дочернего))

/*
Animal[] animals = new Animal[3]; // Теперь в массив типа Animal можно присвоить
любой объект типа Animal или объект, который наследуется от Animal
animals[0] = new Dog();
animals[1] = new Cat();
animals[2] = new Wolf();
for (int i = 0; i < animals.length; i++) {
animals[i].eat();
animals[i].roam();
}
*/

/*
class Vet {
public void giveShot(Animal animal) { // Метод принимает объект любого типа,
который наследуется от типа Animal
a.makeNoise(); // Объект, который мы передали, выполняет метод
makeNoise();
}
}
---------------------------------------------------
class PetOwner {
public void start() {
Vet v = new Vet(); // Создаём объект типа Vet
Dog d = new Dog(); // Создаём объект Dog
Cat c = new Cat(); // Создаём объект Cat
v.giveShot(d); //Теперь метод giveShot(который выполняет другой метод
(makeNoise())) может выполнятся у любого животного, которое наследуется от класса
Animal
v.giveShot(c);
}
}
*/

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

Если пометить класс как final, то его нельзя будет наследовать(а значит, что ни
один из методов не будет переопределён)

Если пометить метод как final, то его нельзя будет переопределить

Аргументы и возвращаемые значения переопределяемых методов внешне должны выглядеть


точно так же, как и в оригинальном методе родительского класса(При переопределении
метода в дочернем классе, он должен принимать такие же аргументы, как в
родительском классе и возвращать значение такого же типа(или дочернего))

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

/*
public class Appliance {
public boolean turnOn() {
// Код
}

public boolean turnOff() {


// Код
}
}
-----------------------------------------------
public class Toaster extends Appliance { //Если метод turnOn() вызвать без
параметров, то выполнится версия из Appliance, а если вызвать его с
параметром(turnOn(7)), то выполнится версия из Toaster
public boolean turnOn(int level) { //Это не переопределение, а перегрузка
// Код
}
}
*/

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


значения

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

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

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

Абстрактный метод должен нахолится внутри абстрактного класса(public abstract void


eat(); - абстрактный метод, т.к. в нём нету кода и он помечен словом abstract)

В абстрактном классе можно совмещать как абстрактные методы, так и конкретные

Вам также может понравиться