FAQ Java

public class Main {
  public static void main(String args[]) throws Exception{
    String str = "Jean Robert Marc Luc Pierre"; // chaine initiale
    String[] strout=str.split(" "); // le séparateur étant le caractère espace.

    System.out.println(java.util.Arrays.toString(strout)); // Affichage du tableau
    }
}

public class Main {
  public static void main(String args[]) throws Exception{
    String str = "Jean;Robert-Marc;Luc-Pierre"; // chaine initiale
    String[] strout=str.split(";|-"); // le séparateur étant les caractères - et ;.

    System.out.println(java.util.Arrays.toString(strout)); // Affichage du tableau
    }
}

public class Personne()
{
    String nom;
    String prenom;

    public Personne(String nom, String prenom)
    {
         this.nom=nom;
         this.prenom=prenom;
    }
}

ArrayList<String> listeTabZero=new ArrayList()<String>; // on notre objet ArrayList de String

// on cree nos objets
Personne p1,p2;
p1=new Personne("Dupont","pierre");
p2=new Personne("Dupont","charlotte");

// on ajoute les personnes dans la liste
listeTabZero.add(p1);
listeTabZero.add(p2);

LinkedList<String> listeChZero=new LinkedList()<String>; // on notre objet ArrayList de String

// on cree nos objets
Personne p1,p2;
p1=new Personne("Dupont","pierre");
p2=new Personne("Dupont","charlotte");

// on ajoute les personnes dans la liste
listeChZero.add(p1);
listeChZero.add(p2);

public class Acheteur() {
    private String nom;
    private String prenom;
    private int revenu;

    public Acheteur(String nom, String prenom, int revenu) {
         this.nom = nom;
         this.prenom = prenom;
         this.revenu = revenu;
    }

    public String obtenirNom() {
        return this.nom;
    }

    public String obtenirPrenom() {
        return this.prenom;
    }

    public String obtenirRevenu() {
        return this.revenu;
    }
}

/* 
 * On crée notre HashMap possédant des clés de type Integer
 * et des valeurs de type Acheteur.
 */
HashMap<Integer, Acheteur> listeXY = new HashMap<Integer, Acheteur>();

/* 
 * On crée nos Acheteurs.
 */
Acheteur a1, a2;
a1 = new Acheteur("Bond", "James", 777);
a2 = new Acheteur("Dupond", "Jacques", 200);

/* 
 * On ajoute à notre HashMap nos informations:
 * A l'ID 5, on aura l'Acheteur James Bond.
 * A l'ID 77, on aura l'Acheteur Jacques Dupond.
 */
listeXY.put(5, a1);
listeXY.put(77, a2);

/* 
 * On crée une HashMap contenant des clés de type String
 * et des valeurs de type Integer
 */
Map<String, Integer> map = new HashMap<String, Integer>();

// On suit les types indiqués : String pour la clé, Integer pour la valeur
map.put("Argument de type STRING", 1); 

/* On crée une HashMap contenant des clés 
 * et des valeurs sans type pré-défini
 */

/* 
 * On crée une HashMap contenant des clés de type String
 * et des valeurs de type Integer
 */
Map<String, Integer> map = new HashMap<String, Integer>();

// Un float à la place d'un String pour la clé
// Un String à la place d'un Integer
map.put(1.0f, "String"); // Uncompilable code

Map<String, Integer> map = new HashMap<String, Integer>();
map.put("String", 1);

// On supprime l'entrée correspondant à clé égale à "String"
map.remove("String");

Map<String, Integer> map = new HashMap<String, Integer>();
map.put("String", 1);

// Si une clé égale à "String" existe ...
if ( map.containsKey("String") )
    map.remove("String"); // ... Alors on la supprime.

Map<String, Acheteur> map = new HashMap<String, Acheteur>();

Acheteur a1 = new Acheteur("Bond", "James", 777);
map.put("String", a1);

