Un peu de maths : les puissances 2/2

Suite du post Un peu de maths : les puissances part.1
Petit rappel sur les règles de la puissance :

  • x^0 = 1.
  • x^y = x^(y/2)*x^(y/2) si y est pair.
  • x^y=x^(y-1)*x sinon.

Le petit programme qui suit demande deux valeurs (x et i) et calcule x puissance i :

import java.util.Scanner;

class puissance{
  static double puissance(double x,int n){
    double reponse;
    if (n==0) {
      reponse=1;
    }else{
      reponse=puissance(x,n/2);
      if(n%2==0){
        reponse=reponse*reponse;//pair
      }else{
        reponse=reponse*reponse*x;//impair
      }
    }
    return reponse;
  }
  public static void main(String[] args) {
    double x;
    Scanner lectureValeur = new Scanner(System.in);
    System.out.print("Valeur de x : ");
    x=lectureValeur.nextDouble();
    System.out.print("Puissance demandee : ");
    i=lectureValeur.nextInt();
    System.out.println(x+"^"+i+" = "+(int)(puissance(x,i)));
  }
}

Résultat sur le terminal :

nerdyprog@nerdycode ~ $ javac puissance.java
nerdyprog@nerdycode ~ $ java puissance
Valeur de x : 2
Valeur de i : 2
2.0^2 = 4

Le deuxieme petit programme permet d’écrire un calcul de la forme 2^2 et effectue le calcul :

import java.util.Scanner;

class puissance2{
  static double puissance(double x,int n){
    double reponse;
    if (n==0) {
      reponse=1;
    }else{
      reponse=puissance(x,n/2);
      if(n%2==0){
        reponse=reponse*reponse;//pair
      }else{
        reponse=reponse*reponse*x;//impair
      }
    }
    return reponse;
  }
  public static void main(String[] args) {
    double x=0;
    String calcul;
    int j=0, k=0, n=0;
    Scanner lectureEntre = new Scanner(System.in);
    System.out.print("Calcul à effectuer : ");
    calcul=lectureEntre.nextLine();
    for (int i=0; i<calcul.length(); i++) {
      if(calcul.charAt(i)!='^'){
        j=i+1;
        k=j+1;
      }else{
        break;
      }
    }
    x=Double.parseDouble(calcul.substring(0,j));
    n=Integer.parseInt(calcul.substring(k,calcul.length()));
    System.out.println(x+"^"+n+" = "+(int)(puissance(x,n)));

  }
}

Résultat sur le terminal :

nerdyprog@nerdycode ~ $ javac puissance.java
nerdyprog@nerdycode ~ $ java puissance
Calcul à effectuer : 2^2
2.0^2 = 4

 

Bien coder c’est coder proprement

Je suis tombé précédemment sur une présentation faite par Jean-Baptiste Nizet, informaticien chez NinjaSquad : https://speakerdeck.com/jnizet/5-apprentissages-pour-le-programmeur-debutant

J’ai trouvé intéressant de rebondir là-dessus vu mon dernier post. Je reviens donc sur cette présentation et je présente mon point de vue. En clair, je commente cette présentation 🙂

1 – Indentez votre code

Oui, comme le dit JB Nizet, l’indentation est promordial en programmation. Sur ce point, rien à dire. C’est comme si j’écrivais ce post sans accents, sans ponctuation. Ce serait illisible ! (Pour faire hype, branché, à la mode, on emploiera le terme refactoring).

2 – Erreurs et trace de bugs

La plupart des étudiants en informatique ne lisent pas ces traces d’erreurs car c’est un bloc illisible à première vue ! Puis même après avoir pris l’habitude de lire ces traces d’erreur, voire avoir pris l’habitude d’utiliser le débugueur de l’IDE, ça reste chiant ce gros pavé.

Que ce soit Eclipse ou IntelliJ (je suis agnostique là-dessus en ce qui concerne ces usines à gaz, pas de préférences), l’apprentissage reste faible. Les gens vont aller sur google et recopient la trace d’erreur et avec un peu de chance, ils trouveront une tentative de résolution sur StackOverflow…

3 – La documentation c’est pour les rigolos

Google c’est magique. Encore plus si vous faîtes votre recherche : 1) en anglais 2) avec des mots-clés.

Personnellement, je trouve que la documentation c’est utile, mais de temps en temps c’est vachement pas très instructif et ça n’aide pas tout le temps. Surtout en développement web quand vous utilisez des frameworks et autres librairies.

