Разное

Как создать файл java: Класс File. Работа с файлами и каталогами

Содержание

Как Создать Собственный Формат Файла В Java

Это зависит от того, какой файл он и какие данные он будет содержать.

Я предполагаю, что вы хотите использовать его для сохранения данных из созданного вами программного обеспечения и только для чтения с помощью этого программного обеспечения. Например,.doc создаются и читаются Microsoft Word.

Первый вопрос, который вы должны задать себе:

Будет ли файл доступен для чтения людьми?

Другими словами, вы можете открыть его с помощью блокнота, например, например.html.

Если да, выберите (или создайте) синтаксис, например, XML (который часто может быть лучшим выбором).

Пример:

<supersoft>
<preference>
<some-preference foo="bar" />
</preference>
<data>
<some-data foo="baz" />
</data>
</supersoft>

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

Пример:

SuperSoft1101100111010110110010111010110101010101010110101011010101101010101011011010101010101010110101011010101101010101

Следующий вопрос:

Какое расширение я хочу?

Вы можете выбрать что угодно, но старайтесь избегать уже принятых имен. Если вы выберете.jpg, например, ваша ОС попытается открыть файл с помощью средства просмотра изображений. Проверьте в Интернете, если экстенсон уже существует.

Последний вопрос:

Должен ли я открывать свое программное обеспечение при открытии файла?

Например, двойной щелчок на.xls автоматически открывает Excel. Этот шаг зависит от используемой ОС.

Я предполагаю, что сохранение и загрузка данных — это то, что вы уже знаете.

Java создать текстовый файл

Хотя с помощью ранее рассмотренных классов можно записывать текст в файлы, однако они предназначены прежде всего дл работы с бинарными потоками данных, и их возможностей для полноценной работы с текстовыми файлами недостаточно. И для этой цели служат совсем другие классы, которые являются наследниками абстрактных классов Reader и Writer .

Запись файлов. Класс FileWriter

Класс FileWriter является производным от класса Writer. Он используется для записи текстовых файлов.

Чтобы создать объект FileWriter, можно использовать один из следующих конструкторов:

Так, в конструктор передается либо путь к файлу в виде строки, либо объект File, который ссылается на конкретный текстовый файл. Параметр append указывает, должны ли данные дозаписываться в конец файла (если параметр равен true), либо файл должен перезаписываться.

Запишем в файл какой-нибудь текст:

В конструкторе использовался параметр append со значением false – то есть файл будет перезаписываться. Затем с помощью методов, определенных в базовом классе Writer производится запись данных.

Чтение файлов. Класс FileReader

Класс FileReader наследуется от абстрактного класса Reader и предоставляет функциональность для чтения текстовых файлов.

Для создания объекта FileReader мы можем использовать один из его конструкторов:

А используя методы, определенные в базом классе Reader, произвести чтение файла:

Также мы можем считывать в промежуточный буфер из массива символов:

В данном случае считываем последовательно символы из файла в массив из 256 символов, пока не дойдем до конца файла в этом случае метод read возвратит число -1.

Создание нового файла в Java не такое уж сложное дело. Эта статья поможет новичкам научиться, как создать и записать новый файл в Java.

Сначала научимся, как создать новые файлы в Java.

Есть много способов для этого, но в этой статье мы расскажем о трех способах создания файла.

Используйте класс java.io.File¶

При установлении объекта File вы указываете название файла и дальше используйте метод createNewFile(), который атомарно создает новый пустой файл с названием абстрактного пути, но только в случае, если файл с таким названием не существует.

Данный метод возвращает true, если названный файл не существует и был успешно создан. Возвращает false, если файл существует. Он также создает java.io.IOException, когда не может создать файл. Созданный файл пуст и имеет нулевой байт.

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

Запомните, что этот метод только создает файл, но не записывает к нему контент.

Пример

Когда закончите и запустите программу, результат будет иметь следующий вид:

Результат

2. Используйте класс java.io.FileOutputStream¶

Если хотите создать новый файл и одновременно записать какую-нибудь информацию в нем, можете использовать метод FileOutputStream.write. Этот метод автоматически создает новый файл и записывает в нем контент.

Метод FileOutputStream используется для записи байтов в файл. Если хотите записать символьно-ориентированную информацию, будет лучше использовать FileWriter.

Смотрите использование кода:

Пример

3. Используйте Java NIO Files.write()¶

Используйте класс Java NIO Files для создания нового файла и записи информации в нем. Этот Java класс представляет метод write(Path path, byte[] bytes, OpenOption… options), который записывает байты к файлу по указанному пути.

С использованием класса Files возможно создавать, перемещать, копировать, удалять файлы и каталоги. Он также может быть использован для записи и чтения файла.

Files.write() – это рекомендуемый способ создания файла, так как вам не придется беспокоиться о закрытии ресурсов IO.

Этот класс имеет следующие параметры:

  • lines – объект для реализования последовательности символов. Запишите строки текста к файлу. Каждая строка – это последовательность символов и записывается к файлу поочередно. Каждая строка заканчивается разделителем строки платформы.
  • options – Этот параметр указывает, как создается или открывается файл. Если никакой параметр не указан, по умолчанию будут выбраны параметры CREATE, TRUNCATE_EXISTING and WRITE. Это означает, что он открывает файл для записи и создает файл, если он не существует, или размер файла доводит до 0, если файл существует.
  • path – Указывает путь.
  • cs – Набор символов, используемый для кодировки

All the bytes in byte array are written to the file. This method ensures that the file is closed when all the bytes have been written and returns the path of written file.

Сегодня мы рассмотрим простейший способ создания файла в Java, узнаем какие исключения могут нас подстерегать при работе с файлами и рассмотрим разные способы создания файла.

Для создания нового файла в Java чаще всего используется класс java.io.File . Во время инициализации объекта File мы должны предоставить ему имя файла, а затем создать сам файл вызовом метода createNewFile() . Этот метод возвращает булево true , если новый файл создан успешно, и false , если файл уже существует. Этот метод также бросает java.io.IOException , когда он не может создать файл.

Немного теории по созданию файла в Java

Создать файл в Java можно одним из трех способов, передав в объект File :

  • абсолютный путь
  • только указать имя файла
  • указать относительный путь (в этом случае объект файла пытается найти файлы в корневой директории проекта)

При создании пути к файлу мы должны использовать свойство системы File.separator , чтобы сделать нашу программу платформонезависимой.

Давайте рассмотрим различные способы создания файла в простой Java программе:

Как открыть и прочитать текстовый файл в Java

Управление текстовыми файлами — это навык, который хорошо послужит вам в вашей карьере программиста. В этом разделе вы узнаете, как создать, открыть и прочитать текстовый файл Java.

Под текстовым файлом мы имеем в виду файл с текстом — все просто! Вы можете создать текстовый файл в таких программах, как Блокнот на компьютере с Windows, TextEdit на Mac, Gedit в среде Linux/Gnome.

Первое, что мы сделаем, это откроем текстовый файл и прочитаем его содержимое.

Как прочитать текстовый файл

Для этой цели начните новый проект. Назовите пакет openandread, а класс ReadFile. Добавьте оператор импорта чуть ниже названия пакета и перед именем класса:

import java.io.IOException;

Ваше окно с кодом будет выглядеть так:

package openandread;
import java.io.IOException;

public class ReadFile {

    public static void main(String[] args) throws IOException {
         
    }  
}

Чтобы Java-программа работала корректно с нашими текстовыми файлами, добавьте следующее к методу main (текст на синем фоне):

public static void main(String[] args) throws IOException {

}

Мы говорим Java, что метод main вызовет ошибку IOException, и что ее необходимо устранить. Позже мы добавим блок try … catch, чтобы отобразить соответствующее сообщение об ошибке для пользователя.

Чтобы открыть текстовый файл, давайте создадим новый класс. Итак выберите File > New File в меню NetBeans вверху. Создайте новый файл Java Class и дайте ему имя FileData. Когда ваш новый класс будет создан, добавьте следующие три оператора импорта:

import java.io.IOException;
import java.io.FileReader;
import java.io.BufferedReader;

Ваш новый класс должен выглядеть следующим образом:

(Все три импорта подчеркнуты желтым цветом, потому что мы еще ничего с ними не сделали. Это функция NetBeans.)

Для того, чтобы прочитать текстовый файл Java, мы создадим новый объект из этого класса. Добавьте следующий конструктор в свой код вместе с приватным полем String с именем path_to_file:

public class FileData {
    
    private String path_to_file;
    
    public FileData (String path) {
        path_to_file = path;
    }
 
}

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

Теперь нам нужно создать метод, который возвращает все строки кода из текстового файла. Они будут храниться в массиве. Добавьте следующее объявление метода, который откроет файл:

