.JAR qui s'ouvre avec WinRAR

[Résolu/Fermé]
Signaler
-
 DarkSpectrum -
Bonjour,


Je ne suis absolument pas un pro en java...

Grace à un tuto ( https://openclassrooms.com/fr/courses ) j'ai réussi à faire le code pour la calculatrice. Mais quand je veux l'enregistrer en .jar (comme dans le tuto) je me retrouve avec plein de .class dans un fichier winrar.

Le code est:

public class Main { (J'ai laissé Main plutot que le nom de mon fichier sinon il met deserreurs)
public static void main(String[] args) {
Calculatrice calculette = new Calculatrice();
}
}
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Calculatrice extends JFrame {
private JPanel container = new JPanel();
//Tableau stockant les éléments à afficher dans la calculatrice
String[] tab_string = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "0", ".", "=", "C", "+", "-", "*", "/"};
//Un bouton par élément à afficher
JButton[] tab_button = new JButton[tab_string.length];
private JLabel ecran = new JLabel();
private Dimension dim = new Dimension(50, 40);
private Dimension dim2 = new Dimension(50, 31);
private double chiffre1;
private boolean clicOperateur = false, update = false;
private String operateur = "";

public Calculatrice(){
this.setSize(240, 260);
this.setTitle("Calculette");
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
this.setResizable(false);
//On initialise le conteneur avec tous les composants
initComposant();
//On ajoute le conteneur
this.setContentPane(container);
this.setVisible(true);
}

private void initComposant(){
//On définit la police d'écriture à utiliser
Font police = new Font("Arial", Font.BOLD, 20);
ecran = new JLabel("0");
ecran.setFont(police);
//On aligne les informations à droite dans le JLabel
ecran.setHorizontalAlignment(JLabel.RIGHT);
ecran.setPreferredSize(new Dimension(220, 20));
JPanel operateur = new JPanel();
operateur.setPreferredSize(new Dimension(55, 225));
JPanel chiffre = new JPanel();
chiffre.setPreferredSize(new Dimension(165, 225));
JPanel panEcran = new JPanel();
panEcran.setPreferredSize(new Dimension(220, 30));

//On parcourt le tableau initialisé
//afin de créer nos boutons
for(int i = 0; i < tab_string.length; i++){
tab_button[i] = new JButton(tab_string[i]);
tab_button[i].setPreferredSize(dim);
switch(i){
//Pour chaque élément situé à la fin du tableau
//et qui n'est pas un chiffre
//on définit le comportement à avoir grâce à un listener
case 11 :
tab_button[i].addActionListener(new EgalListener());
chiffre.add(tab_button[i]);
break;
case 12 :
tab_button[i].setForeground(Color.red);
tab_button[i].addActionListener(new ResetListener());
operateur.add(tab_button[i]);
break;
case 13 :
tab_button[i].addActionListener(new PlusListener());
tab_button[i].setPreferredSize(dim2);
operateur.add(tab_button[i]);
break;
case 14 :
tab_button[i].addActionListener(new MoinsListener());
tab_button[i].setPreferredSize(dim2);
operateur.add(tab_button[i]);
break;
case 15 :
tab_button[i].addActionListener(new MultiListener());
tab_button[i].setPreferredSize(dim2);
operateur.add(tab_button[i]);
break;
case 16 :
tab_button[i].addActionListener(new DivListener());
tab_button[i].setPreferredSize(dim2);
operateur.add(tab_button[i]);
break;
default :
//Par défaut, ce sont les premiers éléments du tableau
//donc des chiffres, on affecte alors le bon listener
chiffre.add(tab_button[i]);
tab_button[i].addActionListener(new ChiffreListener());
break;
}
}
panEcran.add(ecran);
panEcran.setBorder(BorderFactory.createLineBorder(Color.black));
container.add(panEcran, BorderLayout.NORTH);
container.add(chiffre, BorderLayout.CENTER);
container.add(operateur, BorderLayout.EAST);
}

//Méthode permettant d'effectuer un calcul selon l'opérateur sélectionné
private void calcul(){
if(operateur.equals("+")){
chiffre1 = chiffre1 +
Double.valueOf(ecran.getText()).doubleValue();
ecran.setText(String.valueOf(chiffre1));
}
if(operateur.equals("-")){
chiffre1 = chiffre1 -
Double.valueOf(ecran.getText()).doubleValue();
ecran.setText(String.valueOf(chiffre1));
}
if(operateur.equals("*")){
chiffre1 = chiffre1 *
Double.valueOf(ecran.getText()).doubleValue();
ecran.setText(String.valueOf(chiffre1));
}
if(operateur.equals("/")){
try{
chiffre1 = chiffre1 /
Double.valueOf(ecran.getText()).doubleValue();
ecran.setText(String.valueOf(chiffre1));
} catch(ArithmeticException e) {
ecran.setText("0");
}
}
}

//Listener utilisé pour les chiffres
//Permet de stocker les chiffres et de les afficher
class ChiffreListener implements ActionListener {
public void actionPerformed(ActionEvent e){
//On affiche le chiffre additionnel dans le label
String str = ((JButton)e.getSource()).getText();
if(update){
update = false;
}
else{
if(!ecran.getText().equals("0"))
str = ecran.getText() + str;
}
ecran.setText(str);
}
}

//Listener affecté au bouton =
class EgalListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
calcul();
update = true;
clicOperateur = false;
}
}