Donc le RTFM [1], c’est gentil mais dès fois pour des cas complexes ce serait plutôt LMTGTFY [2] ! 😛

4 – Killing the name of

J’en ai déjà parlé précedemment. Les variables foor, bar, toto, c’est cool quand vous testez pour vous-même. Les variables qui n’ont aucun sens c’est à proscrire. De même pour les variables trop verbales. Surtout en Java ! Oui Java est déjà tellement verbeux alors si vous en rajoutez une couche…

5 – Throws, catch…

Je ne suis pas encore un expert dans tous les langages mais à vue de nez ça sent le Java !

Je profite de ce cinquième point pour faire une parenthèse sur Java.Java ne sera jamais mon langage préféré pour plusieurs raisons.

La première : Il est trop verbeux.

Un exemple :

Capture d’écran 2014-07-03 à 16.20.53

La deuxième : Les exceptions.

Pour un débutant voire quelqu’un qui a au minimum un an d’expérience en Java (voire deux dans mon cas), les exceptions c’est un autre monde.

La troisième : Un langage objet devrait être simple.

Je n’ai pas encore manipulé d’autres langages objets jusqu’à présent mais je reste persuadé que le langage objet fut créé tout d’abord pour simplifier la programmation. Il faudrait comparer Java avec le langage C++ ou encore le langage Objective-C. Mieux encore ! Avec le langage Smalltalk !

Il y a d’autres raisons, mais ce sont les principales. Java n’en reste pas moins un langage intéressant mais il est loin d’être le meilleur à mon goût.

Une calculatrice en Java, ça vous va ?


Souvenez vous de ceci « Une calculatrice en Java, ça vous va ? » ? J’avais revisité un code que j’avais écrit quand j’étais un gros débutant. Aujourd’hui, je vous propose un code beaucoup plus balèze et plus sophistiqué que les codes précédents 🙂 En effet, vous pourrez ici faire des calculs (simples hein ? n’espérez pas calculer le khi deux avec )! Enjoy les amis.
P.S : Code vérifié avec des tests unitaires (je reviendrais là-dessus plus tard)


 

import java.util.Scanner;

public class Calculator {
	public static String execute(String s) {
		if(s.equals("")) return "Erreur !";
		if(!s.contains("+")&& !s.contains("-") && !s.contains("*") && !s.contains("/")) return s;
		s = supprEspaces(s);
		String resultat = new String();
		int resultatInt=0;
		char operateur = getOperateur(s);
		String operande1, operande2;
		int indiceOp=0;
		while(s.charAt(indiceOp) != operateur) indiceOp++;
		operande1 = s.substring(0, indiceOp);
		operande2 = s.substring(indiceOp+1, s.length());
		if(operateur == '+') resultatInt = Integer.parseInt(operande1) + Integer.parseInt(operande2);
		if(operateur == '-') resultatInt = Integer.parseInt(operande1) - Integer.parseInt(operande2);
		if(operateur == '*') resultatInt = Integer.parseInt(operande1) * Integer.parseInt(operande2);
		if(operateur == '/') resultatInt = Integer.parseInt(operande1) / Integer.parseInt(operande2);
		resultat = String.valueOf(resultatInt);
		return resultat;
	}
	
	public static String supprEspaces(String s) {
		String S = new String();
		for(int i=0; i<s.length(); i++) {
			if(s.charAt(i) != ' ') S += s.charAt(i);
		}
		return S;
	}
	
	public static char getOperateur(String s) {
		for(int i=0; i<s.length(); i++) {
			if(s.charAt(i) == '/') return '/';
			if(s.charAt(i) == '*') return '*';
			if(s.charAt(i) == '+') return '+';
			if(s.charAt(i) == '-') return '-';
		}
		return 'e';
	}
	
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String reponse = new String();
		do {
			System.out.print("Entrez votre calcul: ");
			String calcul = scan.nextLine();
			System.out.println(calcul + " = " + execute(calcul));
			System.out.print("Voulez-vous effectuer un nouveau calcul? (o/n) ");
			reponse = scan.nextLine();
		} while(!reponse.equals("n"));
	}

}

Pacman : un petit kit de démarrage dans le graphisme en Java avec AWT & SWING

gamejava