// On souhaite récupérer l'Integer lié à la clé souhaitée
Acheteur a2 = (Acheteur)map.get("String");
System.out.println( a2.obtenirRevenu() ); // Retourne 777

String chemin = "c:\\monfichier.txt";

try{
  BufferedReader buf = new BufferedReader(new FileReader(chemin));

  try {
  String line;
  // on lit toutes les lignes du fichier
  while ((line = buff.readLine()) != null) {
    System.out.println(line);
  }
} finally {
    // on ferme notre fichier
    buf.close();
  }
} catch (IOException ioe) {
  System.out.println(ioe.toString());
}

private boolean isFinish = false; // Variable à modifier pour arrêter, ou non, notre Thread.

public void run() {
    boolean end = false;
        
    while( !end ) {
        try {
            // Votre Thread
                   
            // On fait une pause pour mettre à jour notre variable et voir si on stop ici.     
            synchronized(this) {
                Thread.yield();
                                
                fin = this.isFinish;
            } 
        } catch( InterruptedException e ) {}
    } 
} 

public synchronized void exit() {
     this.isFinish = true;
}

PrintWriter pw;
String fichier ="C:\\monfichier.txt"

    pw =  new PrintWriter(new BufferedWriter(new FileWriter(fichier)));
   
    pw.println("Ligne 1");
    pw.println("Ligne 2");
    pw.println("Avant dernière ligne");
    pw.println("Dernière ligne");
    
   // on ferme le fichier
    pw.close();

import java.io.*;

public class  Etudiant implements Serializable {
	private String nom,prenom;

	public Etudiant(String nom, String prenom){
		this.nom=nom;
		this.prenom=prenom;
	}

	public String getNom() { return nom; }

	public String getPrenom() { return prenom; }
}

import java.io.*;

public class Test {
	public static void main(String [] args){
		/*Création d'un tableau d'étudiants
		 * Le premier sert à stocker les étudiants à écrire
		 * Le second sert à récupérer les étudiants durant la lecture
		 */
		Etudiant[] writeEtudiant = new Etudiant[2];
		Etudiant[] readEtudiant = new Etudiant[2];	
		
		// Stockage des étudiants
		
		writeEtudiant[0] = new Etudiant("Bill","Sparrow");
		writeEtudiant[1] = new Etudiant("Jack", "Gates");
		try{
			/* Création du flux de sortie
			 * On précise le chemin du fichier, ici la racine du projet
			 * On écrit chaque Etudiant dans le fichier
			 * Le booléen signifie que les données seront ajoutées 
                         * au contenu du fichier
			 */
			ObjectOutputStream ecriture = new ObjectOutputStream(
                                    new FileOutputStream("Etudiant.dat",true));
			/* Ecriture des deux étudiants */
			ecriture.writeObject(writeEtudiant[0]);
			ecriture.writeObject(writeEtudiant[1]);
			/* Fermeture du fichier */
			ecriture.close();

			/* Création du flux d'entrée
			 * On précise le chemin du fichier, ici la racine du projet
			 * On lit chaque objet sérialisé par le biais de la méthode 
                         * readObject() qui est casté en Etudiant
			 */
			ObjectInputStream lecture = new ObjectInputStream(
                                   new FileInputStream("Etudiant.dat"));
			/* Lecture des deux étudiants */
			readEtudiant[0] = (Etudiant) lecture.readObject();
			readEtudiant[1] = (Etudiant) lecture.readObject();
			/* Fermeture du fichier */
			lecture.close();
			
			System.out.println(readEtudiant[0].getNom() + " " 
                        + readEtudiant[0].getPrenom());
			System.out.println(readEtudiant[1].getNom() + " "
                        + readEtudiant[1].getPrenom());
		}catch(Exception e){
			e.printStackTrace();
		}
	}

}

