Познаём Java. Вторая чашка: собираем классы в кучки. Пробуем апплеты
Как вы уже слышали, Java проектировалась с рассчётом на совместимость со всем, чем только можно. Такое ограничение вынудило разработчиков Java сделать её такой, чтобы максимально упростить развёртывание приложений, при этом обеспечив логическую стройность языка.
Как происходит загрузка классов?
Для того, чтобы найти класс по имени когда вы его вызываете, в Java существует стандартный загрузчик классов. Он оперирует понятием classpath. Список classpath — это набор путей, где следует искать файлы классов. Каждый classpath может указывать как на директорию, так и на так называемый jar-файл (зазипованная директория со скомпилированными .class’ами и разрешением .jar, типа «йА java-archive!»). По умолчанию в classpath входят файлы стандартных библиотек и директория, из которой вы вызвали саму Java. Именно таким образом был найден класс HelloWorld — java нашла файл HelloWorld.class и запустила в нём метод main. Собственно, так и работают большинство программ, даже самых сложных. Всё начинается с одного main’а…
Пакеты классов
Пакет (package) представляют собой набор классов, объединённых по смыслу. Пакеты обычно вкладываются друг в друга, образуя собо иерархию, дающую понять, что зачем. На файловой системе такая иерархия выглядит в виде вложенных друг в друга директорий с исходниками. Так, исходники пакета a лежат в папке a, исходники пакета a.b — в папке a/b и так далее. Типичный путь к пакету выглядит примерно так:
org.apache.commons.collectons . Видите, сразу ясно зачем он нужен. Чтобы использовать какой-то класс в коде другого класса, вы должны импортировать его, написав до объявления класса строку
import путь.к.классу.ИмяКласса;
Кроме того, если вы используете классы одного пакета часто, вы можете импортировать весь пакет:
import путь.к.классу.*;
Это относится ко всем пакетам, кроме java.lang — он импортирован по умолчанию, именно из него были в прошлом примере взяты классы System и String. На самом деле они лежат в некоем jar’е, в каталоге java/lang.
Что ж, теперь вы знаете как работает загрузчик классов. В реальных проектов количество classpath измеряется десятками, а то и сотнями.
Организация кода
Если вы пишете свои первые маленькие примерчики и вам лень создавать иерархию классов — пусть, это ваше право. Но помните, в серьёзном проекте вы всегда должны будете разложить свои классы по пакетам. Обычно корневые пакеты создаются такими, чтобы ясно давать понять кто автор кода, и к чему он относится.
Например:
ru.vasiapupkin.photomaker выбирается корневым пакетом
ru.vasiapupkin.photomaker.core сюда мы пишем классы отвечающие за логику
ru.vasiapupkin.photomaker.visual сюда, допустим, все наши окошки приложения
и так далее.
Чтобы создать класс
ru.vasiapupkin.photomaker.Starter
вы должны:
создать файл Starter.java в папке ru/vasiapupkin/photomaker/
прописать в нём первой строчкой (точнее говоря, до импортов)
package ru.vasiapupkin.photomaker;
Коллижн
«А что будет, если у нас будет два класса с одним именем?», — спросите вы. «Смотрите», — отвечу я.
Допустим вы решили что вы умнее джавы и создали свой класс строки — String. Но вот проблема, у нас же уже есть такой!
Значит, вам придётся положить свой класс в пакет, скажем ru.vp.stuff и обращаться к нему так: ru.vp.stuff.String.
Именно поэтому не рекомендуется класть классы прямо в корень classpath — таким образом вы роете себе дорогу к несовместимости, ведь Java требует, чтобы каждый класс определялся однозначно. Именно поэтому нельзя написать так:
import ru.vp.SuperClass;
import ru.mashka.SuperClass;
За это вас накажет компилятор, потому что он не будет знать, какой из них использовать.
Мораль: правильно выбирайте и имя класс и имя пакета.
Погоняем?
Давайте улучшим первое приложение. Эх, классика интернета… Создадим апплет.
Эх, может быть апплетами.
import java.applet.Applet ;
import java.awt.Graphics ;
public class HelloWorld extends Applet
public void paint( Graphics g) g.drawString( «Hello World» ,15,15);
>
>
* This source code was highlighted with Source Code Highlighter .
Так, что у нас тут? Импортировано 2 класса, один из них — стандартный пустой апплет, который мы будем расширять. Второй — Graphics. Graphics — это понятие из библиотеки AWT. Кстати, небольшой экскурс. AWT (Abstract Window Toolkit) входил ещё в первую Java и был предназначен для многих задач, связанных в основном с отображением.
Так вот, объект типа Graphics позволяет нам рисовать на себе всякую муру типа строк, линий, кружочков и прочего. В данном примере мы написали строчку с отступом.
Метод paint здесь написан не от балды — он перекрывает аналогичный метод класса Applet, и когда java будет перерисовывать этот конкретный апплет, она вызовет этот метод.
Посмотреть на наш апплет достаточно просто — пишем небольшой HTML:
< body >
< applet code ="HelloWorld.class" codebase ="file:///home/devgru/" width ="150" height ="30" >
* This source code was highlighted with Source Code Highlighter .
… а может приложением.
Давайте попробуем сделать HelloWorld в standalone-приложении.
import java.awt.* ;
import javax.swing.* ;
public class HelloWorld extends JFrame
public static void main( String [] args) new HelloWorld();
>
add( new JLabel( «Hello world» ));
setSize(200,200);
setVisible( true );
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
>
>
* This source code was highlighted with Source Code Highlighter .
Здесь мы полностью импортируем основные классы пакетов Swing и AWT. Swing — более поздняя чем AWT библиотека, сейчас именно она обеспечивает отображение основной части графического интерфейса для Java-приложений.
Итак, в main мы просто создаём экземпляр класса HelloWorld.
Сейчас наш класс наследуется от класса JFrame. Это класс из Swing, он представляет собой окно, которое отображается пока не будет закрыто.
Блок <. >— это «общий конструктор». Он добавляется к любому конструктору нашего класса. Так как у нас нет ни одного — он добавляется к пустому конструктору без параметров, который создаётся на лету, если у класса нет ни одного.
Мы добавляем на окно новый объект типа JLabel (т.е. надпись), затем устанавливаем окну размеры и отображаем его. Последняя строчка нужна, чтобы выполнение приложения закончилось, когда будет закрыто окно. Таким образом, вы можете быть уверены что после закрытия окна у вас в памяти не останется висеть ваше приложение.
Запускать его нужно точно так же как и прошлое: пишем, компилируем, запускаем.
А может и сервлетами? Наверное, потом.
В этих двух статьях я постарался дать вам начальное представление о возможностях Java в общем. За рамками сегодняшней статьи (наверное, будут в завтрашней) остались сервлеты и прочие радости серверной части типа JSP-страниц, а также МИДлеты — приложения для мобилок. Я бы мог рассмотреть и то и то, но хотел бы знать, чего больше хотят читатели. Кроме того, возможно, нужно рассказать о самых основах языка. Примерно на том же уровне подробности, что и начало этой статьи. Напишите в комментариях, какую статью вы хотели бы видеть в следующий раз:
— классы и интерфейсы: ООП в джаве;
— буквы-цифры-строчки: работа с базовыми типами;
— создание оконных приложений с помощью Swing;
— от мала до велика: сервлеты, мидлеты и 2 слова о портлетах.
Когда отпишетесь — станет ясно, куда копать дальше. Всем спасибо за внимание.
Ссылка для тех, кому лень ждать завтра: основы языка (eng.).
Как объединить классы в java? Как с этих кусков кода сделать один проект?
У меня есть три класса (TypeByte, Types, Operators). Код каждого класса я написала, отдельными проектами работает, в одном проекте нет.
22 мар 2018 в 22:49
Из кода и вопроса не понятно какую цель вы преследуете. Если просто объединить файлы, то ctrl+c cltr+v вам в помощь. Иначе поясните как эти классы должны взаимодействовать и что вообще делает ваш проект.
22 мар 2018 в 23:17
Чтобы этого добиться вам требуется освоить базовые принципы ООП, разнести данные по полям и логику по методам, оставив в единственном методе main всего пару-тройку строк кода. Сейчас ваш код сложно назвать даже процедурным.
Классы. Объектно-ориентированное программирование
Java является объектно-ориентированным языком, поэтому такие понятия как «класс» и «объект» играют в нем ключевую роль. Любую программу на Java можно представить как набор взаимодействующих между собой объектов.
Шаблоном или описанием объекта является класс , а объект представляет экземпляр этого класса. Можно еще провести следующую аналогию. У нас у всех есть некоторое представление о человеке — наличие двух рук, двух ног, головы, туловища и т.д. Есть некоторый шаблон — этот шаблон можно назвать классом. Реально же существующий человек (фактически экземпляр данного класса) является объектом этого класса.
Класс определяется с помощью ключевого слова сlass :
class Person
В данном случае класс называется Person. После названия класса идут фигурные скобки, между которыми помещается тело класса — то есть его поля и методы.
Любой объект может обладать двумя основными характеристиками: состояние — некоторые данные, которые хранит объект, и поведение — действия, которые может совершать объект.
Для хранения состояния объекта в классе применяются поля или переменные класса. Для определения поведения объекта в классе применяются методы. Например, класс Person, который представляет человека, мог бы иметь следующее определение:
class Person < String name; // имя int age; // возраст void displayInfo()< System.out.printf("Name: %s \tAge: %d\n", name, age); >>
В классе Person определены два поля: name представляет имя человека, а age — его возраст. И также определен метод displayInfo, который ничего не возвращает и просто выводит эти данные на консоль.
Теперь используем данный класс. Для этого определим следующую программу:
public class Program < public static void main(String[] args) < Person tom; >> class Person < String name; // имя int age; // возраст void displayInfo()< System.out.printf("Name: %s \tAge: %d\n", name, age); >>
Как правило, классы определяются в разных файлах. В данном случае для простоты мы определяем два класса в одном файле. Стоит отметить, что в этом случае только один класс может иметь модификатор public (в данном случае это класс Program), а сам файл кода должен называться по имени этого класса, то есть в данном случае файл должен называться Program.java.
Класс представляет новый тип, поэтому мы можем определять переменные, которые представляют данный тип. Так, здесь в методе main определена переменная tom , которая представляет класс Person. Но пока эта переменная не указывает ни на какой объект и по умолчанию она имеет значение null . По большому счету мы ее пока не можем использовать, поэтому вначале необходимо создать объект класса Person.
Конструкторы
Кроме обычных методов классы могут определять специальные методы, которые называются конструкторами . Конструкторы вызываются при создании нового объекта данного класса. Конструкторы выполняют инициализацию объекта.
Если в классе не определено ни одного конструктора, то для этого класса автоматически создается конструктор без параметров.
Выше определенный класс Person не имеет никаких конструкторов. Поэтому для него автоматически создается конструктор по умолчанию, который мы можем использовать для создания объекта Person. В частности, создадим один объект:
public class Program < public static void main(String[] args) < Person tom = new Person(); // создание объекта tom.displayInfo(); // изменяем имя и возраст tom.name = "Tom"; tom.age = 34; tom.displayInfo(); >> class Person < String name; // имя int age; // возраст void displayInfo()< System.out.printf("Name: %s \tAge: %d\n", name, age); >>
Для создания объекта Person используется выражение new Person() . Оператор new выделяет память для объекта Person. И затем вызывается конструктор по умолчанию, который не принимает никаких параметров. В итоге после выполнения данного выражения в памяти будет выделен участок, где будут храниться все данные объекта Person. А переменная tom получит ссылку на созданный объект.
Если конструктор не инициализирует значения переменных объекта, то они получают значения по умолчанию. Для переменных числовых типов это число 0, а для типа string и классов — это значение null (то есть фактически отсутствие значения).
После создания объекта мы можем обратиться к переменным объекта Person через переменную tom и установить или получить их значения, например, tom.name = «Tom» .
В итоге мы увидим на консоли:
Name: null Age: 0 Name: Tom Age: 34
Если необходимо, чтобы при создании объекта производилась какая-то логика, например, чтобы поля класса получали какие-то определенные значения, то можно определить в классе свои конструкторы. Например:
public class Program < public static void main(String[] args) < Person bob = new Person(); // вызов первого конструктора без параметров bob.displayInfo(); Person tom = new Person("Tom"); // вызов второго конструктора с одним параметром tom.displayInfo(); Person sam = new Person("Sam", 25); // вызов третьего конструктора с двумя параметрами sam.displayInfo(); >> class Person < String name; // имя int age; // возраст Person() < name = "Undefined"; age = 18; >Person(String n) < name = n; age = 18; >Person(String n, int a) < name = n; age = a; >void displayInfo() < System.out.printf("Name: %s \tAge: %d\n", name, age); >>
Теперь в классе определено три коструктора, каждый из которых принимает различное количество параметров и устанавливает значения полей класса.
Консольный вывод программы:
Name: Undefined Age: 18 Name: Tom Age: 18 Name: Sam Age: 25
Ключевое слово this
Ключевое слово this представляет ссылку на текущий экземпляр класса. Через это ключевое слово мы можем обращаться к переменным, методам объекта, а также вызывать его конструкторы. Например:
public class Program < public static void main(String[] args) < Person undef = new Person(); undef.displayInfo(); Person tom = new Person("Tom"); tom.displayInfo(); Person sam = new Person("Sam", 25); sam.displayInfo(); >> class Person < String name; // имя int age; // возраст Person() < this("Undefined", 18); >Person(String name) < this(name, 18); >Person(String name, int age) < this.name = name; this.age = age; >void displayInfo() < System.out.printf("Name: %s \tAge: %d\n", name, age); >>
В третьем конструкторе параметры называются так же, как и поля класса. И чтобы разграничить поля и параметры, применяется ключевое слово this:
this.name = name;
Так, в данном случае указываем, что значение параметра name присваивается полю name.
Кроме того, у нас три конструктора, которые выполняют идентичные действия: устанавливают поля name и age. Чтобы избежать повторов, с помощью this можно вызвать один из конструкторов класса и передать для его параметров необходимые значения:
Person(String name)
В итоге результат программы будет тот же, что и в предыдущем примере.
Инициализаторы
Кроме конструктора начальную инициализацию объекта вполне можно было проводить с помощью инициализатора объекта. Инициализатор выполняется до любого конструктора. То есть в инициализатор мы можем поместить код, общий для всех конструкторов:
public class Program < public static void main(String[] args) < Person undef = new Person(); undef.displayInfo(); Person tom = new Person("Tom"); tom.displayInfo(); >> class Person < String name; // имя int age; // возраст /*начало блока инициализатора*/ < name = "Undefined"; age = 18; >/*конец блока инициализатора*/ Person() < >Person(String name) < this.name = name; >Person(String name, int age) < this.name = name; this.age = age; >void displayInfo() < System.out.printf("Name: %s \tAge: %d\n", name, age); >>
Name: Undefined Age: 18 Name: Tom Age: 18
Объединение двух списков в Java
Одна из типичных задач, которые часто встречаются при работе с Java, — это объединение двух списков. Рассмотрим пример: есть два списка, каждый из которых содержит некоторые элементы. Задача — создать новый список, который будет содержать элементы из обоих исходных списков.
List<String> listOne = Arrays.asList("one", "two", "three"); List<String> listTwo = Arrays.asList("four", "five", "six");
Самый прямой и простой способ объединить эти два списка — это использовать метод addAll() , предоставляемый интерфейсом List . Он позволяет добавить все элементы из одного списка в другой.
List<String> newList = new ArrayList<String>(); newList.addAll(listOne); newList.addAll(listTwo);
В результате, newList будет содержать элементы из обоих исходных списков: «one», «two», «three», «four», «five», «six».
Однако стоит учесть, что этот подход изменяет список, к которому добавляются элементы. Если есть необходимость сохранить исходные списки без изменений, можно создать новый список и добавить в него элементы из обоих исходных списков.
List<String> newList = new ArrayList<String>(listOne); newList.addAll(listTwo);
Таким образом, listOne и listTwo останутся без изменений, а newList будет содержать элементы из обоих исходных списков.
Это простой и эффективный способ объединить два списка в Java, не требующий использования сторонних библиотек или специфических функций языка.