[sirius@localhost java]$ ls
     kangourou.java pet.java
     [sirius@localhost java]$ javac kangourou.java
     kangourou.java:1: cannot resolve symbol
     symbol : class animal 
     location: class kangourou
     class kangourou extends animal{
                             ^
     1 error

     kangourou.java:5: cannot resolve symbol
     symbol  : variable xpoids 
     location: class kangourou
           Kangoo.xpoids=25;
                  ^

Même type d'erreur sauf qu'il s'agit d'une variable inexistante dans la classe kangourou. Il s'agit souvent d'une faute de frappe.
Si on étudie un peu la nouvelle classe kangourou on remarque pas mal de changements. En particulier l'apparition d'une nouvelle méthode. Jusqu'à présent nous n'avions fait que des classes avec des variables mais on avait pas fait de programmes à vraissemblement parler. Pour faire un programme il faut bien évidemment un point d'entrée (une expression très courante en cracking ;). Il s'agit s'implement du début du programme. Ce point d'entrée a toujours le même profil (aprennez le par coeur) :

public static void main(String [] args)

Décomposons un peu ça. Tout d'abord le static permet de dire que la fonction est la même pour toutes les instances de la classe. Comme ça doit pas vous sembler ultra clair on va refaire un peu de POO.
Nous on a déclaré une classe kangourou. C'est bien joli mais c'est générique. En gros notre classe désigne tous les kangourous à travers le monde. Nous on veut travailler avec un seul kangourou. Dans notre exemple on en veut un précis qui s'appelle Kangoo (comme la caisse). On peut dire que Kangoo est une instance de tous les kangourous à travers le monde. On peut aussi entendre le terme occurence mais il est moins rattaché à la programmation. Bref une instance c'est un exemplaire.

Si on veut expliquer un peu plus le mot static on peut par exemple mettre la variable moyenne_de_vie en static dans la classe kangourou parce que tous les kangourous ont la même moyenne de vie (moyenne sur le monde).
public on a déjà vu ; ça veut dire que cette fonction est accessible par tout le monde... heureusement parce que c'est le point d'entrée du programme.
void main je pense que vous connaissez (mais pour ceux qui n'ont pas encore programmé ça veut dire que c'est la fonction principale et quelle ne renvoie aucun résultat).
Ensuite le String []args. Il s'agit évidemment des arguments du programme. Quelle est la différence avec le C ? Piou !! La classe String possède pas mal de méthodes et c'est largement à notre avantage. Le nom de la String n'est pas figé, rien ne vous empéche de mettre argv. Ensuite les crochets : ils peuvent être aussi bien devant que après le nom de la chaîne.
Autre spécificité : le premier argument est accessible par args[0] et le nombre d'agument s'obtient avec args.length(). Cette méthode renvoie un entier (int).

Programmation Objet et droits d'accès
Je vous ai dit qu'en Java tout était des classes. String en est une par exemple. Alors comment se fait-il qu'on ne fait pas appelle à sa librairie ?
L'explication est simple. La librairie java.lang.* est chargée automatiquement car elle contient... le noyau de Java. Sans elle pas de programme !
Maintenant vous allez me demander pourquoi on ne charge pas la classe int... Il y a quelques exceptions en Java : certains type basiques ont été gardés. Ainsi int, char, float, short, byte, long, double et boolean ne sont pas des classes. En revanche les tableaux (int [] ou byte [] etc) sont vraiment spéciaux, on peut les classer entre les types basiques et les classes. On verra peut-être ça (j'insiste sur le peut-être). Le mot clé null a aussi été conservé. Le type char a subit quelques modifications car il n'est plus sur 1 mais sur 2 octets !! Oui 2 pour le prix d'1 (en dirait du Bellemare au T.V. H.I.É.). Pourquoi deux octets ? Pour respecter la norme unicode. Ainsi on peut représenter tous les caractères à travers le monde. Tous ? Non ! Une bonne dose d'irréductibles caractères Chinois prennent trop de place pour en faire partie.
Pour en finir avec cette fonction main()... aprennez là par cœur et faites pas chier.

La première opération de notre programme est d'instancier un objet kangourou. Pour cela on utilise le même opérateur qu'en C++, l'opérateur new(). Cet opérateur permet de réserver de la place pour mettre au monde notre objet (un kangourou dans notre cas). Dans notre cas le kangourou s'appelle Kangoo. On verra la création d'objets plus en détail dans pas longtemps.

La ligne suivante est, une fois l'erreur corrigée (poids à la place de xpoids), une affectation tout ce qu'il y a de plus simple. On pourrait se demander si cela va provoquer une erreur car la classe kangourou ne possède pas d'attribut nommé 'poids'. Mais ça marche parce que la classe kangourou hérite de la classe animal qui possède justement l'attribut poids.
Une classe hérite des attributs et des méthodes de son père. La morale c'est vous pouvez être con, c'est pas de votre faute mais de celle de vos ancètres LoL.

J'en voit certains qui cogitent. En effet puisque l'attribut poids n'est pas public il doit être private et par conséquent la classe kangourou, bien que fille de la classe animal, ne devrait pas pouvoir accèder à cet atribut. En fait à la différence de C++, le droit d'accès par défaut est un droit qui s'appelle 'friendly' (nom non-officiel pompé sur le C++).
Un élément friendly est accessible uniquement aux classes de son package (pour tout à l'heure). Or dans notre cas nous n'avons pas défini de package donc l'accès se fait sans problème.

Il reste un type d'accès dont j'ai parlé ya pas mal de temps : protected. Un élément protected est public vis à vis de son package, de sa classe et de ses sous classes mais private vis à vis du reste.

Bref du plus accessible au moins accessible on a : public ; protected ; friendly ; private

Je sais que autant de texte à la suite c'est lourd alors je met une image entre les deux. Hésitez pas à faire une pause aussi.

 

Maintenant passons à un concept sympa : les packages.
Dans l'intro j'ai dit que les packages étaient l'équivalent des librairies. Contrairement à de simples fichiers d'entêtes dans le C et C++, les packages permettent de regrouper des classes par affinité.
Java propose une bonne dose de packages que l'on utilise pour programmer. Par exemple le package java.lang.* est automatiquement chargé. Il permet d'utiliser les fonctions System etc.
Donc un package c'est un ensemble de classes. Le symbole étoile de java.lang.* signifie que l'on prend toutes les classes du package java.lang.
Il est bien évidemment possible de créer ses propres packages mais là encore il y a des règles à respecter : Si on veut créer un package MonPackage il faut d'abord créer un répertoire du même nom et y mettre les classes du package. Ensuite il faut que les classes commencent par la ligne package MonPackage; pour déclarer la classe comme partie du package.

Les avantages : tout simplement la possibilité d'utiliser ses librairies personnels. Ainsi si on veut utiliser ses classes perso on mettra dans notre programme : import MonPackage.*;
J'ai aussi parlé aussi d'afinité et non sans raison puisque les accès friendly et protected se basent sur les relations inter-classes. En gros un package c'est un groupe de potes qui se connaissent bien, ils se dépannent quand ils sont dans la merde... Ils s'échangent donc plus facilement les données que deux classes étrangères.

Au niveau du compilateur : le compilateur recherche le répertoire qui porte exactement le même nom que le package. Il regarde dans les librairies standart de Java, dans le répertoire courant et dans les répertoires fixés dans la variable $CLASSPATH. Personnellement je ne l'ai pas fixé sous Linux car je met tout dans le même répertoire.

On reprend le travail avec nos classes habituelles :
---------------animal.java-------------
package p1;
class animal{
    protected int age;
    int poids;
    String nom;
}
------------fin animal.java----------

-----------kangourou.java----------
package p1;
class kangourou extends animal{
    private int longueur_de_saut;
}
---------fin kangourou.java--------

--------------prog.java---------------
import p1.*;
public class prog{
    animal inconu;

    prog()
    {
        try{
            inconu = new animal();
            inconu.age=5;
        }
        catch(Exception ex){System.out.println(ex);}
    }

    public static void main(String []args)
    {
        prog p=new prog();
    }
}
----------fin prog.java-------------

Déjà vous constatez que on a une classe dévoué à l'exécution du programme ; c'est bien plus 'propre' niveau programmation. Comme ça nos classes animal et kangourou sont totalement indépendantes et on pourra les réutiliser quand on le voudra.
Les classes animal et kangourou font partie du package p1. Les fichiers animal.java et kangourou.java se trouvent dans le répertoire p1 (qui se trouve dans mon rép courant). prog.java est dans le rep courant.

Quand on compile on a :

prog.java:4: p1.animal is not public in p1; cannot be accessed from outside package
	animal inconu;
        ^
prog.java:11: p1.animal is not public in p1; cannot be accessed from outside package
			inconu = new animal();
                                     ^
prog.java:11: animal() is not public in p1.animal; cannot be accessed from outside package
			inconu = new animal();
                                 ^
prog.java:13: age has protected access in p1.animal
			inconu.age=5;
                              ^
4 errors

Normal puisque on a pas déclaré nos classes comme public. Il faut mettre public class animal...
On va passer à une autre page car celle-ci est pas mal remplie.

Mais avant on va revoir très rapidement ce que on a vu et on va ajouter quelques truc :
Une classe est une description générique. Elle décrit un 'type'.
Une instance d'une classe est un 'objet'. Chaque objet a son existence propre cependant ils peuvent avoir des valeurs communes que l'on déclare par static.
Pour créer un objet (une instance) on utilise la fonction new().
Une classe doit se trouver dans un fichier java du même nom.
Par convention le nom d'une classe commence par une majuscule (et le nom du fichier .java aussi par conséquent).
En POO une variable est appelée un 'attibut' et une fonction est appelée une 'méthode'.
Par convention toujours, les noms des attributs et des méthodes commencent par une minuscules.
Il y a 4 types d'accès : private (accessible seulement par l'objet lui même), friendly (par défaut), protected (accessible si dans la même 'famille') et public (accessible par tous).
La notion de packages permet de créer des librairies et/ou de faire un système d'affinité.
La fonction principale a toujours le même profil : public static void main(String []args).

Pour ce qui est des conventions, des fois je les respecte des fois non...
Je viens de voir que j'ai oublié quelques concepts importants, on y go.