Robot robot = new Robot();
BufferedImage img = robot.createScreenCapture(new Rectangle(java.awt.Toolkit.getDefaultToolkit().getScreenSize()) );
// on enregistre dans un fichier png
            File f =new File("C:\\exemple.png");
            try {
                if (f != null) {
                    ImageIO.write(img, "png", new FileImageOutputStream(f));
                }
            } catch (Exception e) {
            }

Robot robot = new Robot();
BufferedImage img = robot.createScreenCapture( new Rectangle( frame.getX(), frame.getY(), frame.getWidth(), frame.getHeight() ));
// on enregistre dans un fichier png
            File f =new File("C:\\exemple.png");
            try {
                if (f != null) {
                    ImageIO.write(img, "png", new FileImageOutputStream(f));
                }
            } catch (Exception e) {
            }

Robot robot = new Robot();
BufferedImage img = robot.createScreenCapture(new Rectangle( 30, 100, 800, 600));
// on enregistre dans un fichier png
            File f =new File("C:\\exemple.png");
            try {
                if (f != null) {
                    ImageIO.write(img, "png", new FileImageOutputStream(f));
                }
            } catch (Exception e) {
            }

import java.net.Socket;
import java.net.ServerSocket;

public class ServerEcho {

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

        // création de la socket
        int port = 1989;
        ServerSocket serverSocket = new ServerSocket(port);
        System.err.println("Serveur lancé sur le port : " + port);

        // repeatedly wait for connections, and process
        while (true) {

            // on reste bloqué sur l'attente d'une demande client
            Socket clientSocket = serverSocket.accept();
            System.err.println("Nouveau client connecté");

            // on ouvre un flux de converation
            In  in  = new In (clientSocket);
            Out out = new Out(clientSocket);

            // chaque fois qu'une donnée est lue sur le réseau on la renvoi sur le flux d'écriture.
            // la donnée lue est donc retournée exactement au même client.
            String s;
            while ((s = in.readLine()) != null) {
                out.println(s);
            }

            // on ferme les flux.
            System.err.println("Connexion avec le client terminée");
            out.close();
            in.close();
            clientSocket.close();
        }
    }
}

public class Main {
	
	private static List<String> strings ;

	public static void main(String[] args) {
		strings = new ArrayList<String>();
		
		strings.add("Bonjour ");
		strings.add("tu ");
		strings.add("vas ");
		strings.add("bien ");
		strings.add("?");
		
		for(int i=0;i<strings.size();i++){
			System.out.print(strings.get(i));
		}
	}
	
}

public class Main {
	
	private static List<String> strings ;

	public static void main(String[] args) {
		strings = new ArrayList<String>();
		
		strings.add("Bonjour ");
		strings.add("tu ");
		strings.add("vas ");
		strings.add("bien ");
		strings.add("?");
		
		Iterator<String> chaine = strings.iterator();
		while(chaine.hasNext()){
			System.out.print(chaine.next());
		}
	}
	
}

public class Main {
	
	private static List<String> strings ;

	public static void main(String[] args) {
		strings = new ArrayList<String>();
		
		strings.add("Bonjour ");
		strings.add("tu ");
		strings.add("vas ");
		strings.add("bien ");
		strings.add("?");
		
		for(String s : strings){
			System.out.print(s);
		}
	}
	
}

import java.net.*;
import java.io.*;

public class EchoClient {
  public static void main(String[] args) {
    String hostname = "localhost";
    if (args.length > 0) {
      hostname = args[0];
    }
    // on crée les flux d'entrées sorties
    PrintWriter out = null;
    BufferedReader networkIn = null;
    try {
      Socket theSocket = new Socket(hostname); // on crée la socket
      networkIn = new BufferedReader(new InputStreamReader(theSocket.getInputStream())); //on initialise le flux de lecture sur le réseau.
      BufferedReader userIn = new BufferedReader(new InputStreamReader(System.in)); // on se prépare à lire les entrées sur le clavier
      out = new PrintWriter(theSocket.getOutputStream());
      System.out.println("Connecté au serveur");

      // on boucle sur la lecture du reseau
      while (true) {
        String line = userIn.readLine();
        if (line.equals(".")) break; // on sort de la boucle si l'on rencontre un point.
        out.println(line);
        out.flush();
        System.out.println(networkIn.readLine());
      }
    }
    catch (IOException e) {
      System.err.println(e);
    }
    finally {
      try {
        if (networkIn != null) networkIn.close();
        if (out != null) out.close();
        System.out.println("Connexion terminée");
      }
      catch (IOException e) {}
    }
  }
}