Voici le premier article d’une série que j’espère pouvoir compléter sur la création de jeu en Java. Cette série ne comportera que les rudiments, les outils que vous utiliserez afin de créer vos jeux. Il y a bien longtemps, j’avais introduit SWING & AWT avec mon projet Ninn, laissé un peu de côté ces derniers temps. Je reviens ici sur SWING & AWT, pour vous présenter un petit programme assez sympa et rapide à réaliser : Pacman. Nous ne verrons pas comment coder le jeu entier, mais simplement dessiner la petite boule jaune morfale. Si vous arrivez à comprendre comment fonctionne ce code, vous pourrez alors par la suite créer votre propre jeu Pacman ! 🙂

 APERÇU DU RESULAT FINAL DISPONIBLE ICI :

Pacman

prebloc

import java.awt.Color;
import java.awt.Graphics;

import javax.swing.JFrame;

public class Pacman extends JFrame{

 private int compteur ;
 Color couleur1, couleur2;
 public int x=70;
 public int x1;

 public Pacman(String titre, int largeur,int hauteur,int posX,int posY) {
 super(titre);
 setSize( largeur, hauteur );
 setVisible( true );
 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 this.setLocation(posX,posY);
 couleur2 = Color.yellow;
 }

 public void animer (int nbr_mouvement){
 for (compteur=0; compteur<nbr_mouvement; compteur++) {
 this.repaint();
 try {
 Thread.sleep(100);
 }
 catch (InterruptedException e) {
 e.printStackTrace();
 }

 if(x1<300){
 x=x+10;
 x1=x;
 }else{
 x=x-10;
 x1=300;
 }
 }

 //on relance la méthode pour obtenir une boucle infinie !
 if(compteur==nbr_mouvement){
 compteur=0;
 x1=0;
 animer(48);
 }
 }

 public void paint (Graphics g){
 if (compteur%2==0){
 couleur1 = Color.yellow;
 }else{
 couleur1 = Color.white;
 }
 if(x1<300){
 g.setColor( Color.white);
 g.fillRect(0,0,500,500);
 g.setColor( couleur1);
 g.fillArc(x, 60, 50, 50,0, 360);
 g.setColor( couleur2);
 g.fillArc(x,60, 50, 50, 30, 280);
 g.setColor(Color.DARK_GRAY);
 g.fillArc(x+25, 65, 7,7,0, 360);
 }else{
 g.setColor( Color.white);
 g.fillRect(0,0,500,500);
 g.setColor( couleur1);
 g.fillArc(x, 60, 50, 50,0, 360);
 g.setColor( couleur2);
 g.fillArc(x, 60, 50, 50,140, -280);
 g.setColor(Color.DARK_GRAY);
 g.fillArc(x+25, 65, 7,7,0, 360);
 }
 }

 public static void main(String[] args) {
 Pacman animation = new Pacman("Pacman", 400, 165,200,150);
 animation.animer(48);
 }

}

Quelques explications s’imposent ! :mrgreen: Tout d’abord nous travaillons avec SWING & AWT et nous avons besoin d’une JFrame. La JFrame permet de créer et gérer des objets de type cadres, fenêtres. C’est une sorte de conteneur pour les objets de type boutons, champs texte… Pour utiliser cela nous allons avoir besoin d’importer cet élément de la bibliothèque graphique SWING.

import javax.swing.JFrame;

Notre classe va hériter des propriétés, des méthodes et divers attributs de JFrame. Pour ça, on doit ajouter extends JFrame.

public class Pacman extends JFrame

Maintenant, détaillons en commençant avec les signatures :

public Pacman(String titre, int largeur,int hauteur,int posX,int posY)

Pacman est le constructeur, il permet de construire notre fenêtre dans son ensemble. Les attributs qu’on passe en arguments sont des caractéristiques propres à la création d’une fenêtre. De manière générale, pour créer une fenêtre nous devons créer un constructeur en suivant ce modèle :

public fenetre() {
	super("titre");//titre de la fenetre
	setSize( 900, 300 );//taille de la fenetre
	setVisible( true );//visibilite de la fenetre
	this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //Pour fermer la fenetre
	this.setLocation(0,0);//position de la fenetre
}

Ici, dans notre code, on a passé en arguments les attributs afin de rendre le constructeur plus flexible. Je pourrais créer plein d’objets en y changeant les attributs :

public static void main(String[] args) {
	Pacman animation = new Pacman("Pacman", 400, 165,200,150);
	Pacman animation2 = new Pacman("Pacman2", 410, 150,200,150);//une autre fenetre aux dimensions différentes
	Pacman animation3 = new Pacman("Pacman3", 600, 175,200,150);//idem
        animation.animer(48);
}

