Открыть Электронные книги
Категории
Открыть Аудиокниги
Категории
Открыть Журналы
Категории
Открыть Документы
Категории
на Java
2019
Java – это высокоуровневый ОО язык программирования. В
основе концепции объектно-ориентированного
программирования лежит понятие объекта — некой сущности,
которая объединяет в себе поля (данные) и методы
(выполняемые объектом действия).
В современных объектно-ориентированных языках
используются три основных механизма:
1. Наследование - создание нового класса объектов путём
добавления новых элементов (методов). процесс перенимания
классом свойств (методов и полей) другого класса. С
использованием в Java наследования информация становится
управляемой в иерархическом порядке.
Класс, который наследует свойства другого класса, называется
подклассом (производным классом, наследующим классом), а
класс, свойства которого наследуются, известен как суперкласс
(базовый класс, родительский класс).
2. Инкапсуляция. Сокрытие детали реализации, которое
позволяет вносить изменения в части программы
безболезненно для других её частей, что существенно
упрощает сопровождение и модификацию ПО. Инкапсуляция
означает, что данные объекта недоступны его клиентам
непосредственно. Вместо этого они инкапсулируются —
скрываются от прямого доступа извне. Инкапсуляция
предохраняет данные объекта от нежелательного доступа,
позволяя объекту самому управлять доступом к своим данным.
3. Полиморфизм. При полиморфизме некоторые части (методы)
родительского класса заменяются новыми, реализующими
специфические для данного потомка действия. Таким образом,
интерфейс классов остаётся прежним, а реализация методов с
одинаковым названием и набором параметров различается.
Наиболее популярные языки программирования: С#, C++, Java, Delphi, VB.NET, Perl,
Python, JavaScript, Jscript.NET, Ruby, Ada, PHP.
Выполнение Java программ
Все типы данных в Java делятся на две группы – примитивные типы и ссылочные
типы.
Ссылочные типы включают в себя массивы, классы, интерфейсы и перечислимый
тип.
Примитивных типов всего восемь – логический тип и семь числовых типов.
Числовые типы делятся на целые типы и вещественные типы.
Целых типов пять: byte, short, int, long, char.
Символы можно применять везде, где используется тип int, поэтому Java
причисляет char к целым типам.
2+'ж' – к двойке прибавляется кодировка буквы ж в Юникоде = \u0416=1046
2+1046=1048
2+”ж” – так как ж записана как строка, то произойдет склейка строк и получим 2ж.
(байт)
byte 1 От -128 до 127
short 2 От -32768 до 32767
if (x<y) then {
x=10; /* при необходимости можно использовать несколько операторов, но только в блоке фигурных
скобок! */
}
Условный оператор
if (x>1) {
y=100
} else if (x<10) {
y=10:
} else {
y=1;
}
Условный оператор
Возникает вопрос – к какому именно оператору if относится ветвь else? Для языка
Java, как и для большинства языков, ветвь else относится к ближайшему слева
условию if, не имеющему своей ветви else. Изменить этот порядок можно с
помощью блока.
а если
while (x>0)
{
y+=2;
}
Операторы цикла
do
{if (x>0) x-=1;}
while (x>0);
Операторы цикла
Оператор for;
Оператор continue;
Оператор break;
Бесконечный цикл
while (true)
{
if (x==2) {continue;}
if (x!=2) {x++;}
if(x==3) {break;}
}
Оператор варианта
switch (логическое_выражение) {
case коснтвыр1: оператор1;
case коснтвыр2: оператор2;
case коснтвыр3: оператор3;
….
case коснтвырN: операторN;
default: операторDef;
Оператор варианта
double[] a, b;
квадратные скобки можно и переставлять сразу после имени, если это нужно:
int i=0, ar[], k=-1;
Массивы
Свойства и классификация
• Устойчивость (англ. stability) — устойчивая сортировка не меняет взаимного
расположения элементов с одинаковыми ключами.
• Естественность поведения — эффективность метода при обработке уже
упорядоченных или частично упорядоченных данных. Алгоритм ведёт себя
естественно, если учитывает эту характеристику входной последовательности и
работает лучше.
• Использование операции сравнения. Алгоритмы, использующие для сортировки
сравнение элементов между собой, называются основанными на сравнениях. Для
специальных случаев (типов данных) существуют более эффективные алгоритмы.
Сортировка массивов
Абстракция
При описании какого-либо объекта, например автомобиля, мы создаём
его модель. Модель не описывает объект полностью – реальные
объекты слишком сложны. Для решения поставленной задачи
отбираются только те характеристики, которые важны для решения
задачи.
class Smartphone {
int capacity; //ёмкость батареи
int screensize;
int onboardMemory;
// и т.д.
void disCharge(int cpuload, boolean screenon) {
int a=0;// cpuload, screenon и a – это локальные переменные, а не поля.
//тело метода – описывается метод вычисления скорости разряда
}
Общие принципы объектно-ориентированного программирования
Motorola.age=5;
int p=LG. charging (2000,2,10);
package nasled1;
System.out.print("Test1");
//Mobile NewDevice = new Mobile();
//Smartphone Samsung = new Smartphone();
SamsungModel S10 = new SamsungModel();
S10.operMemory = 6;
System.out.println(S10.onBoardMemory(128));
System.out.println("RAM on S10 is " + S10.operMemory);
}
}
Модульность
Описание класса начинается со слова class, после которого с заглавной буквы идет
имя класса.
Перед словом класс можно записать модификаторы класса. Например: public,
abstract, final. Перед именем вложенного класса можно использовать также
модификаторы protected, private, static.
Тело класса, в котором в любом порядке перечисляются поля, методы,
конструкторы, вложенные классы и интерфейсы, заключается в фигурные скобки.
При описании поля указывается его тип, затем, через пробел, имя и может быть
начальное значение после знака равенства, которое допустимо записать
константным выражением.
Как описать класс и подкласс?
public – модификатор доступа. У класса обозначает, что любой класс имеет полный
доступ к членам открытого класса.
abstract – обозначает, что класс является абстрактным – у абстрактного класса
нельзя создать экземпляр класса, а реализовывать этот класс можно только лишь в
классах-потомках. У абстрактного класса не обязательно должны быть абстрактные
методы, но если таковые имеются у какого-либо класса, значит класс обязан быть
абстрактным.
final – обозначает что данный класс нельзя наследовать.
Как описать класс и подкласс?
Поля класса
final - не может поменять своего значения после инициализации. Это касается и
статических, и нестатических полей (member fields).
transient – обозначает, что во время сериализации это поле будет проигнорировано.
volatile - в Java потоки могут хранить значения некоторых переменных в некотором
своем локальном контексте. Если один поток изменит значение такого поля, то
другой поток может об этом не узнать (так как хранит копию). Для полей с
модификатором volatile есть гарантия, что все потоки всегда будут видеть
актуальное значение такой переменной.
При описании метода указывается тип возвращаемого им значения или
слово void, затем, через пробел, имя метода, потом, в скобках, список
параметров. После этого, в фигурных скобках расписывается
выполняемый метод.
Описание метода может начинаться с модификаторов public, protected,
private, abstract, static, final, synchronized, native, strictfp.
В списке параметров через запятую перечисляются тип и имя каждого
параметра. Перед типом какого-либо параметра может стоять
модификатор final. Такой параметр нельзя изменять внутри метода.
Список параметров может отсутствовать, но скобки сохраняются.
abstract - может быть объявлен как метод-член (member method) в
пределах абстрактного класса (или интерфейса). В этом случае тело
метода отсутствует, а реализация может быть предоставлена в классах-
наследниках.
Метод, объявленный с модификатором final не может быть
переопределен в наследниках.
Метод с модификатором static относится к классу в целом, а не к его
экземплярам, то есть в него не передается объект this. Такой метод
может быть вызван используя имя класса.
Модификатор native перед объявлением метода указывает, что он
является специфическим для операционной системы. Как и у
абстрактного метода, у него тоже нет тела, а реализация находится в
скомпилированном виде в файлах JVM.
Модификатор synchronized у метода говорит о том, что перед его
выполнением должен быть захвачен монитор объекта (для
нестатического метода), либо монитор, связанный с классом (для
статического метода)
Передача аргументов в метод
class Dummy1{
private static void f(int a){
a=5;
}
}
public static void main (String [] args){
int x=7;
System.out.println(“До: “ + x);
f(x);
System.out.println(“После: “ + x);
}
class Dummy2{
private static void f (int[] a){
a[0]=5;
}
public static void main(String() args){
int[] x = {7};
System.out.println (“До: “ + x[0]);
f(x);
System.out.println (“После: “ + x[0]);
}
Передача аргументов в метод
Thought t1 = null;
t1 = new Thought();
t1.message(); // Выводит "Я себя чувствую как стрекоза, попавшая в параллельную вселенную."
В данном случае явно класса предка не указано, а по умолчанию все классы Java
наследуют класс Object поэтому вызывается конструктор класса Object. Если в
классе определен конструктор с параметрами, а перегруженного конструктора без
параметров нет, то вызов конструктора без параметров является ошибкой. Тем не
менее, в Java, начиная с версии 1.5, можно использовать конструкторы с
аргументами переменной длины. И если есть конструктор, имеющий аргумент
переменной длины, то вызов конструктора по умолчанию ошибкой не будет. Не
будет потому, что аргумент переменной длины может быть пустым.
Создание объекта и конструкторы
При создании объекта последовательно выполняются следующие действия:
• Ищется класс объекта среди уже используемых в программе классов. Если его
нет, то он ищется во всех доступных программе каталогах и библиотеках. После
обнаружения класса в каталоге или библиотеке выполняется создание, и
инициализация статических полей класса. Т.е. для каждого класса статические поля
инициализируются только один раз.
• Выделяется память под объект.
• Выполняется инициализация полей класса.
• Отрабатывает конструктор класса.
• Формируется ссылка на созданный и инициализированный объект. Эта ссылка и
является значением выражения, создающего объект. Объект может быть создан и с
помощью вызова метода newInstance() класса java.lang.Class. В этом случае
используется конструктор без списка параметров.
Перегрузка конструкторов
Class Mobile{
Private static int number;
Mobile(){
number++;
System.out.println(“Show mobile imei ” + number);
}
Вложенные классы в Java используются, как правило, только в самом простом виде,
главным образом для обработки событий, возникающих при действиях с мышью и
клавиатурой.
Вложение класса удобно тем, что методы внешнего класса могут напрямую
обращаться к полям и методам вложенного класса. Но ведь того же самого можно
было бы добиться по-другому – при помощи наследования.
Отношения «быть частью» и «являться»
Внутренние классы
Каждый пакет создает одно пространство имен. Это означает, что все
имена классов, интерфейсов и подпакетов в пакете должны быть
уникальны. Имена в разных пакетах могут совпадать, но это будут
разные программные единицы. Таким образом, ни один класс,
интерфейс или подпакет не может оказаться сразу в двух пакетах. Если
надо в одном месте программы использовать два класса с одинаковом
именами из разных пакетов, то имя класса уточняется именем пакета –
пакет.класс. Такое уточненное имя называется полным именем класса.
Пакеты, интерфейсы, перечисления
private +
“packadge” + +
protected + + *
public + + + +
Импорт классов и пакетов
или
interface Auto{ . . .}
interface Car extends Auto { . . . }
class Truck implements Auto{ . . .}
class Pickup implements Truck, Car { . . . }
При этом в классе Pickup невозможно реализовать метод f(), описанный и в интерфейсе
Car, и в интерфейсе Truck с одинаковой сигнатурой.
Интерфейсы позволяют реализовывать средствами Java чистое объектно-
ориентированное проектирование, не отвлекаясь на вопросы реализации проекта.
Приступая к разработке проекта можно записать его в виде иерархии интерфейсов, не
думая о реализации, а затем построить по этому проекту иерархию классов, учитывая
ограничения одиночного наследования и видимости членов классов.
Возможно создавать ссылки на интерфейсы. Конечно, указывать такая ссылка может
только на какую-нибудь реализацию интерфейса. Тем самым мы получаем еще один
способ организации полиморфизма.
Интерфейсы
При этом в классе Pickup невозможно реализовать метод f(), описанный и в интерфейсе
Car, и в интерфейсе Truck с одинаковой сигнатурой.
Интерфейсы позволяют реализовывать средствами Java чистое объектно-
ориентированное проектирование, не отвлекаясь на вопросы реализации проекта.
Приступая к разработке проекта можно записать его в виде иерархии интерфейсов, не
думая о реализации, а затем построить по этому проекту иерархию классов, учитывая
ограничения одиночного наследования и видимости членов классов.
Возможно создавать ссылки на интерфейсы. Конечно, указывать такая ссылка может
только на какую-нибудь реализацию интерфейса. Тем самым мы получаем еще один
способ организации полиморфизма.
Интерфейсы
В JAVA все что можно представлено объектами. Восемь примитивных типов нарушают
это правило. Арифметические действия удобнее и быстрее производить с обычными
числами, а не с объектами классов, которые требуют много ресурсов.
Character.Subset InputSubset
Character.UnicodeBlock
Числовые классы
Автоматическая распаковка:
int n = k1; //компилятор извлечет из объекта k1 числовое значение 55 методом
intValue().
Абстрактный пример:
public NastTipy<Stype, Ttype> makeClass (Stype id, NastTipy2<Ttype> data){
return new NastTipy(id, data.getData());
}
Шаблоны типа (wildcard type)
Способ 1
Создать объект класса Thread, передав ему в конструкторе нечто, реализующее
интерфейс Runnable. Этот интерфейс содержит метод run(), который будет выполняться
в новом потоке. Поток закончит выполнение, когда завершится его метод run().
Способ 2
Создать потомка класса Thread и переопределить его метод run():
Как правило, более распространенной ситуацией является случай, когда Main thread
завершается самым последним. Для этого надо применить метод join()
имя_потока.join().
Как правило, более распространенной ситуацией является случай, когда Main thread
завершается самым последним. Для этого надо применить метод join()
имя_потока.join().
public static void main(String[] args) {
System.out.println("Main thread started...");
JThread t= new JThread("JThread ");
t.start();
try{
t.join();}
catch(InterruptedException e){
System.out.printf("%s has been interrupted", t.getName());}
System.out.println("Main thread finished...");}
Метод join() заставляет вызвавший поток (в данном случае Main thread) ожидать
завершения вызываемого потока, для которого и применяется метод join (в данном
случае JThread).
Завершение процесса и демоны
В Java процесс завершается тогда, когда завершается последний его поток. Даже если
метод main() уже завершился, но еще выполняются порожденные им потоки, система
будет ждать их завершения.
Однако это правило не относится к особому виду потоков – демонам. Если завершился
последний обычный поток процесса, и остались только потоки-демоны, то они будут
принудительно завершены и выполнение процесса закончится. Чаще всего потоки-
демоны используются для выполнения фоновых задач, обслуживающих процесс в
течение его жизни.
Объявить поток демоном достаточно просто — нужно перед запуском потока вызвать
его метод setDaemon(true);
Проверить, является ли поток демоном, можно вызвав его метод boolean isDaemon();
Метод Thread.sleep()
Консоль:
Значение = 1 2 1 0 -1 -2 -1 0 1 2 3 4
Завершение потоков
Класс Thread содержит в себе скрытое булево поле, подобное полю mFinish в
программе Incremenator, которое называется флагом прерывания. Установить этот флаг
можно вызвав метод interrupt() потока. Проверить же, установлен ли этот флаг, можно
двумя способами.
Первый способ — вызвать метод bool isInterrupted() объекта потока, второй — вызвать
статический метод bool Thread.interrupted(). Первый метод возвращает состояние флага
прерывания и оставляет этот флаг нетронутым.
Консоль:
Значение = 1 2 1 0 -1 -2 -1 0 1 2 3 4
Interruption
try {
// блок кода, где отслеживаются ошибки
}
catch (тип_исключения_1 exceptionObject) {
// обрабатываем ошибку
}
catch (тип_исключения_2 exceptionObject) {
// обрабатываем ошибку
}
finally {
// код, который нужно выполнить после завершения блока try
}
Обработка исключительных событий
Существует специальный класс для исключений Throwable. В него входят два класса
Exception и Error.
Класс Error служит для обработки ошибок в самом языке Java и на практике вам не
придётся иметь с ним дело.
Несколько исключений
int catNumber;
int zero;
try { // мониторим код
catNumber = 1; // у меня один кот
zero = 1; // ноль, он и в Африке ноль
int result = catNumber / zero;
// Создадим массив из трёх котов
String[] catNames = {"Васька", "Барсик", "Мурзик"};
catNames[3] = "Рыжик";
Toast.makeText(this, "Не увидите это сообщение!", Toast.LENGTH_LONG).show();
} catch (ArithmeticException e) {
Toast.makeText(this, e.toString() + ": Нельзя котов делить на ноль!", Toast.LENGTH_LONG).show();
}
catch (ArrayIndexOutOfBoundsException e) {
Toast.makeText(this, "Ошибка: " + e.toString(), Toast.LENGTH_LONG).show();}
Toast.makeText(this, "Жизнь продолжается", Toast.LENGTH_LONG).show();
Несколько исключений
Cat cat;
public void onClick(View view) {
if(cat == null){
throw new NullPointerException("Кот не инициализирован");}}
Оператор throw
Ключевое слово finally создаёт блок кода, который будет выполнен после
завершения блока try/catch, но перед кодом, следующим за ним. Блок будет
выполнен, независимо от того, передано исключение или нет. Оператор
finally не обязателен, однако каждый оператор try требует наличия либо
catch, либо finally.
Встроенные исключения Java
} finally {
// при закрытии потока тоже возможно исключение, например, если он не был открыт, поэтому
“оборачиваем” код в блок try
try {
reader.close();
// пишем обработку исключения при закрытии потока чтения
} catch (IOException e) {
System.out.println(e.getMessage());}}
if (s.equals("")) {
// мы решили, что пустая строка может нарушить в дальнейшем работу нашей программы, например, на
результате этого метода нам надо вызывать метод substring(1,2), поэтому мы вынуждены прервать
выполнение программы с генерацией своего типа исключения MyException с помощью throw
throw new MyException("String can not be empty!"); }
return s;}
Принципы построения графического интерфейса
Компонент и контейнер
Создав компонент – объект класса Component или его расширения, следуте добавить
его к предварительно созданному объекта класса Container или его расширения одним
из методов контейнера add().
Класс Container сам является невидимым компонентом, он расширяет класс Component.
Таким образом, в контейнер наряду с компонентами можно помещать контейнеры, в
которых находятся какие-то другие компоненты, достигая тем самым большой
гибкости расположения компонентов.
Основное окно приложения, активно взаимодействующиее с операционной системой,
необходимо построить по правилам её графической системы. Око должно
перемещаться по экрану, изменять размеры, реагировать на действия мыши и
клавиатуры.
Принципы построения графического интерфейса
Компонент JComponent
Основные свойства всех компонентов Swing сосредоточены в их суперклассе
JComponent. Класс JComponent расширяет класс Container, входящий в графическую
библиотеку AWT. Поэтому компонент JComponent и все его расширения являются
контейнерами и могут содержать в себе другие компоненты. Класс Container, в свою
очередь, расширяет класс Component, содержащий около сотни методов работы с
компонентами. Эти методы и методы класса Container наследуются классом
JComponent, который добавляет к ним добрую сотню своих методов. Все компоненты
Swing расширяют класс JComponent, наследуя его богатейшие свойства. Класс
JComponent – это абстрактный класс, поэтому нельзя создать его экземпляры.
Схема MVC в компонентах Swing
2. Класс String в Java — это final класс, который не может иметь потомков.
3. Класс String — immutable класс, то есть его объекты не могут быть изменены после
создания. Любые операции над объектом String, результатом которых должен быть
объект класса String, приведут к созданию нового объекта.
5. Каждый объект в Java может быть преобразован в строку через метод toString,
унаследованный всеми Java-классами от класса Object.
Операции со строками. class String
Создание строки
Объявление:
Vector NewVec1 = new Vector();
Конструкторы класса Vector
Vector()
Создаёт пустой вектор размером 10 и с capacityIncrement = 0.
Vector(Collection c)
Создаёт вектор содержащий элементы определённой коллекции.
Vector(int initialCapacity)
Создает пустой вектор с заданным объемом памяти.
boolean add(Object o)
Добавляет в конец вектора определённый элемент.
boolean addAll(Collection c)
Добавляет в вектор все элементы определённой коллекции.
Object clone()
Возвращает аналог вектора.
boolean containsAll(Collection c)
Возвращает значение true если вектор содержит все элементы коллекции.
Методы класса Vector
void copyInto(Object[] anArray)
Копирует элементы вектора в заданный массив.
Enumeration elements()
Возвращает перечисление компонентов вектора.
boolean equals(Object o)
Сравнивает определённый объект с вектором.
Методы класса Vector
Object firstElement()
Возвращает первый элемент вектора (индекс 0).
int hashCode()
Возвращает хэш-код вектора.
boolean isEmpty()
Возвращает true если вектор пуст.
Object lastElement()
Возвращает поседний элемент вектора.
Методы класса Vector
int lastIndexOf(Object elem)
Возвращает индекс последнего найденного аналога объекта.
boolean retainAll(Collection c)
Удаляет все объекты кроме объектов содержащихся в коллекции.
Методы класса Vector
Object set(int index, Object element)
Заменяет объект в определянной позиции на другой.
Object[] toArray()
Возвращает массив содержащий все элементы вектора.
Методы класса Vector
Object[] toArray(Object[] a)
Возвращает массив содержащий все элементы вектора.
String toString()
Возвращает представление вектора в виде строки.
void trimToSize()
Приводит объем вектора к заданному размеру.
Методы класса Vector
import java.util.Vector;
public class VectorExample {
Vector vector=new Vector();
public void addCharacterandPrint(){
vector.add("Weasley");
vector.add("Potter");
for(int i=0;i<vector.size();i++){
System.out.println("The characters are\t"+vector.get(i));
}
}
public static void main(String args[]){
VectorExample example=new VectorExample(); example.addCharacterandPrint();
}
}
Методы класса Vector
search (object item) — находит позицию элемента item в стеке. Верхний элемент имеет
позицию 1, под ним элемент 2 и т. д. Если элемент не найден, возвращается — 1.
Класс Stack
import java.utii.*;
class StackTesti
static boolean checkParity(String expression,
String open, String close){
Stack stack = new Stack ();
StringTokenizer st = new StringTokenizer(expression,
" \t\n\r+*/-(){}", true);
while (st..hasMoreTokens ()) {
String tmp = st.nextToken();
if (tmp.equals(open)) , stack.push(open);
i f (tmp.equals(close)) stack.pop();
}
if (stack.isEmpty () ) return true/return fals e;
}
public static void main(String[] args){
System.out.println(
checkParityC'a - (b - (c - a) / (b + c) - 2) , "(", ")));
}
Коллекции.
Для хранения наборов данных в Java предназначены массивы. Однако их не всегда
удобно использовать, прежде всего потому, что они имеют фиксированную длину. Эту
проблему в Java решают коллекции. Однако суть не только в гибких по размеру наборах
объектов, но в и том, что классы коллекций реализуют различные алгоритмы и
структуры данных, например, такие как стек, очередь, дерево и ряд других.
Queue: наследует интерфейс Collection и представляет функционал для структур данных в виде очереди
Set: также расширяет интерфейс Collection и используется для хранения множеств уникальных объектов
NavigableSet: расширяет интерфейс SortedSet для создания коллекций, в которых можно осуществлять поиск по
соответствию
Map: предназначен для созданий структур данных в виде словаря, где каждый элемент имеет определенный ключ и
значение. В отличие от других интерфейсов коллекций не наследуется от интерфейса Collection
Типы коллекций. Абстрактные классы.
Интерфейсы частично реализуются абстрактными классами:
AbstractCollection: базовый абстрактный класс для других коллекций, который применяет интерфейс Collection
AbstractList: расширяет класс AbstractCollection и применяет интерфейс List, предназначен для создания коллекций
в виде списков
AbstractSet: расширяет класс AbstractCollection и применяет интерфейс Set для создания коллекций в виде
множеств
AbstractQueue: расширяет класс AbstractCollection и применяет интерфейс Queue, предназначен для создания
коллекций в виде очередей и стеков
AbstractSequentialList: также расширяет класс AbstractList и реализует интерфейс List. Используется для создания
связанных списков
AbstractMap: применяет интерфейс Map, предназначен для создания наборов по типу словаря с объектами в виде
пары "ключ-значение"
Типы коллекций. Абстрактные классы.
С помощью применения вышеописанных интерфейсов и абстрактных классов в Java
реализуется широкая палитра классов коллекций - списки, множества, очереди,
отображения и другие, среди которых можно выделить следующие:
HashSet: набор объектов или хеш-множество, где каждый элемент имеет ключ -
уникальный хеш-код
Типы коллекций. Абстрактные классы.
TreeMap: структура данных в виде дерева, где каждый элемент имеет уникальный
ключ и некоторое значение
Интерфейс Collection
boolean add (E item): добавляет в коллекцию объект item. При удачном добавлении
возвращает true, при неудачном - false
boolean addAll (Collection<? extends E> col): добавляет в коллекцию все элементы из
коллекции col. При удачном добавлении возвращает true, при неудачном - false
boolean contains (Object item): возвращает true, если объект item содержится в
коллекции, иначе возвращает false
boolean isEmpty (): возвращает true, если коллекция пуста, иначе возвращает false
Iterator<E> iterator (): возвращает объект Iterator для обхода элементов коллекции
boolean remove (Object item): возвращает true, если объект item удачно удален из
коллекции, иначе возвращается false
boolean removeAll (Collection<?> col): удаляет все объекты коллекции col из текущей
коллекции. Если текущая коллекция изменилась, возвращает true, иначе возвращается
false
Интерфейс Collection
boolean retainAll (Collection<?> col): удаляет все объекты из текущей коллекции, кроме
тех, которые содержатся в коллекции col. Если текущая коллекция после удаления
изменилась, возвращает true, иначе возвращается false
void add(int index, E obj): добавляет в список по индексу index объект obj
boolean addAll(int index, Collection<? extends E> col): добавляет в список по индексу
index все элементы коллекции col. Если в результате добавления список был изменен,
то возвращается true, иначе возвращается false
int indexOf(Object obj): возвращает индекс первого вхождения объекта obj в список.
Если объект не найден, то возвращается -1
Интерфейс List
E remove(int index): удаляет объект из списка по индексу index, возвращая при этом
удаленный объект
E set(int index, E obj): присваивает значение объекта obj элементу, который находится
по индексу index
Интерфейс List
List<E> subList(int start, int end): получает набор элементов, которые находятся в
списке между индексами start и end
Класс ArrayList
ArrayList(Collection <? extends E> col): создает список, в который добавляются все
элементы коллекции col.
ArrayList (int capacity): создает список, который имеет начальную емкость capacity
Класс ArrayList
После небольшого анализа, кроме этих вопросов, можно увидеть еще немалое
количество проблем, которые надо решить при мультипользовательском доступе к
данным.
В итоге было принято (и реализовано) вполне здравое решение — написать
специальную программу, которая называется — Система Управления Базами Данных
(СУБД).
Суть и цель этой программы — организовать централизованный доступ к данным. Т.е.
все запросы на получение или изменение данных от клиентских приложений
(клинетов) посылаются (обычно по сети и по протоколу TCP/IP) именно в эту
программу. И уже эта программа будет заниматься всеми вышеупомянутыми
проблемами.
Java + SQL
jdbc:mysql://localhost:3306/Database_dbName?
allowPublicKeyRetrieval=true&useSSL=false;
То есть в нашем случе
con1=(Connection)DriverManager.getConnection("jdbc:mysql://localhost:3306/DateBase?
allowPublicKeyRetrieval=true?useSSL=false", "Admin","123");