import java.awt.GridLayout;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Observable;
import java.util.Observer;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

public class Main {

	public static void main(String[] args) {
		SDZFrame frame = new SDZFrame();
		frame.setDefaultCloseOperation(SDZFrame.EXIT_ON_CLOSE);
		frame.pack();
		frame.setVisible(true);
	}

}

class SDZFrame extends JFrame {

	private static final long serialVersionUID = 8459041084584493795L;

	/**
	 * Constructeur.
	 */
	public SDZFrame() {
		super("desin pattern Observer");
		init();
	}

	/**
	 * La méthode suivante permet d'initialiser l'IHM de l'application.
	 */
	private void init() {
		JLabel label1 = new JLabel("Saisir une valeur: ");
		JLabel label2 = new JLabel("Saisir une valeur: ");
		JLabel label3 = new JLabel("La valeur saisie est: ");
		setLayout(new GridLayout(3, 3, 2, 2));

		StringObservable observable = new StringObservable();

		add(label1);
		SDZTextField textfield1 = new SDZTextField(observable);
		add(textfield1);

		add(label2);
		SDZTextField textfield2 = new SDZTextField(observable);
		add(textfield2);

		add(label3);
		SDZLabel label4 = new SDZLabel(observable);
		add(label4);

	}

}

class SDZLabel extends JLabel implements Observer {

	private static final long serialVersionUID = 1494388745926012891L;

	public SDZLabel(StringObservable observable) {
		observable.addObserver(this);
	}

	@Override
	// Cette méthode est appelée par l'objet observé.
	public void update(Observable o, Object arg) {
		setText(arg.toString());
	}

}

class SDZTextField extends JTextField implements Observer, KeyListener {

	private static final long serialVersionUID = -4486493690639803915L;

	private StringObservable observable;

	public SDZTextField(StringObservable observable) {
		observable.addObserver(this);
		this.observable = observable;
		/*
		 * nous ajoutons un listener sur le JTextField afin de détecter les
		 * changements.
		 */
		addKeyListener(this);
	}

	@Override
	// Cette méthode est appelée par l'objet observé.
	public void update(Observable o, Object arg) {
		setText(arg.toString());
	}

	@Override
	public void keyPressed(KeyEvent e) {
	}

	@Override
	public void keyReleased(KeyEvent e) {
		// nous changeons la valeur de l'objet observé.
		observable.setValue(getText());
	}

	@Override
	public void keyTyped(KeyEvent e) {
	}

}

/**
 * Classe StringObservable. 

 * Cette classe sera observée par des observateur. Si le paramètre change
 * d'état, alors nous notifions les observateurs.
 * 
 * @author Damien
 * 
 */
class StringObservable extends Observable {

	/**
	 * Le paramètre que nous voulons observé
	 */
	private String value;

	public StringObservable() {
		value = "";
	}

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
		/*
		 * value vient de changer de valeur ? Alors nous notifons les
		 * observateurs.
		 */
		setChanged();
		notifyObservers(value);
	}

}

java.util.Collections.synchronizedSet(java.util.Set<T>)

public class Personne
{
	
	private String nom = null;
	
	private String prenom = null;
	
	public Personne() {
		this("","");
	}

	public Personne(String nom, String prenom) {
		this.nom = nom;
		this.prenom = prenom;
	}

	public String getNom() {
		return nom;
	}

	public void setNom(String nom) {
		this.nom = nom;
	}