(En rajoutant ces lignes, on créé trois fenêtres)

public void animer (int nbr_mouvement)

animer est une méthode void qui permet de faire tourner une boucle qui appelle, à chaque fois qu’on passe dans celle-ci, à la méthode qui dessine notre pacman. Le paramètre nbr_mouvement, permet de définir combien de fois nous afficherons pacman.

public void paint (Graphics g)

La méthode paint est propre à AWT et plus particulièrement à Graphics. Elle permet de dessiner… Des ronds, des rectangles…Vous pouvez consulter la javadoc d’Oracle à propos de Graphics.

C’est pour cette raison que nous importons des éléments de la bibliothèque AWT au tout début du programme :

import java.awt.Color;
import java.awt.Graphics;

Je vous laisse regarder cette doc, et bidouiller le programme afin de comprendre l’utilité de setColor(), fillRect(), fillArc() … Mais en gros, setColor() permet de définir la couleur de l’arrière-plan (blanc) et du pacman (jaune) , le  fillRect() nous permet ici de dessiner un rectangle plein, de couleur blanche, et le fillArc() le pacman. Pour dessiner notre pacman, j’ai délibérément choisi de le présenter à l’aide de deux disque, un disque plein jaune, et un quart de disque dont la couleur alternera :soit blanc, soit jaune. Le compteur permet d’alterner entre « pacman bouche ouverte » et « pacman bouche fermée » :


if (compteur%2==0){
couleur1 = Color.yellow;
}else{
couleur1 = Color.white;
}

Il existe bien sûr d’autres méthodes, par exemple deux disques jaunes un complet et un ouvert ou encore un seul disque donc l’angle d’ouverture change selon la valeur du compteur. Tout est possible ! 😀

Vous avez normalement toutes les données nécessaires pour refaire le pacman présenté en vidéo.

Prochainement, nous verrons comment bouger le pacman avec le clavier, puis si j’ai le temps nous nous pencherons sur les collisions (ex : pacman ne peut pas traverser le mur).  🙂

P.S : WordPress a un peu de mal avec l’indentation, n’oubliez pas de  bien indenter votre code ! 😉

classicgames_64

Une calculatrice en Java, ça vous va ?


Après le premier article intitulé « Une calculatrice en Java, ça vous va ? » qui dévoilait aux internautes mon tout premier programme en tant que débutant, je décide de revoir un peu ce code très lourd et horrible. A l’époque mon but avait été d’utiliser pas mal de techniques complexes telle que le fameux try{}catch, but débile pour un débutant. En effet, mieux vaut commencer simple avec une syntaxe simple mais des algorithmes du plus simple au plus compliqué que d’essayer dès le début d’apprivoiser une syntaxes « haut niveau ». Bon voilà j’ai revisité un peu le code, le voici un peu plus allégé. Il n’est certes pas parfait, mais au moins ça fait du bien aux yeux !! 🙂


 

import java.util.*;
public class calculatrice{
	public static void main(String [] args){
		String calculAFaire,temp;
		int chiffre1,chiffre2,somme;
		System.out.println("*********************************************");
		System.out.println("***************SIMPLE CALCULATOR*************");
		System.out.println("*********************************************");
		Scanner in = new Scanner(System.in);
		System.out.print("Tapez votre calcul : ");
		calculAFaire=in.next();
		chiffre1=Character.getNumericValue(calculAFaire.charAt(0));
		chiffre2=Character.getNumericValue(calculAFaire.charAt(2));
		if(calculAFaire.charAt(1)=='+'){
			somme=chiffre1+chiffre2;
		}else if(calculAFaire.charAt(1)=='-'){
			somme=chiffre1-chiffre2;
		}else if(calculAFaire.charAt(1)=='*'){
			somme=chiffre1*chiffre2;
		}else if (calculAFaire.charAt(1)=='/') {
			somme=chiffre1/chiffre2;

		}else{
			System.out.println("Unknown operator");
			somme=0;
		}
		System.out.println("Résultat "+somme);

	}
}

Ninn : Une fenêtre Java avec un JTextArea

Introduction

Je vous en parlais dans la brève d’aujourd’hui, nous allons bientôt démarrer le développement de Ninn fin Septembre si tout se passe bien. Nous allons partager avec vous ce mois-ci un code en java qui servira de base au développement de Ninn. (Nous avons de grands projets pour Ninn 🙂 ).

Java 