//Listener affecté au bouton +
class PlusListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
if(clicOperateur){
calcul();
ecran.setText(String.valueOf(chiffre1));
}
else{
chiffre1 = Double.valueOf(ecran.getText()).doubleValue();
clicOperateur = true;
}
operateur = "+";
update = true;
}
}

//Listener affecté au bouton -
class MoinsListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
if(clicOperateur){
calcul();
ecran.setText(String.valueOf(chiffre1));
}
else{
chiffre1 = Double.valueOf(ecran.getText()).doubleValue();
clicOperateur = true;
}
operateur = "-";
update = true;
}
}

//Listener affecté au bouton *
class MultiListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
if(clicOperateur){
calcul();
ecran.setText(String.valueOf(chiffre1));
}
else{
chiffre1 = Double.valueOf(ecran.getText()).doubleValue();
clicOperateur = true;
}
operateur = "*";
update = true;
}
}

//Listener affecté au bouton /
class DivListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
if(clicOperateur){
calcul();
ecran.setText(String.valueOf(chiffre1));
}
else{
chiffre1 = Double.valueOf(ecran.getText()).doubleValue();
clicOperateur = true;
}
operateur = "/";
update = true;
}
}

//Listener affecté au bouton de remise à zéro
class ResetListener implements ActionListener {
public void actionPerformed(ActionEvent arg0){
clicOperateur = false;
update = true;
chiffre1 = 0;
operateur = "";
ecran.setText("");
}
}
}