	public String getPrenom() {
		return prenom;
	}

	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((nom == null) ? 0 : nom.hashCode());
		result = prime * result + ((prenom == null) ? 0 : prenom.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Personne other = (Personne) obj;
		if (nom == null) {
			if (other.nom != null)
				return false;
		} else if (!nom.equals(other.nom))
			return false;
		if (prenom == null) {
			if (other.prenom != null)
				return false;
		} else if (!prenom.equals(other.prenom))
			return false;
		return true;
	}
	
	@Override
	public String toString() {
		return "Personne [nom=" + nom + ", prenom=" + prenom + "]";
	}

}

public class Main {

	public static void main(String[] args) {
		// Création du Set
		Set demoSet = new HashSet();
		
		// Création des objets Personne pour la démonstration
		Personne p1 = new Personne("Syrion75","");
		Personne p2 = new Personne("Dupont","Alain");
		
		// Alimentation du Set
		demoSet.add(p1);
		System.out.println(demoSet.size()); // affiche 1
		demoSet.add(p2);
		System.out.println(demoSet.size()); // affiche 2
		demoSet.add(p1); // p1 étant déjà présent dans le set, il ne sera pas ajouté.
		System.out.println(demoSet.size()); // affiche 2	
	}

}

public class Main {

	public static void main(String[] args) {
		// Création du Set
		Set demoSet = new LinkedHashSet();
		
		// Création des objets Personne pour la démonstration
		Personne p1 = new Personne("Syrion75","");
		Personne p2 = new Personne("Dupont","Alain");
		
		// Alimentation du Set
		demoSet.add(p1);
		System.out.println(demoSet.size()); // affiche 1
		demoSet.add(p2);
		System.out.println(demoSet.size()); // affiche 2
		demoSet.add(p1); // p1 étant déjà présent dans le set, il ne sera pas ajouté.
		System.out.println(demoSet.size()); // affiche 2	
	}

}

public class Main {

	public static void main(String[] args) {
		// Création du Set
		Set demoSet = new TreeSet(new PersonneComparator());
		
		// Création des objets Personne pour la démonstration
		Personne p1 = new Personne("Syrion75","");
		Personne p2 = new Personne("Dupont","Alain");
		
		// Alimentation du Set
		demoSet.add(p1);
		System.out.println(demoSet.size()); // affiche 1
		demoSet.add(p2);
		System.out.println(demoSet.size()); // affiche 2
		demoSet.add(p1); // p1 étant déjà présent dans le set, il ne sera pas ajouté.
		System.out.println(demoSet.size()); // affiche 2	
	}

}

class PersonneComparator implements Comparator
{

	@Override
	public int compare(Object o1, Object o2) {
		System.out.println("Comparaison de ["+ o1 +"] et ["+ o2 +"].");
		if( o1 == null && o2 == null ){
			return 0 ;
		} else if ( o1 == null ) {
			return -1 ;
		} else if ( o2 == null ) {
			return 1 ;
		}
		Personne p1 = (Personne)o1;
		Personne p2 = (Personne)o2;
		int result = p1.getNom().compareTo(p2.getNom());
		if(result == 0){
			result = p1.getPrenom().compareTo(p2.getPrenom());
		}
		return result;
	}
	
}

Connection con; // la connexion doit être initialisée
public void afficheEurope()
{
    String requete = "select * from pays where Continent='Europe'";
    try {
	stmt = con.createStatement(); // on crée le statement
	ResultSet rs = stmt.executeQuery(requete); // on execute la requête
	while (rs.next()) {
		int id = rs.getInt("Id");
		String pays = rs.getString("Nom_Pays");
		System.out.println(id+" - "+pays);
	}
	stmt.close();
	con.close();
    } catch(SQLException ex) {
	System.err.println("SQLException: " + ex.getMessage());
    }
}

public class Personne
{ 
	
	private String nom = null;
	
	private String prenom = null;
	
	public Personne() {
		this("","");
	}

	public Personne(String nom, String prenom) {
		this.nom = nom;
		this.prenom = prenom;
	}