Pour exécuter ce code, veuillez avoir installer l’environnement Java (JRE et JDK). Pour comprendre ce code servez vous des commentaires ainsi de l’article proposé en fin d’article. 🙂

 
 

package Ihm;
import java.util.*;
//on importe tout le contenu de la bibliothèque avec
//cela évite d'importer un par un les éléments de la bibliothèque swing
import javax.swing.*;
/*je suis obligé de faire appel à AWT car j'en ai besoin pour gérer les 'layouts manager'
(gestionnaires de placement)
*/
import java.awt.*;
import java.awt.event.*;

//la classe hérite de JFrame (extends)
class mainwindow extends JFrame
//On maintenant construit la fenêtre
{
/*variable privée : variable accessible uniquement dans la classe
on déclare ces variables qui vont être utilisés dans le constructeur avant
avantage de le déclarer en dehors du constructeur :
utilisable partout dans la classe mainwindow*/

//Container, contient tous les autres objets tel que JButton
private JPanel panel = new JPanel();

//barre de menu
private JMenuBar menubar = new JMenuBar();

//Menu
private JMenu file = new JMenu("File");
private JMenu edition = new JMenu("Edit");
private JMenu about = new JMenu("A propos");

//Items
private JMenuItem sauvegarder = new JMenuItem("Save");
private JMenuItem quitter = new JMenuItem("Quit");
private JMenuItem license = new JMenuItem("License");

//fontsize sera un item de : edition et aura plusieurs items
private JMenu fontsize = new JMenu("Font Size");
private JMenuItem size12 = new JMenuItem("12");
private JMenuItem size36 = new JMenuItem("36");
//Zone de texte
private JTextArea text = new JTextArea("");
//constructeur
public mainwindow()
{            //titre de la fenêtre
setTitle("NINN");
//taille de la fenêtre
setSize(990,560);
setResizable(true);
//affiche la fenêtre au centre de l'écran
setLocationRelativeTo(null);
//cadre de la fenêtre
//true : cadre
//false : sans cadre
setUndecorated(false);
// ferme la fenêtre
//si on ne met pas ça en réalité la fenetre n'est pas fermée elle a juste "disparue"
setDefaultCloseOperation(EXIT_ON_CLOSE);

//----------------
setJMenuBar(menubar);
menubar.add(file);
menubar.add(edition);
menubar.add(about);
file.add(sauvegarder);
file.add(quitter);
edition.add(fontsize);
fontsize.add(size12);
fontsize.add(size36);
about.add(license);

//----------------

//raccourcis clavier
sauvegarder.setMnemonic('S');
// getKeyStroke to get the KeyChar
sauvegarder.setAccelerator(KeyStroke.getKeyStroke (KeyEvent.VK_S,InputEvent.CTRL_MASK));
quitter.setMnemonic('Q');
quitter.setAccelerator(KeyStroke.getKeyStroke (KeyEvent.VK_Q,InputEvent.CTRL_MASK));

//----------------

//quand on clique sur quitter, l'application se ferme
//pour sauvegarder
sauvegarder.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent arg0) {
JOptionPane.showMessageDialog(panel, "La fonction sauvegarder n'existe pas encore" );
}
}
);
//pour quitter Ninn
quitter.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent arg0) {
System.exit(0);}
}
);
//la licence d'exploitation de Ninn
license.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent arg0) {
JOptionPane.showMessageDialog(panel, "GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. http://fsf.org/" );
}
}
);
//pour modifier la taille du texte
size12.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent arg0) {
Font twelve = new Font("Arial", Font.PLAIN,12 ); // 12
text.setFont(twelve);
}
}
);
size36.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent arg0) {
Font twelve = new Font("Arial", Font.PLAIN,36 ); // 36
text.setFont(twelve);
}
}
);

//----------------

//on appelle ceci un layout manager et ceci est un objet de la bibliothèque AWT
panel.setLayout(new BorderLayout());
//panel.add(bouton, BorderLayout.NORTH);
panel.add(text, BorderLayout.CENTER);
this.setContentPane(panel);

//----------------

//autorise le retour à la ligne
text.setLineWrap(true);

}
}
//classe principale 'window'
public class window {

/**
* @param args
*/
//méthode prncipale main (static void)
public static void main(String[] args) {
// TODO Auto-generated method stub
//objet de type JFrame, on place sa référence dans window
//On va construire la fenêtre en faisant appelle à la classe mainwindow();
JFrame window = new mainwindow();
//rendre visible la fenêtre
window.setVisible(true);

}

}