Не переживайте из-за красного подчеркивания: оно исчезнет, ​​как только мы добавим код. NetBeans добавляет подчеркивание, потому что у нас нет оператора return.

Обратите внимание, что метод настроен на возврат массива String:

public String[]

Массив будет содержать все строки из текстового файла.

Также обратите внимание, что мы добавили в конец заголовка метода throws IOException. Каждый метод, который работает над чтением текстовых файлов в Java, нуждается в подобном методе. Throw в переводе с английского означает «выбросить». Java выбросит ошибки, которые мы сможем увидеть в нашем методе main.

Для того, что прочитать символы из текстового файла используется FileReader. Он читает байты из текстового файла, а каждый байт является отдельным символом.

Вы можете читать целые строки текста, а не отдельные символы. Для этого нужно передать то, что находится в FileReader классу BufferedReader. BufferedReader имеет удобный метод, называемый ReadLine. Как следует из названия, он используется для чтения целых строк, а не отдельных символов. А вот BufferedReader сохраняет символы в памяти (в буфере), чтобы ими было легче манипулировать.

Давайте установим FileReader и BufferedReader:

public String[] OpenAndRead() throws IOException {
        
    FileReader x = new FileReader(path_to_file);
    BufferedReader varRead = new BufferedReader(x);
 
}

Здесь мы создаем два новых объекта: первый — это объект FileReader, который мы назвали x; второй — это объект BufferedReader с именем varRead.

FileReader открывает и считывает файл, исходя из пути к нему. Эту информацию мы сохраняем в переменной path_to_file. А дальше мы можем использовать ее.

В BufferedReader передается объект FileReader (в круглых скобках). Все символы файла затем сохранятся в памяти в ожидании манипуляции. Они сохранятся в переменной varRead.

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

int num = 3;
String[] lines = new String[num];

Сейчас мы установили количество строк в текстовом файле равным 3. Очевидно, что текстовые файлы могут содержать любое количество строк, и мы обычно не знаем, сколько их. Поэтому вскоре мы это изменим. Мы напишем отдельный метод, который получает количество строк в текстовом файле.

Дальше мы устанавливаем массив строк. Количество позиций в массиве (его размер) устанавливается равным количеству строк. Мы поместили эту переменную в квадратные скобки.

Чтобы поместить все строки текста из файла в каждую позицию в массиве, нам нужен цикл. Цикл получит каждую строку текста и поместит их в массив. Добавьте следующее в код:

int i;
for (i = 0; i < num; i++) {
    lines[i] = varRead.readLine();
}

Ваше окно с кодом должно выглядеть так:

public String[] OpenAndRead() throws IOException {

    FileReader x = new FileReader(path_to_file);
    BufferedReader varRead = new BufferedReader(x);
        
    int num = 3;
    String[] lines = new String[num];
        
    int i;
    for (i = 0; i < num; i++) {
        lines[i] = varRead.readLine();
    }

}

Цикл for идет от 0 до меньше, чем количества строк. (Помните, позиции массива начинаются с 0. Три строки будут сохранены в позициях 0, 1 и 2.)

Здесь мы обращаемся к строкам текста и сохраняем их в массив:

lines[i] = varRead. readLine();

После знака равенства мы имеем это:

varRead.readLine();

Объект varRead, который мы установили, читает все символы из текстового файла, которые находятся в памяти (в буфере). Мы можем использовать метод readLine, чтобы прочитать полную строку текстового файла из буфера. После того, как строка прочитана, мы сохраняем ее в позиции массива:

lines[i]

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

Осталось добавить в метод следующее:

varRead.close();
return lines;

Метод close очищает временный буфер памяти с именем varRead. Возвращаемая строка возвращает весь массив. Обратите внимание, что для этого массива квадратные скобки не требуются.

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

public String[] OpenAndRead() throws IOException {

    FileReader x = new FileReader(path_to_file);
    BufferedReader varRead = new BufferedReader(x);
        
    int num = 3;
    String[] lines = new String[num];
        
    int i;
    for (i = 0; i < num; i++) {
        lines[i] = varRead.readLine();
    }
        
    varRead.close();
    return lines;
}

Однако все еще существует проблема количества строк. Мы указали жесткое 3. Нам нужно прочитать весь текстовый файл и посчитать, сколько в нем строк. Поэтому добавьте следующий метод в класс FileData:

int numStrings() throws IOException {

    FileReader text = new FileReader(path_to_file);
    BufferedReader y = new BufferedReader(text);
        
    String one;
    int num = 0;
        
    while ((one = y.readLine()) != null) {
        num++;
    }
    y. close();
        
    return num;
}

Новый метод называется numStrings и настроен на возврат целочисленного значения. Это количество строк в текстовом файле. Обратите внимание, что этот метод в заголовке также имеет IOException.

В этом коде устанавливается другой FileReader и другой BufferedReader. Чтобы поставить в цикл наш текст, мы написали:

while ((one = y.readLine()) != null) {
    num++;
}

Цикл while выглядит немного грязно. Но он просто говорит «прочитайте каждую строку текста и остановитесь, когда не будет достигнуто нулевое значение». (Если Java прочитала весь текстовый файл, и больше не осталось строк, вернется значение null.) В фигурных скобках мы увеличиваем счетчик с именем num.

В конце кода мы очищаем буфер памяти с именем y и возвращаем количество строк.

Чтобы вызвать этот новый метод в действие, измените методе OpenAndRead это:

int num = 3; 

На это:

int num = numStrings();

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

Хорошо, пришло время запустить новый класс и посмотреть, открывает ли он текстовый файл и сможет ли он прочитать его.

Вернитесь к классу ReadFile, классу с методом main. Установите строковую переменную для хранения имени текстового файла:

package openandread;
import java.io.IOException;

public class ReadFile {

    public static void main(String[] args) throws IOException {

        String new_path = "D:/test.txt";

    }  
}

На этом этапе вам нужно создать текстовый файл где-нибудь на компьютере. Мы создали его в блокноте на компьютере с Windows:

Имя текстового файла — test.txt. Создайте аналогичный у себя. Обратите внимание, куда вы его сохраняете, чтоб указать правильный путь к нему:

String new_path = "D:/test.txt";

Если бы мы создали папку с именем MyFiles для хранения этого файла, путь был бы «D: /MyFiles/test. txt». Измените путь к файлу, если это необходимо.

Следующее, что нужно сделать, — это создать новый объект из нашего класса FileData. Затем мы сможем вызвать метод, который откроет и прочитает наш текстовый файл в Java. Мы сделаем это в блоке try … catch.

Добавьте следующий код под переменной String:

try {
    FileData new_file = new ReadFile(new_path);
    String[] aryStrings = new_file.OpenAndRead();

}
catch (IOException a) {
    System.out.println(a.getMessage());
}

Не забудьте все фигурные скобки для блока try … catch. Вам нужна одна пара для части try и другая — для части catch. Для пробной части у нас есть это:

FileData new_file = new ReadFile(new_path);
String[] aryStrings = new_file.OpenAndRead();

Первая строка устанавливает новый объект FileData с именем new_file. В круглых скобках FileData мы добавили переменную new_path. Этого достаточно, чтобы передать конструктору путь к файлу, который ему нужен.

Вторая строка кода устанавливает массив String с именем aryStrings. После знака равенства мы вызвали метод OpenAndRead нашего класса FileData. Если он успешно открывает текстовый файл, то массив текстовых строк будет передан новому массиву aryStrings.

Однако, если что-то пойдет не так, появится ошибка, которую мы поместили в части catch блока try … catch:

catch (IOException a) {
    System.out.println(a.getMessage());
}

После слова catch в круглых скобках у нас есть это:

IOException a

Для этого исключения мы устанавливаем переменную с именем a, которая имеет тип IOException. У объекта IOException есть собственные методы, которые вы можете использовать. Одним из таких методов является getMessage. Это даст пользователю некоторую информацию о том, что пошло не так.

Прежде чем мы увидим пример сообщения об ошибке, давайте пройдемся по всем строкам текстового файла, распечатав каждую. Добавьте следующий код цикла в try блока try … catch:

int i;
for (i = 0; i < aryStrings.length; i++) {
    System.out.println(aryStrings[i]);
}

Ваше окно с кодом должно теперь выглядеть так:

package openandread;
import java.io.IOException;

public class ReadFile {

    public static void main(String[] args) throws IOException {

        String new_path = "D:/test.txt";
        
        try {
            FileData new_file = new FileData(new_path);
            String[] aryStrings = new_file.OpenAndRead();
            
            int i;
            for (i = 0; i < aryStrings.length; i++) {
                System. out.println(aryStrings[i]);
            }
        }
        catch (IOException a) {
            System.out.println(a.getMessage());
        }   
    }  
}

Когда программа будет запущена, в окне «Вывод» будет напечатано следующее:

Как видите, с помощью Java мы прочитали каждую строку из нашего текстового файла.

