Bonjour à tous et à toutes,

je fais une petite ouverture sur le Java

"Le langage Java est un langage de programmation informatique orienté objet créé par James Gosling et Patrick Naughton employés de Sun Microsystems avec le soutien de Bill Joy (cofondateur de Sun Microsystems en 1982), présenté officiellement le 23 mai 1995 au SunWorld." (Wikipédia : http://fr.wikipedia.org/wiki/Java_%28langage%29)

Le Java, à ne pas confondre avec Javascript, est un langage assez utilisé sur Terre de nos jours pour la programmation.

je dis ca, parce que j'avais fait une petite ouverture sur le Scheme (https://forum.pcastuces.com/ouverture_sur_le_scheme-f19s9380.htm), qui avait plutot bien marcher, parce qu'elle a été lu près de 1600 fois.

cette fois ci, j'aimerai bien avoir des questions, ou réponses pourquoi pas =).

Le Scheme n'est pas tellement utilisé... le Java lui si, donc si vous voulez apprendre un langage informatique sympa (après ca dépend aussi des utilités!), apprenez le Java, ou le C, ou le C++, mais pas le Scheme.

le Java est un langage que je trouve bien pratique, et il ressemble assez au C, si ce n'est qu'en C quand on compare des variables, on ne pas tellement attention, on utilise ==, on ne compare pas les adresses de stockage mais les valeures, en Java tous les types de variables non primitifs ne se comparent pas avec de simples églales comme en C, le == compare les emplacements de stockage en Java, les pointeurs...

cette ouverture n'est cependant pas là pour vous permettre de coder des programmes complexes, mais seulement pour faire une ouverture sur ce langage fort sympathique...

en fait, cette ouverture à une seconde utilité, ce langage est également utilisé dans des écoles pour apprendre à programmer, et j'offre ici des TPs qui pourront être utiles à certains .

donc si vous voulez étudier un peu ce langage, ou si ces TPs peuvent vous aider, venez ici, faites tourner!
pour toutes questions, contactez moi par MP

IDE utilisés : Eclipse : http://www.01net.com/telecharger/windows/Programmation/creation/fiches/49057.html

on peut également se servir de DrJava, qui permet de faire une conversation en temps réel avec nos lignes de code. (PS : je n'ai pas trouvé d'adresse sur le net...)

DrJava est moins puissant, et comporte des failles comparé à des IDE normaux.

Remarques préliminaires :
dans l'IDE, les ' // ' servent à mettre une ligne en commentaire (ils peuvent être placés à n'importe quel endroit sur la ligne), donc toutes les lignes commençant par un ' ; ' ne sont pas exécutées par DrScheme.
pour mettre plusieurs lignes de suite en commentaire, il faut commencer par ouvrir les commentaires pas ' /* ' et finir les commentaires par ' */ '.
le fait de mettre ' /** ' sert à référencer la fonction pour la Javadoc (lorsque l'on lance la Javadoc, une documentation sur les fonctions écrites se créé automatiquement, et prend en particulier les commentaires commençant pas ' /** ')
faites toujours bien attention aux parenthèses! c'est quelque chose qu'il ne faut pas oublier en java non plus... c'est moins grave qu'en Scheme, mais à une parenthèse près, votre srcipt plante. et n'oubliez pas de créer des objets (public ou private classe Objet { } )

lors d'un changement du script, vous devez exécuter à nouveau le programme pour qu'il fonctionne avec les modifications apportées.

pour obtenir un script bien tablué (avec les espaces appropriés en début de fonction et dans la fonction, pour que ce soit lisible!), vous pouvez le faire à la main, ou le faire intelligement : selectionnez tout le texte (control + A), et cliquez sur la touche tabulation, la mise en page se fait automatiquement.

____________________

public class Point {
/* - La classe Point minimale : */
private double x; // Abscisse de type double
private double y; // Ordonnee de type double

/** Constructeur du point de coordonnées (0,0) */
public Point() {
this.x = 0;
this.y = 0;
}
/** Constructeur du point de coordonnées (a,b) */
public Point(double a, double b) {
this.x = a;
this.y = b;
}
/** Accès vers l'abscisse */
public double voirAbscisse() {
return this.x;
}
/** Accès vers l'ordonnée */
public double voirOrdonnee() {
return this.y;
}
/* Tests :
Point p1 = new Point (2, 3);
Point p2 = new Point (3, -1);
> p1.voirAbscisse()
2.0
> p2.voirOrdonnee()
-1.0
OK
*/

/* - Comparer des Points : */
/** Comparateur de Points */
public boolean equals(Point p) {
return (p.x==this.x) && (p.y==this.y);
}
/* Tests :
> p1
Point d'abscisse 2.0 et d'ordonnée 5.0.
> p3
Point d'abscisse 2.0 et d'ordonnée 5.0.
> p1==p3
false
> p1.equals(p3)
true
> p3.equals(p1)
true
> p1.equals(p2)
false
OK
*/

/* - Voir les Points : */
/** Convertisseur en chaine de caractères */
public String toString() {
return "Point : x = " + this.x + ", y = " + this.y + ".";
}
/* Tests :
> Point p1 = new Point(2, 5)
> Point p2 = new Point(3, 1)
> Point p3 = new Point(2, 5)
> p2.toString()
"Point : x = 2, y = 5"
> "p1 vaut "+p1.toString()
"p1 vaut Point : x = 2, y = 5"
> "p1 vaut "+p1
"p1 vaut Point : x = 2, y = 5"
> "p1 vaut "+p1+"\np2 vaut "+p2+"\np3 vaut "+p3
"p1 vaut Point : x = 2.0, y = 5.0.
p2 vaut Point : x = 3.0, y = 1.0.
p3 vaut Point : x = 2.0, y = 5.0."
OK
*/

/* - Continuer et décrire le comportement des Points : */
/** Méthode : savoir si le point est sur l'axe des ordonnées */
public boolean estSurLAxeY() {
return this.x==0;
}
/** Méthode : calculer la distance entre deux points */
public double distanceA(Point p) {
return Math.sqrt((Math.pow(this.x, 2))+(Math.pow(this.y, 2)));
}
/** Méthode : construit le symétrique du point */
public Point symY() {
return new Point(-this.x, this.y);
}
/* Tests :
> Point p1 = new Point(2, 5)
> Point p2 = new Point(0, 1)
> Point p3 = new Point(4, 5)
> p1.estSurLAxeY()
false
> p2.estSurLAxeY()
true
> p3.distanceA(p2)
6.4031242374328485
> p2.distanceA(new Point())
1.0
> p3.symY()
Point : x = -4.0, y = 5.0.
OK
*/

/** Méthode : calcul le milieu de deux points */
public Point milieuPoints(Point p){
return new Point((this.x+p.x)/2, (this.y+p.y)/2);
}
/* Tests :
> Point p1 = new Point()
> Point p2 = new Point(2, 0)
> p2.milieu(p1)
Point : x = 1.0, y = 0.0.
OK
*/


/* --SUITE-- */

/** Méthode : change l'abscisse d'un Point */
public void chgAbscisse(double x) {
this.x = x;
}
/** Méthode : change l'ordonnée d'un Point */
public void chgOrdonnee(double y) {
this.y = y;
}
/* Tests :
> Point p1 = new Point(12, 12)
> Point p2 = new Point(3, 3)
> p1
Point : x = 12.0, y = 12.0.
> p2
Point : x = 3.0, y = 3.0.
> p1=p2
Point : x = 3.0, y = 3.0.
> p2.chgAbscisse(4)
> p1
Point : x = 4.0, y = 3.0.
> p2
Point : x = 4.0, y = 3.0.
> p2 = new Point(5, 5)
Point : x = 5.0, y = 5.0.
> p1
Point : x = 4.0, y = 3.0.
OK
*/

/** Méthode : translate le Point de dx et dy */
public void translater(double dx, double dy) {
this.x = this.x + dx;
this.y = this.y + dy;
}
/* - Seuls les Segments bougent, pas les Points */
/** Méthode : rend une copie du Point courant */
public Point seDupliquer() {
return new Point(this.x, this.y);
}

}

public class Segment {
/** - La classe segment minimale : */
private Point a;
private Point b;

/** Constructeur du segment [a,b] */
public Segment(Point a, Point b) {
this.a = a;
this.b = b;
}
/** Accès à la 1er extrémitée du segment */
public Point extrem1() {
return a;
}
/** Accès à la 2eme extrémitée du segment */
public Point extrem2() {
return b;
}
/* Tests :
> Segment s2 = new Segment (new Point (3, -1), new Point (6, 3))
> s2.extrem2()
Point : x = 6.0, y = 3.0.
> s2.extrem2().voirAbscisse()
6.0
nature de la valeur contenue dans la case mémoire identifiée pas s2 : pointeur
référence à une instance de la classe Segment
> s2
Segment@feecca
on ne peut pas changer s2 pour mettre p comme son extrémité 1, on définit donc p comme l'extrémité 1 de s2
> Point p = s2.extrem1()
OK
*/

/** Convertisseur en chaine de caratrères */
public String toString() {
return "Segment : ["+this.a+","+this.b+"]";
}
/* Tests :
> s2
Segment : [Point : x = 3.0, y = -1.0.,Point : x = 6.0, y = 3.0.]
OK
*/

/* - Comparer des Segments :
> Segment s1 = new Segment (new Point (2, 5), new Point (3, 1))
> Segment s2 = new Segment (new Point (3, 1), new Point (2, 5))
> Segment s3 = new Segment (new Point (2, 5), new Point (0, 0))
> s1==s2
false
OK
*/

/** 01 Comparateur de Segments */
public boolean equals1(Segment s) {
return this.a == s.a && this.b == s.b ||
this.a == s.b && this.b == s.a;
}
/* Tests :
> Point p1 = new Point (2, 5)
> Point p2 = new Point (3, 1)
> Point p3 = new Point (0, 0)
> Segment s1 = new Segment (p1, p2)
> Segment s2 = new Segment (p2, p1)
> Segment s3 = new Segment (p1, p3)
> s1.equals1(s3)
false
> s3.equals1(s1)
false
> s1.equals1(s2)
true
OK
*/

/* 02
> Segment s1 = new Segment (new Point (2, 5), new Point (3, 1))
> Segment s2 = new Segment (new Point (3, 1), new Point (2, 5))
> Segment s3 = new Segment (new Point (2, 5), new Point (0, 0))
> s1.equals1(s3)
false
> s3.equals1(s1)
false
> s1.equals1(s2)
false
OK
*/

/** 03 Comparateur de Segments */
public boolean equals(Segment s) {
return this.a.equals(s.a) && this.b.equals(s.b) ||
this.a.equals(s.b) && this.b.equals(s.a);
}
/* Tests :
> Segment s1 = new Segment (new Point (2, 5), new Point (3, 1))
> Segment s2 = new Segment (new Point (3, 1), new Point (2, 5))
> Segment s3 = new Segment (new Point (2, 5), new Point (0, 0))
> s1.equals(s3)
false
> s3.equals(s1)
false
> s1.equals(s2)
true
OK
*/

/* - Voir les Segments :
Tests :
> Point p1 = new Point (2, 5)
> Point p2 = new Point (3, 1)
> Segment s1 = new Segment (p1, p2)
> s1
Segment : [Point : x = 2.0, y = 5.0.,Point : x = 3.0, y = 1.0.]
OK
*/

/* - Continuer de décrire le comportement des segments : */
/** Méthode : rendre la longueur du segment courant */
public double longueur() {
return this.a.distanceA(this.b);
}
/** Méthode : rendre le Point milieu du Segment courant */
public Point milieu() {
return new Point ((this.a.voirAbscisse()+this.b.voirAbscisse())/2,
(this.a.voirOrdonnee()+this.b.voirOrdonnee())/2);
}
/** Méthode : savoir si le Segment courant coupe l'axe des ordonnées */
public boolean coupeLAxeY() {
return (this.a.voirAbscisse() <= 0 && this.b.voirAbscisse() >= 0) ||
(this.a.voirAbscisse() >= 0 && this.b.voirAbscisse() <= 0);
}
/** Méthode : rendre le Segment symétrique du Segment courant par rapport à l'axe des ordonnées */
public Segment symY() {
return new Segment (this.a.symY(), this.b.symY());
}
/** Méthode : savoir si le Segment courant possède une extrémitée commune avec le Segment s */
public boolean extremCummune(Segment s) {
return this.a.equals(s.a) ||
this.b.equals(s.b) ||
this.a.equals(s.b) ||
this.b.equals(s.a);
}
/* Tests :
> Segment s1 = new Segment (new Point (2, 5), new Point (3, 1))
> Segment s2 = new Segment (new Point (3, 1), new Point (2, 5))
> Segment s3 = new Segment (new Point (2, 5), new Point (0, 0))
> Segment s4 = new Segment (new Point (-2, 5), new Point (2, 5))
> Segment s5 = new Segment (new Point (5, 2), new Point (5, 2))

> s3.longueur()
5.385164807134504

> s3.milieu()
Point : x = 1.0, y = 2.5.
> s4.milieu()
Point : x = 0.0, y = 5.0.

> s3.coupeLAxeY()
false
> s4.coupeLAxeY()
true

> s3.symY()
Segment : [Point : x = -2.0, y = 5.0.,Point : x = -0.0, y = 0.0.]
> s4.symY()
Segment : [Point : x = 2.0, y = 5.0.,Point : x = -2.0, y = 5.0.]

> s3.extremCummune(s4)
true
> s3.extremCummune(s5)
false
OK
*/

/* --RAJOUT DEBUT-- */

/** Méthode : voir si la droite courante coupe la droite placée en paramètre */
public boolean coupeDroite(Segment s) {
double x1 = this.b.voirAbscisse() - this.a.voirAbscisse();
double y1 = this.b.voirOrdonnee() - this.a.voirOrdonnee();
double x2 = s.b.voirAbscisse() - s.a.voirAbscisse();
double y2 = s.b.voirOrdonnee() - s.a.voirOrdonnee();
return (x1 * y2 - y1 * x2) != 0; // determinant
}
/* Tests :
> Segment s8 = new Segment (new Point (0, 0), new Point (5, 5))
> Segment s9 = new Segment (new Point (0, 11), new Point(11, 11))
> s8.coupeDroite(s9)
> true
> Segment s10 = new Segment (new Point (0, 0), new Point (5, 5))
> Segment s11 = new Segment (new Point (1, 1), new Point(6, 6))
> s10.coupeDroite(s11)
> false
OK
*/

/* --RAJOUT FIN-- */


/* --SUITE-- */

/* - Translater et centrer des Segments : */
/** Méthode : translate le Segment de dx et dy */
public void translater(double dx, double dy) {
this.a.translater(dx, dy);
this.b.translater(dx, dy);
}
/** Méthode : centre le Segment sur l'origine */
public void centrer() {
Point c = this.milieu();
this.translater(-c.voirAbscisse(), -c.voirOrdonnee());
}

/* - Seuls les Segments bougents, pas les Points : */
/** Méthode : translate le Segment de dx et dy sans bouger les Points extrémités originaux */
public void translater2(double dx, double dy) {
Point a2 = this.a.seDupliquer();
Point b2 = this.b.seDupliquer();
a2.translater(dx, dy);
b2.translater(dx, dy);
this.a = a2;
this.b = b2;
}
/** Méthode : centre le Segment sur l'origine sans bouger les Points extrémités originaux */
public void centrer2() {
Point c = this.milieu();
this.translater2(-c.voirAbscisse(), -c.voirOrdonnee());
}

/* --RAJOUT DEBUT-- */

/** Méthode : diviser par deux la longueur d'un Segment, en gardant le meme centre */
public void diviser() {
Point c = this.milieu();
double dx = (c.voirAbscisse() - this.extrem1().voirAbscisse()) / 2;
double dy = (c.voirOrdonnee() - this.extrem1().voirOrdonnee()) / 2;
Point a2 = this.a.seDupliquer();
Point b2 = this.b.seDupliquer();
a2.translater(dx, dy);
b2.translater(-dx, -dy);
this.a = a2;
this.b = b2;
}
/** Méthode : fait tourner le Segment d'un angle pi/2, en gardant le meme centre */
public void rotation() {
Point c = this.milieu();
double dx = c.voirAbscisse();
double dy = c.voirOrdonnee();
this.centrer2();
double abs1 = this.extrem1().voirAbscisse();
double ord1 = this.extrem1().voirOrdonnee();
double abs2 = this.extrem2().voirAbscisse();
double ord2 = this.extrem2().voirOrdonnee();
Point abs = new Point(-ord1, abs1);
Point ord = new Point(-ord2, abs2);
this.a = abs;
this.b = ord;
this.translater(dx, dy);
}

/** Méthode : Calcule la pente de la droite portée par un segment */
private double pente() {
double deltaY = this.a.voirOrdonnee() - this.b.voirOrdonnee();
double deltaX = this.a.voirAbscisse() - this.b.voirAbscisse();
if (deltaX == 0) { // Segment vertical
System.out.println("Calcul de la pente d'un segment vertical");
}
return deltaY / deltaX;
}
// Remarque : Ne fonctionne pas pour des segments verticaux (pente = infini)
/** Méthode : Indique si les deux droites sont sécantes */
public boolean secantes(Segment droite) {
return this.pente() != droite.pente();
}
// Remarque : Ne fonctionne pas pour des droites confondu (plusieurs intersections)
/** Méthode : Indique si le segment courant coupe la droite passée en paramètre */
private boolean coupeDroite2(Segment droite) {
double pente = droite.pente();
double valOrig = droite.a.voirOrdonnee() - droite.a.voirAbscisse() * pente;
// Équation de la droite : y = pente * x + valOrig
double aX = this.a.voirAbscisse(), aY = this.a.voirOrdonnee();
double bX = this.b.voirAbscisse(), bY = this.b.voirOrdonnee();
return
// A est au dessus et B en dessous de la droite
(aY >= pente * aX + valOrig && bY <= pente * bX + valOrig)
||
// A est en dessous et B au dessus de la droite
(aY <= pente * aX + valOrig && bY >= pente * bX + valOrig);
// On peut simplifier : return (pente*aX+valOrig - aY) * ( pente*bX+valOrig - bY) <= 0;
}
/** Indique si deux segments se coupent */
public boolean coupeSegment2(Segment s) {
return this.coupeDroite2(s) && s.coupeDroite2(this);
}
// Remarque : Ne fonctionne pas si un des segments est vertical

/* --RAJOUT FIN-- */


/* Tests : */
public static void main(String [] args) {
/* - Tester son programme sans utiliser la fenêtre d'interaction : */
Point p1 = new Point(12, 12);
Point p2 = new Point(3, 3);
System.out.println("p1 :" + p1);
System.out.println("p2 :" + p2);
p1=p2;
System.out.println("p1 :" + p1);
System.out.println("p2 :" + p2);
p2.chgAbscisse(4);
System.out.println("p1.equals(p2) " + p1.equals(p2));
System.out.println("p1==p2 :" + (p1==p2));
p2 = new Point(4, 3);
System.out.println("p1.equals(p2) :" + p1.equals(p2));
System.out.println("p1==p2 :" + (p1==p2));

System.out.println("\n\t-----\n");
/* - Translater et centrer des Segments : */
p1.chgAbscisse(5);
p1.chgOrdonnee(5);
p1.translater(2, 1);
System.out.println("p1 translate de (2,1) :" + p1);
p2.chgAbscisse(3);
p2.chgOrdonnee(5);
Point p3 = new Point(5, 3);
Segment s1 = new Segment(p2, p3);
s1.translater(1, 2);
System.out.println("p2 :" + p2);
System.out.println("p3 :" + p3);
System.out.println("s1 translate de (1, 2) :" + s1);
Point p4 = new Point(1, 5);
Point p5 = new Point(5, 1);
Segment s2 = new Segment(p4, p5);
s2.centrer();
System.out.println("p4 :" + p4);
System.out.println("p5 :" + p5);
System.out.println("s2 centre :" + s2);

System.out.println("\n\t-----\n");
/* - Seuls les Segments bougent, pas les Points : */
// p1 = (7, 6)
System.out.println("p1 :" + p1);
Point p6 = p1.seDupliquer();
p6.chgAbscisse(1);
p6.chgOrdonnee(1);
System.out.println("p1 :" + p1);
System.out.println("p6 :" + p6);
Segment s3 = new Segment(p1, p2);
Segment s4 = s3;
System.out.println("s3 :" + s3);
System.out.println("s4 :" + s4);
s4.translater2(2, 2);
System.out.println("s3 :" + s3);
System.out.println("s4 :" + s4);
System.out.println("p1 :" + p1);
System.out.println("p2 :" + p2);
Segment s5 = s3;
s5.centrer2();
System.out.println("s3 :" + s3);
System.out.println("s5 :" + s5);
System.out.println("p1 :" + p1);
System.out.println("p2 :" + p2);

System.out.println("\n\t-----\n");
/* La méthode diviser */
Point p7 = new Point(0, 0);
Point p8 = new Point(4, 4);
Segment s6 = new Segment(p7, p8);
s6.diviser();
System.out.println("s6 divisé par 2 :" + s6);
System.out.println("p7 :" + p7);
System.out.println("p8 :" + p8);

System.out.println("\n\t-----\n");
/* La méthode rotation */
Point p9 = new Point(2, 0);
Point p10 = new Point(0, 2);
Segment s7 = new Segment(p9, p10);
s7.rotation();
System.out.println("s7 :" + s7);
System.out.println("p9 :" + p9);
System.out.println("p10 :" + p10);

/*
p1 :Point : x = 12.0, y = 12.0.

p2 :Point : x = 3.0, y = 3.0.

p1 :Point : x = 3.0, y = 3.0.

p2 :Point : x = 3.0, y = 3.0.

p1.equals(p2) true

p1==p2 :true

p1.equals(p2) :true

p1==p2 :false


-----


p1 translate de (2,1) :Point : x = 7.0, y = 6.0.

p2 :Point : x = 4.0, y = 7.0.

p3 :Point : x = 6.0, y = 5.0.

s1 translate de (1, 2) :Segment : [Point : x = 4.0, y = 7.0.,Point : x = 6.0, y = 5.0.]

p4 :Point : x = -2.0, y = 2.0.

p5 :Point : x = 2.0, y = -2.0.

s2 centre :Segment : [Point : x = -2.0, y = 2.0.,Point : x = 2.0, y = -2.0.]


-----


p1 :Point : x = 7.0, y = 6.0.

p1 :Point : x = 7.0, y = 6.0.

p6 :Point : x = 1.0, y = 1.0.

s3 :Segment : [Point : x = 7.0, y = 6.0.,Point : x = 4.0, y = 7.0.]

s4 :Segment : [Point : x = 7.0, y = 6.0.,Point : x = 4.0, y = 7.0.]

s3 :Segment : [Point : x = 9.0, y = 8.0.,Point : x = 6.0, y = 9.0.]

s4 :Segment : [Point : x = 9.0, y = 8.0.,Point : x = 6.0, y = 9.0.]

p1 :Point : x = 7.0, y = 6.0.

p2 :Point : x = 4.0, y = 7.0.

s3 :Segment : [Point : x = 1.5, y = -0.5.,Point : x = -1.5, y = 0.5.]

s5 :Segment : [Point : x = 1.5, y = -0.5.,Point : x = -1.5, y = 0.5.]

p1 :Point : x = 7.0, y = 6.0.

p2 :Point : x = 4.0, y = 7.0.


-----


s6 divisé par 2 :Segment : [Point : x = 1.0, y = 1.0.,Point : x = 3.0, y = 3.0.]

p7 :Point : x = 0.0, y = 0.0.

p8 :Point : x = 4.0, y = 4.0.


-----


s7 :Segment : [Point : x = 2.0, y = 2.0.,Point : x = 0.0, y = 0.0.]

p9 :Point : x = 2.0, y = 0.0.

p10 :Point : x = 0.0, y = 2.0.
*/
} // Tests

}

public class ExoBug {
private int[] tab;

/** Constructeur : crée un tableau de taille n */
public ExoBug(int n) {
this.tab = new int[n];
for (int i = 0 ; i < this.tab.length ; i++) {
this.tab[i] = i;
} // for
}
/** Constructeur : place le tableau en paramètre */
public ExoBug (int[] t) {
this.tab = new int [t.length];
for (int i = 0 ; i < this.tab.length ; i++) {
this.tab[i] = t[i];
} // for
}
/** Méthode : transforme l'objet en String */
public String toString() {
String resul = "";
for (int i = 0 ; i < this.tab.length ; i++) {
resul = resul + this.tab[i] + " ";
} // for
return resul;
}
/** Méthode : vérifie que les entiers classés dans le tableau sont dans l'ordre croissant */
public boolean estCroissant() {
boolean croissant = true;
for (int i = 0 ; i < this.tab.length-1 ; i++) {
if (this.tab[i] > this.tab[i+1]) {
croissant = false;
} // if
} // for
return croissant;
}


/* Tests : */
public static void main(String [] args) {
/* - Pour éviter les pièges élémentaires : */
int[] t1 = {1,2,3,4};
System.out.println("t1 : " + t1);
System.out.println("t1[3] = " + t1[3]);
System.out.println("t1.length : " + t1.length);
t1[0] = 10;
System.out.println("t1[0] = " + t1[0]);
/* > t1[4]
ArrayIndexOutOfBoundsException:
at java.lang.reflect.Array.get(Native Method)
le tableau n'a des entiers numérotés que jusqu'à 3 */
int[] t2 = t1;
System.out.println("t1 : " + t1);
System.out.println("t2 : " + t2);
t2[0] = 9;
System.out.println("t1[0] = " + t1[0]);
System.out.println("t2[0] = " + t2[0]);
int[]t3 = new int[3];
System.out.println("t3.length : " + t3.length);
System.out.println("t3 : " + t3);
t3 = t1;
System.out.println("t3.length : " + t3.length);
System.out.println("t3 : " + t3);
/* t3 pointe vers le même tableau que t1 */
System.out.println("t3 == t2 :" + (t3 == t2));

System.out.println("\n\t-----\n");
/* - Une classe avec un attribut tableau et encore quelques pièges : */
/* ExoBug exo1 = new ExoBug(5);
System.out.println("tab[2] dans exo1 = "+exo1.tab[2]);
System.out.println("tab[5] dans exo1 = "+exo1.tab[5]);
Error: ...\TestTP4.java:32: tab has private access in ExoBug */
int[] tab1 = {1,2,3,4};
ExoBug exo2 = new ExoBug(tab1);
System.out.println("exo2 : " + exo2);
System.out.println("exo2 en ordre croissant : " + exo2.estCroissant());

/*
* t1 : [I@801059

t1[3] = 4

t1.length : 4

t1[0] = 10

t1 : [I@801059

t2 : [I@801059

t1[0] = 9

t2[0] = 9

t3.length : 3

t3 : [I@8a2023

t3.length : 4

t3 : [I@801059

t3 == t2 :true


-----


exo2 : 1 2 3 4

exo2 en ordre croissant : true
*/
} // Tests

}

public class Sequence {
private char[] tcar; // la chaine de nucléotides
private String nature; // "ADN", "ARN"

/** Constructeur : construit une Sequence à partir du tableau et du type */
public Sequence(char[] t, String nat) {
this.tcar = t;
this.nature = nat;
}
/** Méthode : converti une Sequence en chaine */
public String toString() {
return this.nature+" : "+new String(this.tcar);
}
/** Méthode : donne la longueur d'une Sequence */
public int longueur() {
return this.tcar.length;
}
/** Méthode : donne la nature d'une Sequence */
public String voirNature() {
return this.nature;
}
/** Méthode : donne le i-ème caractère d'une Sequence */
public char voirCieme(int i) {
if (i > this.longueur()) {
System.out.println("Attention, hors de la Sequence");
return 'f';
} // if
return this.tcar[i-1];
}
/** Méthode : compte le nombre d'occurence d'une base dans une Sequence */
public int compterBase(char base) {
int nb = 0;
for (int i = 0 ; i < this.longueur() ; i++) {
if (this.tcar[i] == base) {
nb++;
} // if
} // for
return nb;
}
/** Méthode : retourne vrai si la Sequence peut etre celle d'un vertebre
* ie, s'il y a entre 40 ou 45% de nucléotides à base azotée 'C' + 'G' */
public boolean estADNVertebre() {
double n = (double) (this.compterBase('C') + this.compterBase('G')) / this.tcar.length;
if (this.nature.equals("ADN") && 0.40 <= n && 0.45 >= n) {
return true;
} // if
else {
return false;
} // else
}
/** Méthode : construit la Sequence d'ARNm correspondant à la traduction du brin complémentaire par rapport au brin d'ADN courant (this) */
public Sequence ADNtoARN() {
char[] t = new char[this.longueur()];
Sequence ARNm = new Sequence(t, "ARN");
for (int i = 0 ; i < this.longueur() ; i++) {
if (this.tcar[i] == 'T') {
ARNm.tcar[i] = 'U';
} // if
else {
ARNm.tcar[i] = this.tcar[i];
} // else
} // for
return ARNm;
}
/** Méthode : vérifie si une Sequence peut correspondre à de l'ADN */
public boolean estADNcorrecte() {
return this.nature.equals("ADN") &&
this.compterBase('A') + this.compterBase('C') + this.compterBase('T') + this.compterBase('G') == this.longueur();
}
/** Méthode : vérifie si une Sequence peut correspondre à de l'ARN */
public boolean estARNcorrecte() {
return this.nature == "ARN" &&
this.compterBase('A') + this.compterBase('C') + this.compterBase('U') + this.compterBase('G') == this.longueur();
}

/* --RAJOUT DEBUT-- */

/** Méthode : concaténer deux brins s'ils sont du meme type, sinon rend une Sequence vide */
public Sequence concatenerBrins(Sequence brin) {
int lg = this.longueur() + brin.longueur();
char[] brinC = new char[lg];
Sequence seqC = new Sequence(brinC, this.voirNature());
if (this.voirNature() == brin.voirNature()) {
for (int i = 0 ; i < this.longueur() ; i++) {
brinC[i] = this.tcar[i];
} // for i
for (int n = 0 ; n < brin.longueur() ; n++) {
brinC[this.longueur()+n] = brin.tcar[n];
} // for n
} // if
return seqC;
}
/** Méthode : donner la place des différences entre 2 brins de meme type */
public String localiserDif(Sequence brin) {
String loc = "les differences sont en position(s) :";
int m = Math.min(this.longueur(), brin.longueur());
int M = Math.max(this.longueur(), brin.longueur());
for (int i = 0 ; i < m ; i++) {
if (this.tcar[i] != brin.tcar[i]) {
loc = loc + " " + (i+1);
} // if
} // for i
for (int n = 0 ; n < (M-m) ; n++) {
loc = loc + " " + (m+n+1);
} // for n
return loc;
}
/** Méthode : rend true si les deux brins sont égaux */
public boolean equals(Sequence brin) {
int lg = this.longueur();
if (lg == brin.longueur()) {
for (int i = 0 ; i < this.longueur() ; i++) {
if (this.tcar[i] != brin.tcar[i]) {
return false;
} // if
} // for i
} // if
else {
return false;
} // else
return this.nature.equals(brin.nature);
}

/* --RAJOUT FIN-- */


/* Tests : */
public static void main(String [] args) {
/* - Ma permière classe avec un tableau : L'ADN et L'ARN */
char[] tab1 = {'A', 'C', 'C', 'A', 'T', 'G', 'A', 'G', 'A', 'T', 'A', 'T', 'G'};
char[] tab2 = {'A', 'C', 'U', 'A', 'A', 'C', 'U', 'C', 'G'};
char[] tab3 = {'A', 'A', 'A', 'C', 'G', 'G', 'C', 'G', 'T', 'T', 'A', 'C', 'A', 'T', 'G', 'A'};
char[] tab4 = {'C', 'A', 'G', 'K'};
char[] tab5 = {'A', 'C', 'C', 'A', 'T', 'G', 'A', 'G', 'A', 'T', 'A', 'T'};
char[] tab6 = {'A', 'C', 'C', 'A', 'T', 'G', 'A', 'G', 'A', 'T', 'A', 'T', 'C'};
char[] tab7 = {'A', 'C', 'C', 'A', 'T', 'G', 'A', 'G', 'A', 'T', 'A', 'T', 'G'};
char[] tab8 = {'A', 'C', 'C', 'A', 'T', 'G', 'A', 'G', 'A', 'T', 'A', 'T', 'G'};
Sequence s1 = new Sequence(tab1, "ADN");
Sequence s2 = new Sequence(tab2, "ARN");
Sequence s3 = new Sequence(tab3, "ADN");
Sequence s4 = new Sequence(tab4, "ADN");
Sequence s5 = new Sequence(tab5, "ADN");
Sequence s6 = new Sequence(tab6, "ADN");
Sequence s7 = new Sequence(tab7, "ARN");
Sequence s8 = new Sequence(tab8, "ADN");
System.out.println("\ns1 : " + s1.toString());

System.out.println("\ns1.longueur() = " + s1.longueur());

System.out.println("\ns1.voirNature() : " + s1.voirNature());

System.out.println("\ns1.voirCieme(1) : " + s1.voirCieme(1));
System.out.println("s1.voirCieme(13) : " + s1.voirCieme(13));
System.out.println("s1.voirCieme(14) : " + s1.voirCieme(14));

System.out.println("\ns1.compterBase('C') = " + s1.compterBase('C'));
System.out.println("s1.compterBase('V') = " + s1.compterBase('V'));

System.out.println("\ns1.estADNVertebre() : " + s1.estADNVertebre());
System.out.println("\trapport s1 = " + (double) (s1.compterBase('C') + s1.compterBase('G')) / s1.tcar.length);
System.out.println("s2.estADNVertebre() : " + s2.estADNVertebre());
System.out.println("\trapport s2 = " + (double)(s2.compterBase('C') + s2.compterBase('G')) / s2.tcar.length);
System.out.println("s3.estADNVertebre() : " + s3.estADNVertebre());
System.out.println("\trapport s3 = " + (double)(s3.compterBase('C') + s3.compterBase('G')) / s3.tcar.length);

System.out.println("\ns1.ADNtoARN() : " + s1.ADNtoARN());

System.out.println("\ns1.estADNcorrecte() : " + s1.estADNcorrecte());
System.out.print("s2.estADNcorrecte() : " + s2.estADNcorrecte());
System.out.println("\ts2.estARNcorrecte() : " + s2.estARNcorrecte());
System.out.println("s3.estADNcorrecte() : " + s3.estADNcorrecte());
System.out.println("s4.estADNcorrecte() : " + s4.estADNcorrecte());

System.out.println("\n\t-----\n");
// Rajout
System.out.println("concaténation s1 et s3 : " + s1.concatenerBrins(s3));
System.out.println("concaténation de s1 et s2 : " + s1.concatenerBrins(s2));

System.out.println("\ndifférences entre s1 et s3 : " + s1.localiserDif(s3));

System.out.println("\nequals s1 et s2 : " + s1.equals(s2));
System.out.println("equals s1 et s5 : " + s1.equals(s5));
System.out.println("equals s1 et s6 : " + s1.equals(s6));
System.out.println("equals s1 et s7 : " + s1.equals(s7));
System.out.println("equals s1 et s8 : " + s1.equals(s8));

/*
s1 : ADN : ACCATGAGATATG


s1.longueur() = 13


s1.voirNature() : ADN


s1.voirCieme(1) : A

s1.voirCieme(13) : G

Attention, hors de la Sequence
s1.voirCieme(14) : f



s1.compterBase('C') = 2

s1.compterBase('V') = 0


s1.estADNVertebre() : false

rapport s1 = 0.38461538461538464

s2.estADNVertebre() : false

rapport s2 = 0.4444444444444444

s3.estADNVertebre() : true

rapport s3 = 0.4375


s1.ADNtoARN() : ARN : ACCAUGAGAUAUG


s1.estADNcorrecte() : true

s2.estADNcorrecte() : false s2.estARNcorrecte() : true

s3.estADNcorrecte() : true

s4.estADNcorrecte() : false


-----


concaténation s1 et s3 : ADN : ACCATGAGATATGAAACGGCGTTACATGA

concaténation de s1 et s2 : ADN :

différences entre s1 et s3 : les differences sont en position(s) : 2 3 4 5 7 9 12 13 14 15 16


equals s1 et s2 : false

equals s1 et s5 : false

equals s1 et s6 : false

equals s1 et s7 : false

equals s1 et s8 : true

*/
} // Tests

}

Anonyme a écrit :

Au niveau de la forme : sans indentation ces codes sont, de plus, totalement illisibles pour un

néophyte

Anonyme

Anonyme

Salut,

Hélas la balise "code" a disparu du forum depuis de nombreuses années (enfin vers 2005/2006, si mes souvenirs sont bons)!

Hello,

l'intéret... joli mot l'intéret... c'est à chacun de trouver son propre intéret dans toute chose...

quel était l'intéret des 1600 personnes qui ont jeté un coup d'oeil à l'ouverture sur le Scheme qui est presque totalement abandonné?

moi mon intéret est de faire partager, et d'avoir une trace que je puisse utiliser en plusieurs endroits sans avoir à utiliser une clé usb, pour s'il n'y a pas possibilité d'en connecter une à la tour du PC que j'utilise...

si quelqu'un veut les lire, ou voir à quoi ca ressemble pour se lancer dans une langue ou une autre, il peut voir ici (bien sure, il y a des centaines d'autres sites qui en parlent... mais j'aime bien ce forum, et j'ai passé du temps ici, avant de remarquer qu'il y avait des tas d'autres choses sur internet, j'ai vu que l'autre jour quelqu'un se demandait où programmer... il aurai aussi pu se demander quoi programmer, toutes les langues ne se ressemblent pas, certaines sont orientées objet, d'autres gérent des données, d'autres des pages internet... je ne crois pas qu'il ait demandé. mais s'il fait un tour ici, il verra peut etre ceci, et peut que cela l'aidera à trouver ce qu'il veut apprendre à programmer), pour ceux qui seront dans mon école les années suivantes, ils pourront venir ici regarder un peu comment on a fait... chacun peut trouver son intéret s'il cherche un intéret.

et pour la lisibilité, on peut copier ces passages dans eclipse ou DrJava, selestionner tout le texte (control A) et presser la touche tabulation sur le clavier, la mise en page reviendra... ;)

je suis d'accord, ca manque d'ordre là, mais bon...

si l'on parle d'intéret, quel serait l'intéret de Clément de remettre les balises de code pour cette partie du forum qui reste si peu développée sur PCA? tu peux voir ces posts comme une facon de faire un peu vivre ce forum que j'aime bien...meme si cette partie du forum est la plus délaissée...

pour voir à quoi servent les fonctions, il y a des tests à la fin des classes, pour voir ce qu'elles font, et elles ont un titre.

@++