Discussion :

[ouafae2011]

Bonjour à tous,
d'abords, je m'excuse pour ce long code.
En fait, je suis débutante en java et j'aimerais réaliser un programme qui lit un fichier .txt ou chaque ligne contient 2 ou 4 nombre réels et puis il affiche dans une fenêtre un point quand la ligne contient 2 nombres et une droite quand elle contient 4 nombres. Mais quand je compile, eclipse m'affiche cette erreur:

Exception in thread "main" java.lang.Error: Unresolved compilation problem:
The constructor DroiteD2(PointsD2, PointsD2) is undefined

at dataPoints.DataPoints.<init>(DataPoints.java:38)
at dataPoints.Grapheur.main(Grapheur.java:6)



voici les classes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
package dataPoints;
import java.awt.*;
import java.awt.Graphics;
 
import javax.swing.JPanel;
 
 
 
public class DessinPoints extends JPanel {
 
 
	DataPoints listPts;
	int bord; // taille des bords
	int enveloppe; // dimension des rectangles
 
	public DessinPoints (DataPoints pts, int largeur, int hauteur, int bord, int enveloppe) {
		this.listPts = pts;
		this.bord = bord;
		this.enveloppe = enveloppe;
 
	}
	public void paintcomponent (Graphics g) {
		super.paintComponent(g);
		g.setXORMode(Color.blue);
 
	}
 
 
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
package dataPoints;
 
import geomD2.DroiteD2;
import geomD2.PointsD2;
 
import java.io.FileReader;
import java.io.LineNumberReader;
import java.util.StringTokenizer;
import java.util.Vector;
 
public class DataPoints extends Vector<Vector<PointsD2>>{
	double min_x, min_y, max_x, max_y;
	Vector <PointsD2> vectPoint;
	public DataPoints(String fichier){
		LineNumberReader lecteurLignes = null;
		try{
 
			lecteurLignes = new LineNumberReader (new FileReader(fichier));
			String ligneTexte = null;
			vectPoint = new Vector<PointsD2>();
			while ((ligneTexte = lecteurLignes.readLine()) != null) {
				StringTokenizer st = new StringTokenizer(ligneTexte);
 
				if (st.countTokens() == 2) {
					//stoker les points dans le vecteur courant
					Double X = new Double(st.nextToken());
					Double Y = new Double(st.nextToken());
					PointsD2 Point = new PointsD2(X,Y);
					vectPoint.add(Point);
				}
				if (st.countTokens() == 4 ) {
					Double X = new Double(st.nextToken());
					Double Y = new Double(st.nextToken());
					PointsD2 Point = new PointsD2(X,Y);
					Double X1 = new Double(st.nextToken());
					Double Y1 = new Double(st.nextToken());
					PointsD2 Point2 = new PointsD2(X1,Y1);
					DroiteD2 Droite = new DroiteD2(Point,Point2);
 
 
				}
			}
			System.out.println(vectPoint);
		}
		catch(Exception e) { e.printStackTrace(); }
		min_max();
    }
	private void min_max() {
	// completer
 
	  }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
import javax.swing.JFrame;
 
public class Grapheur {
	public static void main(String[] args) {
		DataPoints listePts = new DataPoints ("fichier.txt");
		System.out.println(listePts);
		DessinPoints monGraphe = new DessinPoints(listePts,600,400,10,10);
		JFrame f = new JFrame();
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.add(monGraphe, "center");
		f.setTitle("Grapheur"); 
		f.setSize(400, 400);
	    f.setVisible(true);
	}
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
public class DroiteD2 {
	private PointsD2 point = null;
	private double pente = 0.0;
	private double b = 0.0; // la droite "pente x + b"
 
	// Constructeurs
	// un point et une pente
	public DroiteD2(PointsD2 p, Double m) { //revenir sous la forme de la pente ax + b
		point = p;
		calculerTout(m, p);
	}
	// une pente et une ordonnee d'origine
	public DroiteD2(Double m, Double ord) {
		pente = m;
		b = (double)ord;
		point = new PointsD2(0.0,ord);
	}
	// deux points
	public DroiteD2(PointsD2 p1, PointsD2 p2) {
		point = p1;
		calculerTout(p1, p2);
	}
 