Чтобы проверить часть кода, проверяющую ошибки, измените имя вашего текстового файла на тот, который, как вы знаете, не был создан. Затем запустите этот код. В окне «Вывод» ниже вы можете видеть, что наш текстовый файл был изменен на test2, и его не удалось найти:

При желании вы можете добавить собственное сообщение об ошибке в блок catch:

catch (IOException e) {
    System.out.println("Извини, друг, не могу это сделать!");
}   

Как прочитать текстовый файл с русскими буквами в Java

Если вас интересует, как прочитать текстовый файл на русском языке, то:

  1. Нужно добавить еще несколько import:
    import java. io.InputStreamReader;
    import java.io.Reader;
    import java.io.FileInputStream;
    

  2. В методе numStrings замените строку:
    FileReader text = new FileReader(path_to_file);
    

    На эту:

    Reader text = new InputStreamReader(new FileInputStream(path_to_file), "Cp1251");
    

  3. В методе OpenAndRead замените строку:
    FileReader x = new FileReader(path_to_file);
    

    На эту:

    Reader x = new InputStreamReader(new FileInputStream(path_to_file), "Cp1251");
    

Cp1251 – это кодировка, в которой выполнен текстовый файл. Мы конвертируем символы кириллицы с помощью InputStreamReader и FileInputStream.

Окно «Вывод» будет следующим:

В следующем уроке вы узнаете, как сделать запись в уже существующий текстовый файл или создать новый, используя код Java.

Intellij Idea — создание первого Java-проекта

Настало время получить практический опыт работы с IntelliJ. В этой главе мы создадим наш первый Java-проект. Мы напишем и выполним традиционную программу Hello World . В этой главе описывается компиляция и запуск приложения Java.

Создать проект

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

  • Запустите IntelliJ.

  • Перейдите в Файл → Создать → Меню проекта .

  • Выберите проект Java и соответствующий SDK и нажмите кнопку «Далее».

Запустите IntelliJ.

Перейдите в Файл → Создать → Меню проекта .

Выберите проект Java и соответствующий SDK и нажмите кнопку «Далее».

  • Если вы хотите создать класс Java с помощью метода main, то выберите «Создать проект» из флажка шаблона.

  • Выберите приложение командной строки в диалоговом окне, показанном ниже, и продолжите.

  • Введите название проекта и местоположение каталога.

  • Нажмите на кнопку Готово.

Если вы хотите создать класс Java с помощью метода main, то выберите «Создать проект» из флажка шаблона.

Выберите приложение командной строки в диалоговом окне, показанном ниже, и продолжите.

Введите название проекта и местоположение каталога.

Нажмите на кнопку Готово.

Создать пакет

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

  • Перейти к перспективе проекта.

  • Щелкните правой кнопкой мыши Project, выберите опцию New-> Module .

Перейти к перспективе проекта.

Щелкните правой кнопкой мыши Project, выберите опцию New-> Module .

  • Новое окно модуля будет похоже на новый проект. Выберите опцию Java и соответствующий SDK и нажмите кнопку Далее.

  • Введите имя модуля.

  • Нажмите на кнопку Готово.

Новое окно модуля будет похоже на новый проект. Выберите опцию Java и соответствующий SDK и нажмите кнопку Далее.

Введите имя модуля.

Нажмите на кнопку Готово.

Создать класс Java

В этом разделе мы узнаем, как создать класс Java. Класс Java может быть создан под модулем Java. Выполните следующие шаги, чтобы создать модуль —

  • Перейти к перспективе проекта.

  • Разверните Project и выберите каталог src из модуля.

  • Щелкните по нему правой кнопкой мыши; выберите опцию New-> Java Class.

  • Введите имя класса в диалоговом окне и нажмите кнопку ОК.

  • Откроется окно редактора с объявлением класса.

Перейти к перспективе проекта.

Разверните Project и выберите каталог src из модуля.

Щелкните по нему правой кнопкой мыши; выберите опцию New-> Java Class.

Введите имя класса в диалоговом окне и нажмите кнопку ОК.

Откроется окно редактора с объявлением класса.

Запустить Java-приложение

Теперь мы увидим, как запустить приложение Java. Выполните следующие действия и посмотрите, как это работает.

Давайте напишем простой код, который напечатает сообщение на консоли. Введите следующий код в окне редактора —

Перейдите в меню «Выполнить» и выберите параметр «Выполнить».

Выберите имя класса и нажмите «Выполнить».

Если нет ошибок компиляции, то он покажет вывод в нижней части окна.

Пакетирование и распространение настольных приложений Java

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

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

В этом упражнении мы создаем проект среды IDE и затем помещаем в этот проект два заранее написанных файла исходного кода Java. Затем мы скомпилируем классы и создадим исполняемый файл JAR. После этого мы посмотрим, как запускать файлы JAR вне среды IDE.

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

Создание проекта с помощью существующих файлов исходного кода

  1. Загрузите файл DeploymentTutorial.zip и извлеките его содержимое.
    Данный архив ZIP содержит файлы исходного кода для приложения, а также несколько других файлов, которые будут использованы в этом руководстве.

    1. В IDE NetBeans выберите ‘Файл’ > ‘Создать проект’.

    2. На странице Choose Category («Выбор категории») выберите Java Project With Existing Sources («Проект Java с существующим исходным кодом») в категории Java и нажмите кнопку Next («Далее»).

    3. На странице Name and Location («Имя и местоположение») мастера введите AnotherGrep в поле имени проекта и укажите местоположение проекта.
      Нажмите кнопку «Далее».

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

  1. На странице мастера Existing Sources («Существующие исходные файлы») укажите файлы исходного кода, которые будут включены в проект.
    Нажмите кнопку Add Folder («Добавить папку») справа от поля Source Package Folders («Папки пакетов исходного кода»). Перейдите к папке DeploymentTutorial , которую только что разархивировали, разверните папку, выберите папку src и нажмите кнопку Open («Открыть»). Папка src будет добавлена к полю Source Package Folders («Папки пакетов исходного кода»).

  2. Нажмите кнопку «Завершить».

Примечание. Если, например, необходимо исключить определенные исходные файлы из операции импорта в проект, щелкните ‘Далее’, чтобы открыть последнее окно ‘Включает & Исключает’. В этом случае необходимо использовать все исходные файлы в папке src поэтому нажимается кнопка ‘Готово’, чтобы завершить работу в мастере создания проектов.

Проект откроется в среде IDE и отобразится в окне «Проекты». Изучить содержание проекта можно, развернув его узел пакетов исходного кода, в котором можно будет увидеть классы Grep и xGrep . Grep.java – файл консольной версии приложения. xGrep.java – файл версии приложения с графическим интерфейсом, использующей методы, определенные в Grep.java .

Настройка проекта

Для настройки проекта необходимо выполнить несколько действий:

  • Выберите платформу Java, которая будет использована для компиляции файлов исходного кода.

  • Назначьте главный класс проекта. Это позволит гарантировать, что файл JAR, создаваемый при построении проекта, будет исполняемым.

Проверка платформы Java

Наш проект должен быть скомпилирован и выполнен на платформе Java 7 или Java 8. Поэтому нам необходимо убедиться, что платформа Java 7 или Java 8 соответственно используется в качестве платформы для данного проекта.

  1. Правой кнопкой мыши щелкните узел проекта и выберите элемент «Свойства».

  2. На вкладке «Библиотеки» в качестве платформы Java должна быть указана версия JDK 1. 7 (или JDK 1.8).

  3. На вкладке Sources («Источники») выберите JDK 7 (или JDK 8) как формат двоичных файлов/файлов исходного кода.

  4. Нажмите кнопку «OК», чтобы закрыть окно Project («Свойства»).

Назначение главного класса

Чтобы пользователь мог без труда запустить создаваемый файл JAR (дважды щелкнув его или введя java -jar AnotherGrep.jar в командной строке), необходимо указать главный класс внутри файла манифеста manifest в архиве JAR. (Файл манифеста является стандартной частью архива JAR, содержащей информацию о файле JAR, которая будет полезна для средства запуска java при запуске приложения.) Главный класс служит точкой входа, из которой средство запуска java запускает приложение.

При сборке проекта среда IDE создает файл JAR и включает в него манифест. При назначении главного класса проекта мы убеждаемся, что главный класс указан в манифесте.

Для назначения главного класса проекта выполните следующие действия:

  1. Правой кнопкой мыши щелкните узел проекта и выберите элемент «Свойства».

  2. Выберите категорию Выполнение и введите anothergrep.xGrep в поле ‘Основной класс’.

  3. Нажмите кнопку «ОК» для закрытия диалогового окна «Свойства проекта».

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

Main-Class: anothergrep.xGrep

Построение проекта и создание файла JAR

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

Сборка проекта