VOUS AVEZ ADORÉ ? VOUS ALLEZ RIRE MAIS CET ARTICLE VOUS INTÉRESSERA.

En passant

Les brèves de nerdycode


Création d’une nouvelle rubrique : Les brèves de nerdycode

Après constaté que je pouvais consacré un peu de mon temps pour des articles rapides, je vous propose cette rubrique. Cette dernière comportera des nouvelles plus ou moins brèves, ou des articles dans le vif du sujet.

Vous reconnaîtrez ce type d’articles par le logotype ici présent —>

Le projet Ninn

Début du projet Ninn : 30 Septembre 2012 normalement.

Ninn sera un éditeur de texte écrit en Java, nous commençons bientôt le développement de l’applicatif. Il sera normalement diffusé en version code source libre et gratuit. Dans la continuité du projet, je partagerais avec vous un code source qui fera office de base au code du programme Ninn. Par respect de l’auteur, veuillez ne pas piquer le nom choisi pour l’application en cours de développement.

Creation of a new section : brief news from nerdycode

After a moment while writing a lot of expeditious articles, I decided to create the « brief news form nerdycode », where Serial and me will write very short articles or non-important articles.

Ninn project

Beginning of the project : 09/30/12. Normally.

Ninn will be an editor written in Java (so normally, running everywhere according to the theory). We’re startin’ the development soon, and it will be diffused as free software. So, I’ll share with you the source code in Java which will help me to build Ninn. Be nice, don’t copy the name I found for my soft.

Éditeurs de code

J’espère que vous aimerez cet article qui m’a pris beaucoup de temps et qui complète une série d’articles :

  1. J’apprends à programmer
  2. Des ressources en abondance pour le développeur

Pour compléter la parfaite panoplie du développeur, il faut choisir un IDE. L’IDE est un éditeur de développement intégré. Plus qu’un simple éditeur, il proposera des outils, tel un couteau suisse, comme l’auto-complétion. Alors qu’en ce moment même, Adobe développe son propre éditeur orienté web, j’ai décidé de vous parlé des éditeurs.

Commençons avec les éditeurs en apparence simple mais qui permettent de bosser sur tous les langages.

Éditeurs multiple-langages.

Notepad ++

Éditeur très simple sans débogueur, rien du tout d’autre qu’un éditeur qui vous permet d’enregistrer dans différents formats. A l’origine Notepad++ se veut un simple éditeur pour tous les langages, c’est pourquoi vous le trouverez dénudé au départ, surtout si vous êtes habitués à des IDE tel qu’Eclipse. Ceci dit, ce dernier propose quelques plugins qui vous permettent d’avoir  tous les gadgets que vous voulez (auto complétion, etc).

intype

Cet éditeur est très très jeune mais a une belle longue vie devant lui à tracer. Comme Notepad++, des bundles à souhait. Il n’y a pas encore de plugins, mais il est déjà assez sympathique comme ça. 🙂

Sublime Text 2

Pour finir (en beauté) la partie « éditeur multiple-langage », je vous propose un cas très particulier. Je l’ai découvert depuis très peu de temps : Sublime Text 2. Tapez sur Google, et vous lirez de beaux textes du genre « Il sublimera votre code » (ce qui n’est pas tout à fait vrai dans un sens, puisque ce n’est pas l’éditeur qui fait que le code est magnifique), mais j’avoue qu’il gère la fougère ! Côté aspect graphique rien à dire. Petit plus par rapport à Notepad++, la façon d’utiliser l’ascenseur de droite. Je vous laisse la surprise. Sinon, il y a des raccourcis à souhait, et des plugins qui amènent son utilisation vers la simplicité et l’efficacité. Cerise sur le gâteau, bien qu’une licence est exigée (59$), il n’y a pas de limite dans le temps à l’utilisation de la « version d’essai ».

Éditeurs « Usine à gaz »

On les appelle « usines à gaz », je vous les cite sans passer trop de temps à les décrire, vous comprendrez qu’il n’y a là aucun intérêt d’en parler aussi bien ils sont connus (pour la plupart) que leur réputation d’usines à gaz n’est pas à refaire (ce qui signifie pas que ce sont de mauvais éditeurs). Si vous cherchez un éditeur de code plus léger (qu’importe le langage), ce paragraphe n’est pas pour vous (à moins que vous soyez piqués de curiosité) :

  • Eclipse (éditeur très connu pour Java, je vous recommande la lecture de cet article)
  • Netbeans (éditeur principalement Java, créé d’ailleurs par les créateurs de Java)
  • Komodo Edit (encore du Java mais pas seulement en fait…)
  • Aptana (éditeur principalement HTML/CSS/JS)
  • Dreamweaver (éditeur HTML, etc)
  • VisualStudio (édité par Microsoft)