Donc si vous voyez un problème dans le code (je l'ai essayé en mettant Calculatrice (nom de mon fichier) à la place de main, en vain..)..
D'ailleurs, si je ne met pas "public class Main { " je ne peut pas choisir le "main class" à la fin (Toujours dans https://openclassrooms.com/fr/courses )..

Merci d'avance pour votre aide

9 réponses


Salut et merci pour ta réponse.

Non, ça ne marche pas, il me l'ouvre avec soit wordpad soit avec java qui ouvre cmd.exe et qui se ferme tout de suite.

Sinon, j'ai essayé de mettre .exe a la place du .class, il me dit que ma version windows n'est pas bonne (64bits) il me le fait avec toutes les calculatrices que j'essaye de faire...

chat
Utilisateur anonyme
Mes fichiers winrar se sont bien mis en fichiers java mais ils ne s'ouvrent pas... J'ai un truc pas bon dans le code?
Le problème ne vient pas de ton code, il contient une classe main donc c'est bon.
Moi quand j'exporte des jar à executer je sélectionne :
"Runnable JAR file " et non pas juste "jar file".
Ensuite tu renseigne les parties "launch configuration" et "export destination" et tu clique sur "Finish" et voilà.
Ok, j'essayerai ça tout a l'heure.

Et il est possible de le mettre en .exe pour que ça fasse comme un logiciel? Ou il faut utiliser un autre logiciel que celui pour les programmations java?
Re

Alors quand je veux l'enregistrer en runnable jar file, il faut choisir un "launch configuration" or quand j'en cherche un, je n'en ai aucun qui s'affiche... Il me met tout blanc. J'ai beau attendre, rien. Il faut en créer un?

ça fait ça: https://www.turbopix.fr/i/7Z18Pz6aYy.png
tu peux en créer un dans Run => Run configuration => dans Java Application clic droit New
Utilisateur anonyme
Il s'est bien mis en .jar, quand je double clic, ça charge mais après rien... Il ne s'ouvre pas...

J'ai ouvret calculette.jar avec winrar puis je suis allé dans META INF. Dedans j'ai le fichier manifest que j'ai ouvert avec le bloc notes. Contenu:

Manifest-Version: 1.0
Class-Path: .
Main-Class: Main


Remplacé par:

Manifest-Version: 1.0
Main-Class: Main

(Avec l'espace en dessous de la ligne main)
par contre j'ai pas compris la partie:

"2) en ligne de commandes, tu te déplaces jusqu'à ton fichier bin et tu tapes :

jar cmvf manifest.txt Calcultrice.jar *.class"
Messages postés
16372
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
23 juillet 2021
2 860
Ce que j'appelle ton dossier "bin" c'est là où tu compiles tes fichiers Java, c'est à dire là où tu as tout tes fichiers .class après compilation (c'est là que les mets Eclipse par défaut).
Et c'est aussi là qu'il faut mettre le fichier manifest.txt (en fait son nom importe peu ici).

Ensuite quand tu ouvres une invite de commandes, par défaut tu dois être dans ton dossier personnel, il faut alors se déplacer jusqu'à ce dossier "bin" avec la commande "cd"

Exemple : cd C:\Users\Moi\Workspace\Calculatrice\bin

Une fois au bon endroit tu lances la commande que je t'ai donné, "jar cvmf..." qui va te créer un fichier JAR directement avec Java, sans utiliser les paramètres d'Eclipse qui rajoutent un dossier org/eclipse... qui ne sert à rien et augmente la taille du Jar.
Donc j'ai pris le fichier manifest de meta inf, je l'ai déplacé (mis) avec les fichiers class de "calculette.jar" et je l'ai démarré... L'invite de commande apparait 2 sec puis se referme.. J'ai pas du bien comprendre...
Messages postés
16372
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
23 juillet 2021
2 860
Effaces ton fichier JAR, on va en refaire un manuellement, tu n'as plus besoin de celui d'avant !

Tu vas dans ton workspace d'Eclipse, tu vas avoir un dossier pour ton projet et dedans les dossiers src et bin.

Dans ton dossier bin, tu dois avoir plusieurs fichiers .class (en particulier Calculatrice.class et Main.class). Dans ce dossier bin tu créés un fichier (peu importe le nom, par exemple "manifest.txt") avec le contenu que j'indiquais hier :

Manifest-Version: 1.0
Main-Class: Main

Pour simplifier les invites de commandes, tu vas maintenant créer un autre fichier dans ce dossier, là encore peu importe le nom, mais par contre il est important que ce soit une extension .cmd, par exemple "makejar.cmd" avec ce contenu :

jar cmvf manifest.txt Calculatrice.jar *.class
java -jar Calculatrice.jar
pause

Il te reste plus alors qu'à cliquer sur ce fichier makejar.cmd pour ouvrir une invite de commande qui va créer ton fichier jar exécutable en prenant d'une part le fichier manifest.txt et d'autre part les fichiers .class qui se trouvent tous dans le dossier bin.
Cela va te créer un fichier Calculatrice.jar et le lancer automatiquement. Par la suite tu pourras exécuter directement ton fichier Calculatrice.jar en cliquant dessus, même si tu le déplaces ailleurs sur ton ordinateur ou sur un autre ordinateur (remarque : le clic direct sur un JAR fonctionne sous Windows mais pas forcément sous les autres systèmes)

Je suppose que quand tu dis bin, c'est quand j'enregistre en executable jar, j'ai calculatrice.jar.

je l'ai ouvert avec winrar, j'ai créé un fichier .txt que j'ai nommé manifest avec ton contenu. Je l'ai mis avec mes fichiers .class. (sachant que j'en ai un de manifest dans META-INF). J'ai ensuite créé un fichier que j'ai nommé Makejar.cmd avec ton contenu. Je l'ai lancé (une fois qu'il était avec les autres dossiers .class).

Résultat:

C:\User[...]>jar cmvf manifest.txt Calculatrice.jar *.class
'jar' n'est pas reconnu en tant que commande interne
ou externe, un programme exécutable ou un fichier de commandes.

C:\User[...]>java -jar Calculatrice.jar
aucun attribut manifest principal dans Calculatrice.jar

C:\User[...]pause
Appuyez sur une touche pour continuer...


Voilà :/
En tout cas, merci de ta patience et de tes réponses :)

chat
Utilisateur anonyme
Après avoir mis le manifest avec dedans:

Manifest-Version: 1.0
Main-Class: Main

et le .cmd, la commande indique:

- Chemin d'accès spécifié introuvable (pour la 1ere ligne:)

"C:\Program Files\Java\jdk1.7.0_17\bin\javac.exe" Main.java

- Impossible de trouver ou charger la classe principale Main (pour la 2eme ligne:)

"C:\Program Files\Java\jre7\bin\java.exe" Main

- Le chemin d'accès spécifié introuvable (pour la 3eme ligne:)

"C:\Program Files\Java\jdk1.7.0_17\bin\jar.exe" cmvf manifest.txt Calculatrice.jar *.class

- Error: Unable to access jarfile Calculatrice.jar (pour la 4eme ligne:)

"C:\Program Files\Java\jre7\bin\java.exe" -jar Calculatrice.jar
pause

Voila, il doit y avoir des chemins incorrects dans le code...
Messages postés
16372
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
23 juillet 2021
2 860
"il doit y avoir des chemins incorrects dans le code..."
Surement oui, mais je ne peux pas deviner ta configuration, moi je t'ai donné le répertoire d'installation par défaut, mais à toi de regarder où tu as véritablement installé "jdk-7u17-windows-x64" pour voir quel est le bon chemin.

La 3è erreur est la même que la 1ère parce que c'est le même chemin d'accès.
Les erreurs 2 et 4 sont liés au fait que les lignes 1 et 3 ne se sont pas déroulés correctement.
Utilisateur anonyme
Donc si j'arrive à trouver le bon chemin de la 1ere ligne, tout sera réglé avec?
Messages postés
16372
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
23 juillet 2021
2 860
Je ne veux pas trop m'avancer mais normalement oui.
D'une part, parce que tu pourras exécuter mon .cmd qui va te générer ton JAR.
D'autre part, parce qu'avec le bon chemin d'accès, on pourra correctement configurer la variable d'environnement et par la suite utiliser Eclipse.
Utilisateur anonyme
Alors j'ai mis jdk-7u17-windows-x64.exe dans le java de ProgramFiles (x86), en dessous de jre7 et la commande dit:

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
JFrame cannot be resolved to a type
JPanel cannot be resolved to a type
JPanel cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
Dimension cannot be resolved to a type
Dimension cannot be resolved to a type
Dimension cannot be resolved to a type
Dimension cannot be resolved to a type
The method setSize(int, int) is undefined for the type Calculatrice
The method setTitle(String) is undefined for the type Calculatrice
JFrame cannot be resolved to a variable
The method setLocationRelativeTo(null) is undefined for the type Calculatrice
The method setResizable(boolean) is undefined for the type Calculatrice
JPanel cannot be resolved to a type
The method setVisible(boolean) is undefined for the type Calculatrice
Font cannot be resolved to a type
Font cannot be resolved to a type
Font cannot be resolved to a variable
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a variable
JLabel cannot be resolved to a type
Dimension cannot be resolved to a type
JPanel cannot be resolved to a type
JPanel cannot be resolved to a type
Dimension cannot be resolved to a type
JPanel cannot be resolved to a type
JPanel cannot be resolved to a type
Dimension cannot be resolved to a type
JPanel cannot be resolved to a type
JPanel cannot be resolved to a type
Dimension cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
Dimension cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
Color cannot be resolved to a variable
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
Dimension cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
Dimension cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
Dimension cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
Dimension cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JLabel cannot be resolved to a type
BorderFactory cannot be resolved
Color cannot be resolved to a variable
JPanel cannot be resolved to a type
BorderLayout cannot be resolved to a variable
JPanel cannot be resolved to a type
BorderLayout cannot be resolved to a variable
JPanel cannot be resolved to a type
BorderLayout cannot be resolved to a variable
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
JLabel cannot be resolved to a type
ActionListener cannot be resolved to a type
ActionEvent cannot be resolved to a type
JButton cannot be resolved to a type
JButton cannot be resolved to a type
JLabel cannot be resolved to a type
ActionListener cannot be resolved to a type
ActionEvent cannot be resolved to a type
ActionListener cannot be resolved to a type
ActionEvent cannot be resolved to a type
ActionListener cannot be resolved to a type
ActionEvent cannot be resolved to a type
ActionListener cannot be resolved to a type
ActionEvent cannot be resolved to a type
ActionListener cannot be resolved to a type
ActionEvent cannot be resolved to a type
ActionListener cannot be resolved to a type
ActionEvent cannot be resolved to a type

at Calculatrice.<init>(Calculatrice.java:1)
at Main.main(Main.java:3)

avec d'autres erreurs comme "le chemin d'accès spécifié est introuvable" et "Error: unable to accès jarfile Calculatrice.jar

Je perd espoir T.T
Messages postés
16372
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
23 juillet 2021
2 860
"le chemin d'accès spécifié est introuvable"
Là encore, je ne peux pas deviner ta configuration, à toi d'adapter les chemins d'accès à ceux de ton installation de Java.

"Exception in thread "main" java.lang.Error: Unresolved compilation problems"
Ça c'est une erreur parce que tu exécutes le code avec Eclipse !
Utilises le fichier .cmd, on verra Eclipse plus tard (ou pas).

À part les chemins d'accès, tu devrais avoir tout comme dans cette vidéo :

       chat810.webm (1.0 Mo)
Utilisateur anonyme
pour java -version ça marche, il me donne les infos mais pour javac - version il me dit qu'il est mal fait (Usage: Javac <options> <source files>)
Messages postés
16372
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
23 juillet 2021
2 860
oups, petite erreur, c'était comme l'autre : javac -version (sans espace), mais s'il te dit que la syntaxe est mauvaise ça veut dire qu'il l'a reconnait malgré tout comme commande, et que donc la variable d'environnement est bonne :-)
Utilisateur anonyme
Donc je peux enfin utiliser Eclipse sans refaire toutes les étapes d'avant avec le .bat etc?
Messages postés
16372
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
23 juillet 2021
2 860
A priori oui, mais le fichier .cmd nous aura permis de régler le problème ce qui n'était pas gagné d'avance. Et d'après moi il reste la meilleure manière de faire un fichier JAR propre.
Mais de toute façon la conception d'un JAR vient tout à la fin du développement, une fois que le code est totalement terminé et vérifié, parce qu'en phase de développement les fichiers .class suffisent largement.

Remarque : tout ce qu'on a fait avec le fichier .cmd on peut les faire directement en ligne de commande, et c'est généralement ce que l'on fait en pratique...
Utilisateur anonyme
Ok merci pour tout :)