При сборке проекта происходит следующее.

  • К папке проекта (далее именуемой «папка PROJECT_HOME«) добавляются папки build и dist .

  • Все исходные файлы компилируются в файлы .class , которые помещаются в папку PROJECT_HOME/build .

  • В папке PROJECT_HOME/dist создается архив JAR, содержащий проект.

  • Если для проекта указаны какие-либо библиотеки (кроме JDK), в папке dist создается папка lib . Библиотеки копируются в папку dist/lib .

  • Файл манифеста manifest в архиве JAR обновляется за счет включения записей, указывающих главный класс и все библиотеки, которые находятся в пути классов проекта.

Примечание. Содержимое Manifest можно просмотреть в окне ‘Файлы’ IDE. После построения проекта переключитесь на окно Files («Файлы») и перейдите к dist/AnotherGrep.jar . Разверните узел файла JAR, разверните папку META-INF и дважды щелкните MANIFEST.MF , чтобы отобразить Manifest в редакторе исходного кода.

Main-Class: anothergrep.xGrep

(Дополнительные сведения о файлах манифеста приведены в этом разделе в учебном курсе по Java).

Работа с файлами JAR и Manifest в Java

Обязательное условие — формат файла JAR

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

Создание файла JAR — дополнительные параметры

Файл JAR создается с помощью инструмента JAR. Общая команда выглядит примерно так:

 jar options jar-file [manifest-file] file1 file2 file3 ...
  • jar-file: имя файла jar, в котором вы хотите использовать инструмент jar.
  • file1, file2, file3: файлы, которые вы хотите добавить в файл jar. manifest-file — это имя файла, который содержит манифест этого jar-файла, указывать манифест-файл в качестве аргумента совершенно необязательно.
  • c : создает новый или пустой архив и добавляет в него файлы. Если какое-либо из указанных имен файлов является каталогами, то программа jar обрабатывает их рекурсивно.
  • C : временно меняет каталог.
  • e: создает точку входа в манифест.
  • f : указывает имя файла JAR в качестве второго аргумента командной строки. Если этот параметр отсутствует, jar запишет результат в стандартный вывод (при создании файла JAR) или прочитает его из стандартного ввода (при извлечении или табулировании файла JAR).
  • я : создает индексный файл.
  • m : добавляет файл манифеста в файл JAR. Манифест — это описание содержимого архива и его происхождения. Каждый архив имеет манифест по умолчанию, но вы можете указать свой собственный, если хотите аутентифицировать содержимое архива.
  • М : Не создает файл манифеста для записей.
  • t: отображение оглавления.
  • u: обновляет существующий файл JAR.
  • v: генерирует подробный вывод.
  • x: извлечь файлы Если вы указываете одно или несколько имен файлов, извлекаются только эти файлы. В противном случае все файлы извлекаются.
  • 0: магазины без сжатия zip.

Параметры команды jar почти аналогичны параметрам команды tar в UNIX. В окнах вы также можете получить справку о различных параметрах команды jar, просто набрав jar в cmd и нажав Enter, результат будет примерно таким:

Пример :

Для создания файла JAR с двумя классами server.class и client.class и Jpeg image logo.jpeg необходимо написать следующую команду:

 jar cvf chat.jar server.class client.class logo.jpeg

Вывод вышеуказанной команды будет выглядеть примерно так:

Лучше использовать опцию -v вместе с командой jar, чтобы узнать, как идут дела.

Файл манифеста

Каждый файл JAR содержит файл манифеста, который описывает функции архива. Каждый JAR-файл имеет файл манифеста по умолчанию. Файл манифеста по умолчанию называется MANIFEST.MF и присутствует в подкаталоге META-INF архива. Хотя файл манифеста по умолчанию содержит только две записи, но у сложных файлов манифеста может быть намного больше. Вот как выглядит файл манифеста по умолчанию:

Записи файлов манифеста сгруппированы в разделы. Каждый раздел имеет две записи имя раздела и его значение. Чуть позже мы увидим, как эти разделы могут реально помочь нам в управлении свойствами нашего архива. Файл манифеста также можно обновить с помощью параметра m команды jar. Но есть некоторые вещи, которые необходимо учитывать при обновлении файла манифеста, иначе вы можете получить следующее жуткое сообщение.

 java.io.IOException: invalid manifest format

Что нужно иметь в виду при работе с файлами манифеста:

  1. Вы должны оставить пробел между именем и значением любого раздела в файле манифеста, например, версия: 1.1 находится в допустимом разделе, вместо этого напишите версию: 1.1, что пробел между двоеточием и 1.1 действительно имеет большое значение.
  2. При указании основного класса не следует добавлять расширение .class в конце имени класса. Просто укажите основной класс, набрав:
    Main-Class: Classname

    (Очень скоро я расскажу о секции Main-Class).

  3. Вы должны добавить новую строку в конце файла. Вам не нужно писать / n для указания новой строки, вместо этого просто оставьте последнюю строку вашего файла манифеста пустой, которая будет служить цели.
  4. Текстовый файл для манифеста должен использовать кодировку UTF-8, иначе вы можете столкнуться с некоторыми проблемами.

Пример:

Теперь вернемся и обновим содержимое нашего архива chat.jar. Чтобы обновить файл манифеста, нам просто нужно написать следующую команду:

 jar uvfm chat.jar manifest.txt

Здесь manifest.txt — это новый файл манифеста, который имеет следующее содержимое:

Вывод вышеуказанной команды будет выглядеть примерно так:

Здесь мы получаем два предупреждения, потому что мы пытаемся перезаписать ранее представленные записи.

Исполняемые файлы Jar

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

Пример:

Чтобы создать файл chat.jar с классом клиента в качестве основного, необходимо написать следующую команду —

 jar cvfe chat.jar client client.class server.class logo.jpeg

Вывод вышеуказанной команды будет выглядеть примерно так:

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

В качестве альтернативы вы можете добавить запись Main-Class в файл манифеста, а затем обновить ее. Для приведенного выше примера вам просто нужно добавить эту запись:

 Main-Class: client

Когда основной класс установлен, можно просто запустить jar-программу, написав следующую команду:

 java -jar chat.jar

В зависимости от конфигурации операционной системы пользователи могут даже запустить приложение, дважды щелкнув значок файла JAR.

Запечатывание пакета

Наконец, мы собираемся обсудить герметизацию пакетов в Java. Мы можем запечатать пакет в Java, чтобы другие классы не могли добавить себя в него. Возможно, вы захотите запечатать пакет, если вы используете в коде видимые классы, методы и поля. Без запечатывания упаковки другие классы могут добавлять себя в ту же упаковку и, таким образом, получать доступ к видимым функциям упаковки.

Это все с моей стороны о том, как работать с файлами JAR. Будьте на связи!!

Эта статья предоставлена Abhey Rana (UselessCoder) . Если вы как GeeksforGeeks и хотели бы внести свой вклад, вы также можете написать статью с помощью contribute.geeksforgeeks.org или по почте статьи [email protected]. Смотрите свою статью, появляющуюся на главной странице GeeksforGeeks, и помогите другим вундеркиндам.

Пожалуйста, пишите комментарии, если вы обнаружите что-то неправильное или вы хотите поделиться дополнительной информацией по обсуждаемой выше теме.

Рекомендуемые посты:

Работа с файлами JAR и Manifest в Java

0. 00 (0%) 0 votes

Модуль 2. Урок 4. Пакеты в Java.

Это базовая тема. Двигаться дальше, к следующему уроку, стоит только после вдумчивого понимания этой темы. Смелее задавайте вопросы в обсуждениях и не ленитесь читать уже заданные вопросы — возможно там уже есть для вас ответ или подсказка 🙂


Что такое пакеты?

Пакеты, по сути, являются файловой и логической структурой связей классов в мире java. Очень схоже с файловой системой компьютера. На уровне файловой системы пакеты это и есть папки, в которых лежат другие папки (подпакеты) и классы. Но пакеты не всегда описывают напрямую всю структуру проекта. На практике проект включает в себя различные ресурсы, а структура папок, которую мы назначаем как имена пакетов для наших классов — может быть лишь небольшой частью целого проекта. Ведь, кроме основного кода в пакетах, у нас должны быть еще и тесты, библиотеки или даже другие языки программирования в проекте в целом.

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

Как аналогию, можно привести пример с адресами.

Представим себя в роли некого класса, который выполняет некие функции для этого мира. Для того чтобы этот мир к нам обратился — нам нужно иметь конкретный адрес, путь по которому можно будет взаимодействовать с нами. Пускай это будет адрес, например:

package   страна.область.город.район.улица.дом.имяЧеловека
         корневой_пакет.подпакет.подпакет.подпакет.имяКласса
Что такое пакет для класса