Éditeurs « autres »

BlueGriffon

Pour faire du développement web, je vous propose, si vous n’utilisez pas un des éditeurs multiple-langages, BlueGriffon. Il s’agit d’un éditeur WYSIWYG (What You See Is What You Get). Cet éditeur, pour la culture générale, est écrit par Daniel Glazman. Si vous lisez quelque part : »éditeur basé sur le moteur de rendu de Firefox ». C’est tout à fait normal. 🙂 Les deux éditeurs web de firefox qui se sont succédés, KompoZer et Nvu, ont été écrit par Daniel Glazman !(Bon, d’accord, il n’était pas tout seul sur le développement du logiciel, mais cela explique assez bien les similitudes…).

Bluefish

Si vous n’aimez pas le WYSIWYG, ou que vous préférez le code pur et dur, vous avez Bluefish. (On adore le bleu nous les informaticiens). Remarque : le WYSIWYG n’est plus à la mode, d’autant plus que nombreux sont les web developers  qui considèrent le WYSIWYG comme un outil pour les débutants…Je dis ça je dis rien…

Brackets : « L’éditeur qui pouvait s’éditer lui-même »

Mais celui qui a attiré mon attention ces derniers temps est Brackets, un éditeur gratuit et open-source, tout étant édité par… Adobe ! Enfin un logiciel Adobe que je vais sûrement aimer ! Le code source est donc à disposition sur Github. Son design est épuré , son interface est bien pensé. Techniquement, c’est une vrai trouvaille puisque qu’il est écrit entièrement en HTML et JS (« built with the web« ) ! Quoi de mieux qu’une vidéo pour vous montrer ce que c’est 😉 :

Pour conclure, nombreux sont les logiciels pour les développeurs web. Néanmoins, les principaux à retenir sont :

Je n’ai pas testé d’autres éditeurs autres qu’Eclipse, Komodo et Netbeans pour le java. Néanmoins, je peux vous indiquer deux logiciels plus légers :

Éditeurs en ligne

Cela devient à la mode : les éditeurs en ligne. Je commence par Mozilla et son outil Thimble  dont le graphisme est assez sympathique soit dit en passant. Curieusement, cela me fait penser à un vieux projet de Mozilla  : Bespin, devenu par la suite Skywriter, projet actuellement inactif. :mrgreen:

La fondation Eclipse a son propre éditeur : Orion. L’éditeur est dans votre navigateur et utilisera les ressources de votre navigateur. 🙂

Vous trouverez d’autres « éditeurs », il suffit de suivre un peu l’actualité puisque cela devient un effet de mode. Tout comme on observe de plus en plus des compilateurs en ligne.

D’autre part, vous croiserez sur votre route d’internaute, des « éditeurs » comme jsFiddle. Je vous laisse découvrir son utilité 😀

VOUS AVEZ ADORÉ ? VOUS ALLEZ RIRE MAIS CET ARTICLE VOUS INTÉRESSERA.

♫ Dance the java with me ♫


Introduction

Je me lance sur ce petit article pour faciliter la tâche aux jeunes loups comme moi qui souhaiteraient maîtriser la création d’interface graphique avec Java ou tout simplement à tout ceux qui souhaitent débuter dans l’interfaçage graphique en Java. Pour cela, il est nécessaire de faire appel à la bibliothèque Swing. Petit rappel : Swing est une API graphique (ou bibliothèque graphique au choix) propre à JAVA.

Learn Java ? Easy as ABC ! (Apprendre Java ? Simple comme bonjour !)

Bon, ici je ne vous ferais pas de cours sur JAVA.

Si :

  1. Vous êtes français.
  2. Vous êtes débutant.

Je vous recommande vivement de lire le cours de cysboy, ou d’acheter le livre ou bien de télécharger le livre pour le mettre sur votre liseuse.

Indiana Jones et le cours de Java perdu

Autrement, je vous conseille vivement de vous partir à l’aventure et trouver sur Google ou Bing ce qui vous convient. Vous vous apercevrez que des cours il y en a à foison.

Vous êtes encore vieux jeu et vous préférez les livres ?