	public String getNom() {
		return nom;
	}

	public void setNom(String nom) {
		this.nom = nom;
	}

	public String getPrenom() {
		return prenom;
	}

	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((nom == null) ? 0 : nom.hashCode());
		result = prime * result + ((prenom == null) ? 0 : prenom.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Personne other = (Personne) obj;
		if (nom == null) {
			if (other.nom != null)
				return false;
		} else if (!nom.equals(other.nom))
			return false;
		if (prenom == null) {
			if (other.prenom != null)
				return false;
		} else if (!prenom.equals(other.prenom))
			return false;
		return true;
	}
	
	@Override
	public String toString() {
		return "Personne [nom=" + nom + ", prenom=" + prenom + "]";
	}

}

public class Main {

		public static void main(String[] args) {
			// Création du Set
			Set demoSet = new HashSet();
			
			// Création des objets Personne pour la démonstration
			Personne p1 = new Personne("Syrion75","");
			Personne p2 = new Personne("Dupont","Alain");
			Personne p3 = new Personne("Daudet","Alphonse");
			
			// Alimentation du Set
			demoSet.add(p1);
			demoSet.add(p2);
			demoSet.add(p3);
			
			// Parcourir le Set
			Iterator its = demoSet.iterator();
			while(its.hasNext()) {
				System.out.println(its.next());
			}
			
		}
	
}

public class Main {

		public static void main(String[] args) {
			// Création du Set
			Set<Personne> demoSet = new HashSet<Personne>();
			
			// Création des objets Personne pour la démonstration
			Personne p1 = new Personne("Syrion75","");
			Personne p2 = new Personne("Dupont","Alain");
			Personne p3 = new Personne("Daudet","Alphonse");
			
			// Alimentation du Set
			demoSet.add(p1);
			demoSet.add(p2);
			demoSet.add(p3);
			
			// Parcourir le Set
			for(Personne p : demoSet){
				System.out.println(p);
			}
			
		}
	
}

public class ServeurSingleton
{
	
	private static ServeurSingleton instance ;
	
	private ServerSocket socket ;
	