Для класса его пакет — это его местоположение в проекте, относительно других классов. Благодаря разделению классов на несколько пакетов — мы организовываем структуру программы.

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

  • отсутствие модификатора перед методом или полем (еще говорят package-private) — означает, что данный член класса будет виден другим классам, но только из этого же пакета;
  • protected перед методом или полем — означает, что данный член класса будет виден не только классам текущего пакета, как с package-private, но и классам-наследникам.
Как создать класс внутри пакета?

По сути нам нужно:

  • создать текстовый файл с расширением .java в нужной папке;
  • в самом файле, помимо класса, написать имя его пакета.

Рассмотрим этот процесс поэтапно.

Сначала пишем имя любимого редактора в терминале, потом существующий путь, а потом имя будущего текстового файла. Пример для редактора nano:

UserName BASH ~/projectName/src
$ nano -f /io/hexlet/xo/view/ConsoleView.java

Или с помощью sublime:

UserName BASH ~/projectName/src
$ subl /io/hexlet/xo/view/ConsoleView.java

Если команда subl не найдена и Вы уверены в том, что sublime установлен — проверьте, в переменных среды окружения, наличие прописанного пути к папке, в которой лежит subl.

Можно и обычным блокнотом создать нужный файл в нужной директории. Создать сам файл можно и любым другим удобным для вас способом.

Файл создан. Но класса в нем нет. Создадим класс:

public class ConsoleView {
    //some field & methods
}

Теперь у нас есть и файл в нужной папке, и класс в файле. Но сам класс ничего не знает про то, что он принадлежит некому пакету. Исправим это:

package io.hexlet.xo.view;

public class ConsoleView {
    //some field & methods
}

Не забываем сохранять файл!

Ключевые моменты верного создания класса внутри пакета:

  • внутри класса должно использоваться ключевое слово package;
  • ключевое слово package должно быть в первой строке кода, перед импортами и объявлением самого класса;
  • после package нужно указать полное имя пакета, с корня пакета до пакета(папки) в которой размещен класс;
  • каждая отдельная папка, в полном имени пакета, отделяется точкой;
  • имя самого класса не входит в имя объявляемого пакета;
  • реальное расположение файла и полное имя пакета, после слова package, — должны соответствовать друг другу.
Корень пакетов

А как же задать корневой каталог (папку) как основу пакетов, в котором уже и происходит ветвление этих всех под-пакетов (под-папок)? Почему, например, папка io является корнем для классов проекта, а папка src — не является пакетом, да и вообще не входит в пакетную структуру проекта?

Все очень просто: корневым пакетом считается тот который первым прописан в каждом java-файле после слова package, в текущем проекте. А в самом проекте помимо папки src, на ее уровне и выше, — могут быть много различных папок и файлов, для работы с проектом в целом. Но это не делает их корневым пакетом, или вообще частью пакетов java, в этом проекте, если они не включены в имена пакетов в классах, после ключевого слова package. Пример структуры папок и пакетов:

-/projectName // Папка проекта. Может содержать кучу всякой всячины. 
            README.md // файл с описанием. В пакет никак не входит, но входит в проект.
            +/out // Папка для скомпилированных файлов *.class    
            -/src // Папка для исходных файлов *.java
                -/io // корень пакета
                    StartClass.java // package io;
                    -/hexlet
                        OneMoreClass.java // package io.hexlet;
                        -/xo // в этой папке может и не быть классов
                            -/controllers
                                ControllerOne.java // package io.hexlet.xo.controllers;
                                Controller2.java   // package io.hexlet.xo.controllers;  
                            -/model
                                ModelClaas1.java  // package io.hexlet.xo.model;
                                ModelClass2.java  // package io.hexlet.xo.model;

Как создать свою первую программу на Java: 10 шагов

1. Откройте только что созданный текстовый документ.
2. Внутри вашего типа файла «class MyFirstProgram {»
Не забывайте фигурную скобку, потому что она сообщает компьютеру, где находится суть вашей программы.
3. Дважды нажмите ввод, чтобы создать новые строки, а затем введите «}», это сообщит компьютеру, что все, что составляет эту программу, было введено.
4. На этом этапе ваша программа должна выглядеть, как на прилагаемом рисунке для этого шага.

Понимание кода:
На этом этапе мы можем фактически сгенерировать программу. Единственная проблема в том, что он ничего не сделает. Фактически, если вы попытались запустить программу, появится сообщение об ошибке «Ошибка: основной метод не найден в классе MyFirstProgram, определите метод как:», а затем покажет конкретную строку кода. Мы напишем эту строку кода на следующем шаге, поскольку это важная часть программы, которую нужно понять.

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

Каждая программа на Java состоит из классов и методов. Классы, более известные как объекты, дают нам возможность организовать наш код. Классы хранят информацию и инструкции, наша программа будет одним классом с одной инструкцией или методом. Легко представить себе, что классы — это целая клавиатура, а методы — это отдельные клавиши на клавиатуре. Сейчас наша программа — это просто пустой класс (клавиатура без клавиш).Мы знаем это, и, что более важно, компилятор знает это, потому что первое введенное нами слово говорит «класс».

После прочтения слова «класс» синтаксис Java требует указать имя программы (метку на ключе), в этом случае мы назовем нашу программу «MyFirstProgram». Мы назовем его так, потому что он описывает нашу программу: наша первая! Важно отметить, что большинство языков программирования не допускают пробелов в именах вещей. Это связано с тем, что использование пустого пространства в коде помогает компилятору понять, что происходит.

Компилятор, читая имя нашего класса, ожидает, что мы покажем какой-то способ обозначения, какая часть нашего файла составляет сам класс, для этого мы используем фигурные скобки («{» «}»), чтобы обозначить, где он начинается («{«) и где он заканчивается («}»). Поскольку наш файл делает это, когда мы передаем его через компилятор, компилятор создаст программу, но, поскольку у нашего класса нет методов для использования (клавиш для нажатия), будет произведена ошибка.

Создание вашей первой программы на Java

Это руководство знакомит с основами создания очень простой программы на Java.Изучение нового языка программирования традиционно начинается с программы под названием «Hello World». Все, что делает программа, это пишет текст «Hello World!». в окно команды или оболочки.

Основные шаги для создания программы Hello World: напишите программу на Java, скомпилируйте исходный код и запустите программу.

Напишите исходный код Java

Снимки экрана продукта Microsoft перепечатаны с разрешения Microsoft Corporation.

Все программы на Java написаны в виде обычного текста, поэтому вам не нужно никакого специального программного обеспечения.Для вашей первой программы откройте самый простой текстовый редактор, который есть на вашем компьютере, например, Блокнот.

Вся программа выглядит так:

Хотя вы можете вырезать и вставить приведенный выше код в свой текстовый редактор, лучше выработать привычку вводить его. Это поможет вам быстрее изучать Java, потому что вы почувствуете, как написаны программы, и, что самое главное, , вы будете ошибаться! Это может показаться странным, но каждая допущенная вами ошибка в конечном итоге помогает вам стать лучшим программистом.Просто помните, что ваш программный код должен соответствовать образцу кода, и все будет в порядке.

Обратите внимание на строки с « // » выше. Это комментарии в Java, и компилятор их игнорирует.

  1. Строка // 1 — это комментарий, представляющий эту программу.
  2. Line // 2 создает класс HelloWorld. Весь код должен быть в классе, чтобы механизм выполнения Java мог его запустить. Обратите внимание, что весь класс определяется в фигурных скобках (в строке / 2 и строке // 6).
  3. Строка // 3 — это метод main () , который всегда является точкой входа в программу Java. Он также определяется в фигурных скобках (в строке // 3 и // 5 строке). Давайте разберем его:
    общедоступный : этот метод общедоступен и, следовательно, доступен для всех.
    static : этот метод можно запустить без создания экземпляра класса HelloWorld.
    void : этот метод ничего не возвращает.
    (String [] args) : этот метод принимает аргумент String.
  4. Строка // 4 записывает в консоль «Hello World».

Сохраните файл

Снимки экрана продукта Microsoft перепечатаны с разрешения Microsoft Corporation.

Сохраните файл программы как «HelloWorld.java». Вы можете подумать о создании каталога на вашем компьютере только для ваших программ Java.

Очень важно сохранить текстовый файл как «HelloWorld.java». Java придирчиво относится к именам файлов. В коде есть это утверждение:

Это инструкция для вызова класса «HelloWorld».Имя файла должно соответствовать имени этого класса, отсюда и название «HelloWorld.java». Расширение «.java» сообщает компьютеру, что это файл кода Java.

Открыть окно терминала

Снимки экрана продукта Microsoft перепечатаны с разрешения Microsoft Corporation.

Большинство программ, которые вы запускаете на своем компьютере, являются оконными приложениями; они работают внутри окна, которое можно перемещать на рабочем столе. Программа HelloWorld является примером программы консоли .Он не запускается в собственном окне; вместо этого он должен запускаться через окно терминала. Окно терминала — это еще один способ запуска программ.