	// mŽthodes internes pour calculer pente/B selon param�tres
	private void calculerTout(PointsD2 p1, PointsD2 p2) { //utiliser en interne pour calculer B
		if (p1.getX() >= p2.getX()) {
			pente = ((double)p1.getY() - p2.getY())/(p1.getX() - p2.getX());
		}
		else {
			pente = ((double)p2.getY() - p1.getY())/(p2.getX() - p1.getX());
		}
		calculerB(p1);
	}
	private void calculerTout(Double m, PointsD2 p){
		pente = m;
		calculerB(p);
	}
	private void calculerB(PointsD2 p){
		if (p.getX() >= 0) {
			b = p.getY() - pente*p.getX();
		}
		else {
			b = -(pente*p.getX()) - p.getY();
		}
		System.out.println(pente + "x + " + b);
	}
 
	// modificateurs
	public void setPoint(PointsD2 p) {
		point = p;
		calculerTout(pente, point);
	}
	// changer la pente
	public void setPente(Double m) {
		pente = m;
		//calculerTout(pente, point);
	}
	// changer tout
	public void setPointPente(PointsD2 p, Double m) {
		point = p;
		pente = m;
		calculerTout(m,p);
	}
 
	// les accesseurs purs
	// obtenir le point
	public PointsD2 getPoint() {
		return point;  
	}
	// obtenir la pente
	public Double getPente() {
		return pente;
	}
 
	// les accesseurs avec calcul
	// abscisse d'intersection avec axe X
	public Double getIntersectionX() {
		return -(b/pente); 
	}
	// ordonnŽe d'intersection avec axe Y
	public Double getIntersectionY() {
		return b;
	}
	public boolean contient(PointsD2 p) {
		return (pente*p.getX() + b == p.getY());
	}
	public boolean estParallele(DroiteD2 d) {
		return d.pente == pente;
	}
 
	// Les utilitaires
	public boolean equals(Object o){
		if (!(o instanceof DroiteD2)) {
			return false;
		}
 
		else return ((((DroiteD2)o).pente == this.pente)
				&& (((DroiteD2)o).b == this.b)); 
		//return true;
				//(((DroiteD2)o).point.getX() == this.point.getX() 
	}
	public String toString() {
		return ("pente= " + pente + " b= " + b);
	}
	public StringBuilder toString2() {
		return new StringBuilder("pente= " + pente + " b= " + b);
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
package geomD2;
 
 
 
public class PointsD2 {
	private Double x = (Double) null;
	private Double y = (Double) null;
 
	// Point D2 a ses constructeurs
	public PointsD2() {};
	public PointsD2(Double a, Double b) {
		x = a; //conversion implicite de int en Integer
		y = b;
	}
	public PointsD2(PointsD2 pt){
		x = pt.x;
		y = pt.y;
	}
	public PointsD2(Double[] pt){
		x = pt[0];
		y = pt[1];
	}
 
	// PointD2 m≈Ωthodes d'instance
	public boolean defini() {
		return (x != null) && (y != null);
	}
	public Double getX(){
		return x;
	}
	public Double getY(){
		return y;
	}
	public void setX(Double a){
		x = a;
	}
	public void setY(Double a){
		y = a;
	}
	public double dist(PointsD2 pt){ //distance ÀÜ un point entr≈Ω en paramÔøΩtre (pythagore)
		return Math.sqrt(Math.pow(pt.x-x,2) + Math.pow(pt.y-y,2));
	}
 
	// red≈Ωfinition de la m≈Ωthode Object.equal()
	public boolean equals(Object p){
		if (!(p instanceof PointsD2)) {
			return false;
		}
		else return (((PointsD2)p).x == x && ((PointsD2)p).y == y);  
	}
}

Merci beaucoup