chat
Messages postés
16372
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
23 juillet 2021
2 860
"je me retrouve avec plein de .class dans un fichier winrar"
C'est normal, un fichier .jar est un simple fichier .zip qui contient toutes tes classes.
Il faut modifier la configuration de WinRar pour que les JAR soient ouverts par Java.

Tu ouvres WinRar (soit directement, soit depuis n'importe quel fichier qu'il ouvre)
Tu vas dans Options > Paramètres > Intégration, et tu décoches la case "JAR"
Tu fais OK, et ça devrait être régler.La confiance n'exclut pas le contrôle
mrc ca m a aider aussi
Messages postés
16372
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
23 juillet 2021
2 860
Il existe deux types de fichiers JAR, ceux qui sont éxécutables, et ceux qui ne le sont pas, la différence c'est que l'un contient un fichier particulier "MANIFEST.FM" qui est placé dans le dossier "META-INF" et qui contient la classe principale à exécuter.
Mais de toute façon, un JAR exécutable s'ouvre avec Java (pas avec WinRar ni Wordpad) et en aucun il ne s'agit d'un fichier .exe !

Personnellement je préfère faire ça en ligne de commande, parce que Eclipse a tendance a rajouter des informations inutiles dans le JAR. Voici comment faire :

1) tu créés un fichier "manifest.txt" dans ton dossier "bin" avec ce contenu :

Manifest-Version: 1.0
Main-Class: Main

Attention :
ne pas oublier de sauter une ligne après "Main" (tu dois donc avoir 3 lignes)

2) en ligne de commandes, tu te déplaces jusqu'à ton fichier bin et tu tapes :

jar cmvf manifest.txt Calcultrice.jar *.class

Cela devrait te donner un JAR tout propre et fonctionnel. Reste alors à cliquer dessus.