Чтобы открыть окно терминала, нажмите клавишу «Windows» и букву «R».

Вы увидите диалоговое окно «Выполнить». Введите «cmd», чтобы открыть командное окно, и нажмите «ОК».

На вашем экране откроется окно терминала. Думайте об этом как о текстовой версии проводника Windows; это позволит вам переходить в разные каталоги на вашем компьютере, просматривать файлы, которые они содержат, и запускать программы.Все это делается путем ввода команд в окно.

Компилятор Java

Снимки экрана продукта Microsoft перепечатаны с разрешения Microsoft Corporation.

Другой пример консольной программы — компилятор Java под названием «javac». Это программа, которая прочитает код из файла HelloWorld.java и переведет его на язык, понятный вашему компьютеру. Этот процесс называется компиляцией. Каждую программу Java, которую вы пишете, необходимо будет скомпилировать перед запуском.

Чтобы запустить javac из окна терминала, вам сначала нужно указать вашему компьютеру, где он находится. Например, это может быть каталог с именем «C: \ Program Files \ Java \ jdk \ 1.6.0_06 \ bin». Если у вас нет этого каталога, выполните поиск файла в проводнике Windows по запросу «javac», чтобы узнать, где он находится.

Как только вы найдете его местоположение, введите следующую команду в окне терминала:

Например.,

Нажмите Ввод. Окно терминала просто вернется в командную строку.Однако теперь путь к компилятору установлен.

Изменить каталог

Снимки экрана продукта Microsoft перепечатаны с разрешения Microsoft Corporation.

Затем перейдите в папку, в которой сохранен файл HelloWorld.java.

Чтобы изменить каталог в окне терминала, введите команду:

Например.,

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

Скомпилируйте свою программу

Снимки экрана продукта Microsoft перепечатаны с разрешения Microsoft Corporation.

Теперь мы готовы скомпилировать программу. Для этого введите команду:

Нажмите Ввод. Компилятор просмотрит код, содержащийся в файле HelloWorld.java, и попытается его скомпилировать. Если это не так, он отобразит серию ошибок, которые помогут вам исправить код.

Надеюсь, у вас не должно быть ошибок. Если да, вернитесь и проверьте написанный код. Убедитесь, что он соответствует образцу кода, и повторно сохраните файл.

Совет: После успешной компиляции вашей программы HelloWorld вы увидите новый файл в том же каталоге.Он будет называться «HelloWorld.class». Это скомпилированная версия вашей программы.

Запустите программу

Снимки экрана продукта Microsoft перепечатаны с разрешения Microsoft Corporation.

Осталось только запустить программу. В окне терминала введите команду:

Когда вы нажимаете Enter, программа запускается, и вы видите «Hello World!» написано в окно терминала.

Отличная работа. Вы написали свою первую программу на Java!

Создайте свое первое приложение Java

В этом руководстве вы узнаете, как создать, запустить и упаковать простое приложение Java, которое печатает Hello, World! на системный выход.Попутно вы познакомитесь с функциями IntelliJ IDEA для повышения вашей продуктивности как разработчика: помощь в кодировании и дополнительные инструменты.

Посмотрите видеоролик и следуйте пошаговым инструкциям ниже:

Подготовьте проект

Создайте новый проект Java

В IntelliJ IDEA проект помогает организовать исходный код, тесты и библиотеки, которые вы используете, инструкции по сборке и ваши личные настройки в одном устройстве.

  1. Запустите IntelliJ IDEA.

    Если откроется экран приветствия, щелкните «Новый проект».

    В противном случае в главном меню выберите.

  2. В мастере создания проекта выберите Java из списка слева.

  3. Для разработки приложений Java в IntelliJ IDEA необходим Java SDK (JDK).

    Если необходимый JDK уже определен в IntelliJ IDEA, выберите его из списка Project SDK.

    Если JDK установлен на вашем компьютере, но не определен в среде IDE, выберите и укажите путь к домашнему каталогу JDK (например, / Library / Java / JavaVirtualMachines / jdk-13.0.1.jdk).

    Если на вашем компьютере нет необходимого JDK, выберите. В следующем диалоговом окне укажите поставщика JDK (например, OpenJDK), версию, при необходимости измените путь установки и нажмите «Загрузить».

  4. Мы не собираемся использовать какие-либо дополнительные библиотеки или фреймворки для этого руководства, поэтому нажмите «Далее».

  5. Не создавайте проект на основе шаблона. В этом уроке мы собираемся сделать все с нуля, поэтому нажмите «Далее».

  6. Назовите проект, например: HelloWorld .

  7. При необходимости измените местоположение проекта по умолчанию и нажмите Готово.

Создание пакета и класса

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

  1. В окне инструмента «Проект» выберите папку src, нажмите Alt + Insert и выберите Java Class.

  2. В поле Имя введите com.example.helloworld.HelloWorld и нажмите ОК.

    IntelliJ IDEA создает пакет com.example.helloworld и класс HelloWorld .

Вместе с файлом IntelliJ IDEA автоматически сгенерировала некоторое содержимое для вашего класса. В этом случае IDE вставила оператор пакета и объявление класса.

Это делается с помощью файловых шаблонов. В зависимости от типа создаваемого файла среда IDE вставляет исходный код и форматирование, которые, как ожидается, будут присутствовать во всех файлах этого типа.Для получения дополнительной информации о том, как использовать и настраивать шаблоны, см. Шаблоны файлов.

Окно инструмента «Проект» Alt + 1 отображает структуру вашего приложения и помогает просматривать проект.

В Java существует соглашение об именах, которому вы должны следовать при именовании пакетов и классов.

Напишите код