	private ServeurSingleton() {
		// du code
		try {
			socket = new ServerSocket(80);
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
	
	public static ServeurSingleton getInstance(){
		if(instance==null){
			instance = new ServeurSingleton();
		}
		return instance ;
	}
	
	public int getPort(){
		return socket.getLocalPort();
	}
	
}

public class Main {
	
	public static void main(String[] args) {
		ServeurSingleton serveur = ServeurSingleton.getInstance();
		System.out.println("Main :" + serveur.getPort());
		methode();
	}
	
	// Une autre méthode qui manipule l'objet ServeurSingleton. 
	public static void methode(){
		ServeurSingleton serveur = ServeurSingleton.getInstance();
		System.out.println("methode :" + serveur.getPort());
	}
	
}

public class ServeurSingleton
{
	
	private static ServeurSingleton instance ;
	
	private ServerSocket socket ;
	
	private ServeurSingleton() {
		// du code
		try {
			socket = new ServerSocket(80);
			Thread.sleep(2000); // simulation d'une construction qui prend du temps.
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	// Nous devons utiliser le mot clé synchronized pour limiter le nombre d'accès simultané à la classe.
	public synchronized static ServeurSingleton getInstance(){
		if(instance==null){
			instance = new ServeurSingleton();
		}
		return instance ;
	}
	
	public int getPort(){
		return socket.getLocalPort();
	}
	
}

// Nous passons par des Threads afin de simuler des accès asynchrones
public class Main extends Thread {
	
	public Main(String name) {
		super(name);
	}

	public static void main(String[] args) {
		new Main("Thread 1").start();
		new Main("Thread 2").start();
		new Main("Thread 3").start();
	}
	
	@Override
	public void run() {
		System.out.println("Début du :" + getName());
		System.out.println("Récupérer l'instance de ServeurSingleton (dans " + getName() + ")");
		ServeurSingleton serveur = ServeurSingleton.getInstance();
		System.out.println("ServeurSingleton (dans " + getName() + ")");
		System.out.println("Main :" + serveur.getPort() + " (dans " + getName() + ")");
		System.out.println("Fin du :" + getName());
	}
	
}

Connection con; // la connexion doit être initialisée
public void afficheEurope()
{
    String requete = "insert into pays(Id, Nom_Pays, Continent) values(4,'Chine','Asie')";
    try {
	stmt = con.createStatement(); // on crée le statement
	int nbline = stmt.executeUpdate();; // on execute la requête
	System.out.println("Nombre de lignes modifiées : "+nbline);
	stmt.close();
	con.close();
    } catch(SQLException ex) {
	System.err.println("SQLException: " + ex.getMessage());
    }
}

class MaClasse {
  public MaClasse (int nombre) {
    variable = nombre ;
  }
  
  public int aff () {
    return variable ;
  }
  
  int variable ;
}

public class Essais {
  public static void main (String [] args) {
    MaClasse instance = new MaClasse (38) ;   // OK : un nouvel objet est créé
    System.out.println( aff() ) ;             // erreur : la méthode aff() n'est pas associée à une instance
  }
}

System.out.println( instance.aff() ) ;

class MaClasse {
  public MaClasse (int nombre) {
    variable = nombre ;
  }
  
  public static int aff () {
    return 5 ;      // il n'est pas possible d'accéder ici à "variable"
  }
  
  private int variable ;
}

public class Essais {
  public static void main (String [] args) {
    System.out.println( Essais.aff() ) ;
  }
}

class MaClasse {
  public MaClasse (int nombre) {
    variable = nombre ;
    compteur++ ;
  }
  
  private int getVariable () {
    return variable ;
  }
  
  public static int getCompteur () {
    return compteur ;
  }
  
  private int variable ;
  private static int compteur ;
}

public class Essais {
  public static void main (String [] args) {
    MaClasse objet = new MaClasse (78) ;
    System.out.println( MaClasse.getCompteur() ) ;
    objet = new MaClasse (45) ;
    System.out.println( MaClasse.getCompteur() ) ;
  }
}

//importation des différentes bibliothèques
import java.applet.*;
import java.swing.*;

public class Hello extends Applet
{
   private JLabel lab;
   public void init()
   {
       //code d'initialistaion
       lab=new JLabel("Hello World");
       
   }
   
   public void start()
   {
       //code de d'éxécution
       this.add(lab);
   }
   
   public void stop()
   {
       //code de suspension de l'execution
   }
   
   public void destroy()
   {
       //code de terminaison
   }
}

class Point {
  public Point (double x, double y) {
    this.x = x ;
    this.y = y ;
  }
  
  private double x, y ;
}

class Point {
  public Point (double x, double y) {
    this.x = x ;
    this.y = y ;
  }
  
  public void setX (double x) {
    this.x = x ;
  }
  
  public void setY (double y) {
    this.y = y ;
  }
  
  public double getX () {
    return x ;
  }
  
  public double getY () {
    return y ;
  }
  
  private double x, y ;
}

class Point {
  // les méthodes que nous avons déjà programmées
  
  public double getR () {       // r : la distance du point à l'origine
    return Math.sqrt( x*x + y*y ) ;
  }
  
  public double getTheta () {   // theta : l'angle
    return Math.acos( x / getR() ) ;  // car x = r cos(theta) <=> theta = acos( x/r )
  }
  
  private void changerPolaires (double r, double theta) {
    // méthode pour nous, donc privée
    x = r * Math.cos(theta) ;
    y = r * Math.sin(theta) ;
  }
  
  public void setR (double r) {
    changerPolaires( r, getTheta() ) ;
  }
  
  public void setTheta (double theta) {
    changerPolaires( getR(), theta ) ;
  }
  
  private double x, y ;
}