Pour cela je vous recommande d’acheter, de voler, ou d’emprunter « Programmer en Java » (dernière édition) écrit par Claude Delannoy et édité par Eyrolles dans leur collection Best-Of. Certes, c’est un pavé (citez moi un bon livre d’info qui n’est pas un pavé ? 🙄  ) mais son prix vaut largement le coup non ?

Ce livre comprend tout ce qu’on doit savoir en Java et traite aussi Swing et ses fonctionnalités.

Cela dit si vous êtes orienté jeu vidéo je vous conseille de vous procurer « Devenez un petit génie des jeux vidéo » édité par Pearson dans leur collection « Le Programmeur » écrit par Ian Cinnamon. Vous pouvez l’avoir allons disons à tout casser 20 € !

Création de ma fenêtre en Java

Vous aurez vivement besoin d’un IDE pour créer votre programme. Le plus connu pour le java est Eclipse. Je ne me pencherais pas sur le choix de l’IDE, mais je vous conseille de prendre Eclipse pour deux raisons :

  1. La grosse majorité des développeurs utilisent Eclipse.
  2. J’utilise Eclipse et les explications qui vont suivre sont surtout propre à Eclipse. :mrgreen:

Tout d’abord, vous suivez ce tutoriel où tout est bien expliqué (avec de zolies zimages d’ailleurs) afin de créer votre projet et votre classe. Ne copiez pas le code proposé, il est sympa, il marche, vous le verrez partout dans les cours sur Swing, moi je vous propose une autre méthode ici. Et notons aussi que votre package n’a pas à s’appeler obligatoirement « Ihm ». 😉


package Ihm;
//on importe tout le contenu de la bibliothèque swing
import javax.swing.*;
//je suis obligé de faire appel à AWT car j'en ai besoin pour gérer les 'layouts manager'(gestionnaires de placement)
import java.awt.*;
import java.awt.event.*;

//la classe hérite de JFrame (extends)
class mainwindow extends JFrame
//On construit maintenant la fenêtre
{
	//On met ici des variables de type private par exemple
	//constructeur
	public mainwindow()
{			//titre de la fenêtre
			setTitle("Window title");
			//taille de la fenêtre
			setSize(800,600);
			setResizable(true);
			//affiche la fenêtre au centre de l'écran
			setLocationRelativeTo(null);
			// ferme la fenêtre
			//si on ne met pas ça en réalité la fenêtre n'est pas fermée elle a juste "disparue"
			setDefaultCloseOperation(EXIT_ON_CLOSE);

}
}
//classe principale 'window'
public class window {

	/**
	 * @param args
	 */
	//classe principale dite classe main (static void)
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		JFrame window = new mainwindow();
		window.setVisible(true);

	}

}

Deux-trois p’tites remarques à propos du code. Nous avons créé là deux classes : La classe principale

public class window {
public static void main (String[] args)
...
}

La « classe secondaire » qui contient un constructeur)

class mainwindow extends JFrame {
...
public mainwindow()
{
...
}

L’intérêt de faire appel à une classe « secondaire »  ? Cela permet de garder notre classe principale où se trouvera la classe main « intacte » et de créer à coté des classes diverses qui permettront par la suite d’instancier plein d’objets. Bon, je sais, c’est peut être pas la meilleure méthode…D’autre part, je me dois de vous préciser qu’en écrivant import.javax.swing.* vous importez toute la bibliothèque swing (c’est l’étoile qui indique que vous importez tout 😛 ).

Il reste à savoir s’il ne serait pas plus sage d’appeler uniquement ceux dont on a besoin ? (Par exemple, nous utilisons l’objet JFrame qui appartient à l’API Swing, nous aurions pu écrire import.javax.swing.JFrame). Personnellement, moi je choisis la méthode dite « facile », on importe tout ! :mrgreen: Après évidemment si vous n’avez besoin que de JFrame, c’est comme quand il y a 15 personnes on ne va pas se fouler à appeler tout le monde si on a besoin uniquement de Mr Dupont, prenez la deuxième méthode !

En bref : Dans ce code source, vous noterez la création de deux classes dont une qui contient une classe main où on instancie un objet de type mainwindow qui sera en fait notre fenêtre (polymorphisme) en utilisant le constructeur de la seconde classe .

Le bonus

Exceptionnellement, il n’y en aura pas, mais cela étant dit, je vous offre en compensation une fuite d’information : Bientôt sur le lab de nerdycode, une fenêtre en java sous forme d’application 🙂