Добавьте метод main (), используя живые шаблоны

  1. Поместите курсор в строку объявления класса после открывающей скобки { и нажмите Shift + Enter .

    В отличие от Enter , Shift + Enter начинает новую строку, не прерывая текущую.

  2. Введите main и выберите шаблон, который вставляет объявление метода main () .

    По мере ввода IntelliJ IDEA предлагает различные конструкции, которые можно использовать в текущем контексте. Вы можете увидеть список доступных живых шаблонов, используя Ctrl + J .

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

Для получения дополнительной информации о том, где найти предопределенные живые шаблоны и как создать свои собственные, см. Живые шаблоны.

Вы также можете добавить выписку, используя шаблон sout live.

Вызов метода println () с использованием автозавершения кода

После объявления метода main () IntelliJ IDEA автоматически помещает курсор в следующую строку.Давайте вызовем метод, который выводит текст на стандартный системный вывод.

  1. Введите Sy и выберите класс System из списка предложений завершения кода (он из стандартного пакета java.lang ).

    Нажмите Ctrl +. , чтобы вставить выделение через запятую.

  2. Введите o , выберите из и нажмите Ctrl +. снова.

  3. Введите p , выберите метод println (String x) и нажмите Введите .

    IntelliJ IDEA показывает типы параметров, которые можно использовать в текущем контексте. Эта информация предназначена для вашего ознакомления.

  4. Тип ". Вторая кавычка вставляется автоматически, а курсор помещается между кавычками. Тип Hello, World!

Базовое завершение кода анализирует контекст вокруг текущей позиции курсора и предлагает варианты по мере ввода. Вы можете открыть список завершения вручную, нажав Ctrl + Пробел .

Для получения информации о различных режимах завершения см. Завершение кода.

Создайте и запустите приложение

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

  1. Щелкните в желобе и выберите «Выполнить HelloWorld.main ()» во всплывающем окне. IDE начинает компилировать ваш код.

  2. По завершении компиляции в нижней части экрана откроется окно инструмента «Выполнить».

    В первой строке показана команда, которую IntelliJ IDEA использовала для запуска скомпилированного класса. Вторая строка показывает вывод программы: Hello, World! . И последняя строка показывает код выхода 0 , который указывает, что он успешно завершился.

    Если ваш код неверен, и IDE не может его скомпилировать, в окне инструмента «Выполнить» отобразится соответствующий код выхода.

При нажатии кнопки «Выполнить» IntelliJ IDEA создает специальную конфигурацию запуска, которая выполняет ряд действий.Во-первых, он создает ваше приложение. На этом этапе javac компилирует ваш исходный код в байт-код JVM.

После завершения компиляции javac помещает скомпилированный байт-код в выходной каталог, который выделяется желтым цветом в окне инструмента «Проект».

После этого JVM запускает байт-код.

Автоматически созданные конфигурации запуска являются временными, но вы можете изменять и сохранять их.

Если вы хотите снова открыть окно инструмента «Выполнить», нажмите Alt + 4 .

IntelliJ IDEA автоматически анализирует файл, который в данный момент открыт в редакторе, и ищет различные типы проблем: от синтаксических ошибок до опечаток. Виджет Inspections в правом верхнем углу редактора позволяет быстро увидеть все обнаруженные проблемы и подробно рассмотреть каждую проблему. Для получения дополнительной информации см. Текущий файл.

Упакуйте приложение в JAR

Когда код будет готов, вы можете упаковать свое приложение в архив Java (JAR), чтобы вы могли поделиться им с другими разработчиками.Созданный архив Java называется артефактом.

Создайте конфигурацию артефакта для JAR

  1. В главном меню выберите File | Структура проекта Ctrl + Alt + Shift + S и щелкните Артефакты.

  2. Щелкните, укажите на JAR и выберите Из модулей с зависимостями.

  3. Справа от поля Main Class щелкните и выберите HelloWorld (com.example.helloworld) в открывшемся диалоговом окне.

    IntelliJ IDEA создает конфигурацию артефакта и отображает ее настройки в правой части диалогового окна «Структура проекта».

  4. Примените изменения и закройте диалоговое окно.

Создайте артефакт JAR

  1. В главном меню выберите Build | Стройте артефакты.

  2. Укажите HelloWorld: jar и выберите «Построить».

    Если вы теперь посмотрите папку out / artifacts, вы найдете там свой JAR.

Запустить упакованное приложение

Чтобы убедиться, что артефакт JAR создан правильно, вы можете запустить его.

Используйте действие «Найти» Ctrl + Shift + A для поиска действий и настроек во всей среде IDE.

Создание конфигурации запуска для упакованного приложения

Для запуска приложения Java, упакованного в JAR, IntelliJ IDEA позволяет создать специальную конфигурацию запуска.

  1. Нажмите Ctrl + Shift + A , найдите и запустите действие «Изменить конфигурации».

  2. В диалоговом окне «Запуск / отладка конфигураций» щелкните и выберите «Приложение JAR».

  3. Назовите новую конфигурацию: HelloWorldJar .

  4. В поле Путь к JAR щелкните и укажите путь к файлу JAR на вашем компьютере.

  5. В разделе «Перед запуском» щелкните, выберите в открывшемся диалоговом окне.

    Это означает, что HelloWorld.jar создается автоматически каждый раз, когда вы выполняете эту конфигурацию запуска.

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

Выполнить конфигурацию запуска

  • На панели инструментов выберите конфигурацию HelloWorldJar и щелкните справа от селектора конфигурации запуска.Или нажмите Shift + F10 , если вы предпочитаете сочетания клавиш.

    Как и раньше, открывается окно инструмента «Выполнить», в котором отображаются выходные данные приложения.

Процесс успешно завершен, это означает, что приложение упаковано правильно.

Последнее изменение: 26 апреля 2021 г.

Начало работы с Java в Visual Studio Code

В этом руководстве показано, как написать и запустить программу Hello World на Java с помощью Visual Studio Code.Он также охватывает несколько дополнительных функций, которые вы можете изучить, прочитав другие документы в этом разделе.

Для обзора функций, доступных для Java в VS Code, см. Обзор языка Java

Если вы столкнетесь с какими-либо проблемами, следуя этому руководству, вы можете связаться с нами, нажав кнопку Сообщить о проблеме ниже.

Сообщить о проблеме

Настройка VS Code для разработки на Java

Пакет кодирования

для Java

Чтобы помочь вам быстро настроить, вы можете установить пакет кодирования для Java , который включает VS Code, Java Development Kit (JDK) и основные расширения Java.Пакет Coding Pack можно использовать как чистую установку, а также для обновления или исправления существующей среды разработки.

Установите пакет кодирования для Java — Windows

Установите пакет кодирования для Java — macOS

Примечание : Пакет Coding Pack для Java доступен только для Windows и macOS. Для других операционных систем вам потребуется вручную установить расширения JDK, VS Code и Java.

Установка расширений

Если вы уже являетесь пользователем VS Code, вы также можете добавить поддержку Java, установив Java Extension Pack, который включает следующие расширения:

Установите пакет расширений Java

Пакет расширений Java содержит руководство по быстрому запуску и советы по редактированию и отладке кода.Здесь также есть FAQ, в котором есть ответы на некоторые часто задаваемые вопросы. Используйте команду Java: Начало работы из палитры команд (⇧⌘P (Windows, Linux Ctrl + Shift + P)), чтобы запустить руководство.

Вы также можете установить расширения отдельно. В помощь вам предоставляется Extension Guide . Вы можете запустить руководство с помощью команды Java: Extension Guide .

Для этого руководства требуются только расширения:

Настройки для JDK

Поддерживаемые версии Java

Поддерживаемая версия для запуска расширения VS Code for Java и поддерживаемая версия для ваших проектов — это две отдельные среды выполнения.Для запуска VS Code для Java требуется Java SE 11 или более поздняя версия; для проектов VS Code for Java поддерживает проекты с версией 1.5 или выше. Дополнительные сведения см. В разделе Настройка JDK.

Использование мастера настройки среды выполнения Java

Чтобы помочь вам правильно настроить, мы предоставляем мастер настройки во время выполнения. Вы можете запустить мастер, открыв палитру команд (⇧⌘P (Windows, Linux Ctrl + Shift + P)) и набрав команду Java: Configure Java Runtime , которая отобразит пользовательский интерфейс конфигурации ниже.

Примечание : Чтобы настроить несколько JDK, см. Настройка JDK. Чтобы включить функции предварительного просмотра Java, см. Как я могу использовать VS Code с новыми версиями Java

.

Использование настроек VS Code

Кроме того, вы можете настроить параметры JDK с помощью редактора VS Code Settings. Обычный способ сделать это — установить в качестве значения системной переменной среды JAVA_HOME место установки JDK, например C: \ Program Files \ Java \ jdk-13.0,2 . Или, если вы хотите настроить только VS Code для использования JDK, используйте параметр java.home в настройках пользователя или рабочей области VS Code.

Установка Java Development Kit (JDK)

Если вам нужно установить JDK, мы рекомендуем рассмотреть возможность установки из одного из следующих источников:

Создание файла исходного кода

Создайте папку для вашей программы Java и откройте папку с VS Code. Затем в VS Code создайте новый файл и сохраните его с именем Hello.java . Когда вы открываете этот файл, Java Language Server автоматически начинает загрузку, и вы должны увидеть значок загрузки в правой части строки состояния. После завершения загрузки вы увидите значок с изображением большого пальца вверх.

Примечание : Если вы откроете файл Java в VS Code, не открывая его папку, Java Language Server может работать некорректно.

VS Code также попытается определить правильный пакет для нового типа и заполнить новый файл из шаблона.См. Создание нового файла.

Вы также можете создать проект Java с помощью команды Java: Create Java Project . Откройте палитру команд (⇧⌘P (Windows, Linux Ctrl + Shift + P)), а затем введите java для поиска этой команды. После выбора команды вам будет предложено указать местоположение и имя проекта. Вы также можете выбрать свой инструмент сборки с помощью этой команды.

Visual Studio Code также поддерживает более сложные проекты Java, см. Управление проектами.

Редактирование исходного кода

Вы можете использовать фрагменты кода для создания шаблонов для ваших классов и методов. VS Code также предоставляет IntelliSense для завершения кода и различные методы рефакторинга.

Чтобы узнать больше о редактировании Java, см. Редактирование Java.

Запуск и отладка вашей программы

Для запуска и отладки кода Java установите точку останова, затем нажмите F5 на клавиатуре или используйте пункт меню Run > Start Debugging . Вы также можете использовать параметры Run | Debug CodeLens в редакторе.После компиляции кода вы можете увидеть все свои переменные и потоки в представлении «Выполнить».

Отладчик также поддерживает расширенные функции, такие как замена Hot Code и условные точки останова.

Для получения дополнительной информации см. Отладка Java.

Дополнительные возможности

Редактор также имеет гораздо больше возможностей для вашей рабочей нагрузки Java.

14.04.2021

Java и Makefiles

Java и Makefiles

Да, вы можете писать и использовать make-файлы для создания приложений Java.Если вы никогда не использовали Makefile, сначала прочтите
Документация по основам Makefile.

Вот более сложный пример Makefile для Java-программы.
(труднее читать, но в этой форме легче использовать и изменять):


JFLAGS = -g
JC = javac
. СУФФИКСЫ: .java .class
.java.class:
        $ (JC) $ (JFLAGS) $ *. Java

КЛАССЫ = \
        Foo.java \
        Blah.java \
        Library.java \
        Main.java

по умолчанию: классы

классы: $ (КЛАССЫ: .java = .class)

чистый:
        $ (RM) *.класс
 
Чтобы использовать вышеуказанный make-файл для компиляции ваших Java-программ:
  1. создайте файл с именем «makefile» в своем домашнем каталоге с
    идентичное содержание
  2. модифицирует макрос CLASSES так, чтобы он имел
    имена ваших файлов .java ;
  3. запустите make, и если все пойдет хорошо, он должен скомпилировать всю вашу java
    исходные файлы, которые необходимо перестроить.

Вот тот же make-файл с комментариями, объясняющими каждую строку:


#
# определить компилятор и переменные флага компилятора
#

JFLAGS = -g
JC = javac


#
# Очистить все цели по умолчанию для строительства.файлы классов из файлов .java; мы
# предоставит нашу собственную целевую запись для этого в make-файле.
# make имеет набор целей по умолчанию для разных суффиксов (например, .c.o)
# В настоящее время очищать значение по умолчанию для .java.class не требуется, поскольку
# make не имеет определения для этой цели, но более поздние версии
# make may, поэтому не помешает очистить все значения по умолчанию
# определения для этих
#

. СУФФИКСЫ: .java .class


#
# Вот наша целевая запись для создания файлов .class из.файлы java
# Это целевая запись, использующая синтаксис суффиксного правила:
# DSTS:
# правило
# 'TS' - суффикс целевого файла, 'DS' - суффикс зависимости
# файл, а 'rule' - это правило для создания цели
# '$ *' - это встроенный макрос, который получает базовое имя текущей цели
# Помните, что перед командной строкой должен быть & lt tab & gt ('правило')
#

.java.class:
        $ (JC) $ (JFLAGS) $ *. Java


#
# CLASSES - это макрос, состоящий из 4 слов (по одному для каждого исходного файла java)
#

КЛАССЫ = \
        Фу.Ява \
        Blah.java \
        Library.java \
        Main.java


#
# по умолчанию сделать целевую запись
#

по умолчанию: классы


#
# Эта целевая запись использует замену суффикса в макросе:
# $ (имя: строка1 = строка2)
# В словах макроса с именем 'name' замените 'string1' на 'string2'
# Ниже мы заменяем суффикс .java всех слов в макросе CLASSES
# с суффиксом .class
#

классы: $ (КЛАССЫ: .java = .class)


#
# RM - это предопределенный макрос в make (RM = rm -f)
#

чистый:
        $ (RM) *.класс
 

Создание исполняемого файла jar

Создание исполняемого файла JAR

В Java обычно объединяют несколько
классы в одном файле .jar («java-архив»).
Так хранятся классы библиотеки.
В более крупных проектах используются файлы jar.
Вы также можете создать свой собственный файл jar, объединяющий несколько классов.

jar-файлов создаются с помощью служебной программы jar.exe из
JDK.
Вы можете сделать свой jar-файл работающим, указав jar.exe , который
class имеет основной .
Для этого вам необходимо создать файл манифеста.
Манифест — это однострочный текстовый файл с директивой «Main-Class».
Например:

 Главный класс: Крэпс 

Эта строка должна заканчиваться новой строкой.

Файл jar, созданный с помощью манифеста основного класса, может использоваться как
как библиотека и работающая банка.
Если вы используете его как библиотеку, вы можете редактировать и компилировать
любой из классов, включенных в jar, и добавьте его в
ваш проект.
Затем он заменит тот, который находится в файле jar.

Вы можете создать файл манифеста в любом текстовом редакторе,
или даже с помощью команды MS-DOS echo .
Вы можете дать своему файлу манифеста любое имя, но лучше
использовать что-то стандартное, например manifest.txt .

Когда у вас есть манифест и все ваши классы
были скомпилированы, вам необходимо запустить утилиту JDK jar.exe .
Находится в папке JDKs bin , там же
где javac.exe и java.exe .
jar.exe принимает аргументы командной строки;
если вы запустите его без аргументов, он будет
отображать информацию об использовании и примеры.
Тебе нужно

 C \ mywork> jar cvfm MyJarName.jar manifest.txt * .class 

cvfm означает « c reate a jar;
показать вывод v erbose;
укажите выходной jar f имя файла;
укажите имя файла anifest m «.
За ним следует имя, которое вы хотите дать своему файлу jar,
имя вашего файла манифеста и список
файлов .class
что вы хотите включить в банку.
* .class означает все файлы классов в текущем каталоге.

На самом деле, если ваш манифест содержит только директиву Main-Class,
вы можете указать основной класс непосредственно в файле jar.exe
в командной строке, используя переключатель e вместо m .
Тогда вам не нужен отдельный файл манифеста; банка будет
добавьте требуемый манифест в свой файл jar за вас.
Например:

 C \ mywork> jar cvfe MyJarName.jar MyMainClass * .class 

Ниже приведена ссылка на создание файла jar в Eclipse .
и подробные инструкции по выполнению этого
в командной строке и в JCreator .

Создание файла jar в

Eclipse

В содержимом справки Eclipse разверните «Руководство пользователя по разработке Java» ==>
«Задачи» ==> «Создание файлов JAR».
Следуйте инструкциям для «Создание нового файла JAR».
или «Создание нового исполняемого файла JAR».

Файл JAR и Запускаемый файл JAR команды
по какой-то причине находятся в меню Файл :
щелкните Export ... и разверните узел Java .

Создание файла jar в

JCreator

Вы можете настроить «инструмент», который автоматизирует процесс создания банки.
Вам нужно сделать это только один раз.

  1. Щелкните Configure / Options .
  2. Нажмите Инструменты в левом столбце.
  3. Щелкните New и выберите Create Jar file .
  4. Щелкните по вновь созданной записи
    Создать файл Jar
    в левом столбце под Инструменты .
  5. Измените среднюю строку с меткой Аргументы:
    он должен иметь

     cvfm $ [PrjName] .jar manifest.txt * .class 
  6. Нажмите ОК.

Теперь создайте проект для своей программы,
создать файл манифеста manifest.txt или скопировать
и отредактируйте существующий.
Поместите manifest.txt в ту же папку
куда идут файлы .class .
Под Вид / Панели инструментов
проверьте панель инструментов Tools .
Щелкните соответствующую кнопку инструмента или нажмите Ctrl-1
(или Ctrl- n , если это n -й инструмент)
для запуска инструмента Create Jar & nbspFile .

В Windows Explorer перейдите к файлу jar
который вы только что создали, и дважды щелкните по нему, чтобы запустить.

Создание файла jar в командной строке

  1. Запустить Командная строка .
  2. Перейдите в папку, в которой хранятся файлы классов:
     C: \> cd \ mywork 
  3. Установить путь для включения корзины JDK.
    Например:

     C: \ mywork> путь c: \ Program Files \ Java \ jdk1.7.0_25 \ bin;% путь% 
  4. Скомпилируйте свой класс (ы):
     C: \ mywork> javac *.Java 
  5. Создайте файл манифеста и свой файл jar:
     C: \ mywork> echo Main-Class: Craps> manifest.txt 
     C: \ mywork> jar cvfm Craps.jar manifest.txt * .class 

    или же

     C: \ mywork> jar cvfe Craps.jar Craps * .class 
  6. Проверьте свою банку:
     C: \ mywork> Craps.jar 

    или же

     C: \ mywork> java -jar Craps.jar 

Начало работы | Создание проектов Java с помощью Maven

Maven теперь готов к сборке проекта.Теперь вы можете выполнить несколько целей жизненного цикла сборки с помощью Maven, включая цели по компиляции кода проекта, созданию пакета библиотеки (например, файла JAR) и установке библиотеки в локальном репозитории зависимостей Maven.

Чтобы опробовать сборку, введите в командной строке следующее:

Это запустит Maven, сообщив ему выполнить цель компиляции . По завершении вы должны найти скомпилированные файлы .class в каталоге target / classes .

Поскольку маловероятно, что вы захотите напрямую распространять или работать с файлами .class , вы, вероятно, захотите вместо этого выполнить цель пакета :

Пакет Цель скомпилирует ваш Java-код, запустит все тесты и завершит упаковкой кода в файл JAR в целевом каталоге . Имя файла JAR будет основано на и проекта. Например, с учетом минимальных пом.xml из предыдущего файла JAR будет называться gs-maven-0.1.0.jar .

Для выполнения файла JAR запустите:

 java -jar цель / gs-maven-0.1.0.jar 
Если вы изменили значение с «jar» на «war», результатом будет файл WAR в каталоге target вместо файла JAR.

Maven также поддерживает репозиторий зависимостей на вашем локальном компьютере (обычно это .m2 / repository в вашем домашнем каталоге) для быстрого доступа к зависимостям проекта. Если вы хотите установить файл JAR вашего проекта в этот локальный репозиторий, вы должны вызвать цель установить :

Цель install скомпилирует, протестирует и упакует код вашего проекта, а затем скопирует его в локальный репозиторий зависимостей, чтобы другой проект мог ссылаться на него как на зависимость.

Говоря о зависимостях, теперь пора объявить зависимости в сборке Maven.

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

2024 © Все права защищены. Карта сайта