JAVA mathématique double variable ne correspond pas, est-il bc de problèmes de représentation binaire?

Question

Fondamentalement, c'était un devoir que je devais faire à propos des rectangles. Le problème est venu quand j'ai eu besoin de faire des calculs simples pour calculer les valeurs x et y des sommets, par exemple. (x-width/2), et parce que j'avais besoin d'utiliser ces valeurs dans plus d'une méthode, j'ai créé de nouvelles variables dans la classe pour cette mathématique simple (x1 = (x-width/2), x2, y1, y2 etc.), pour plus de lisibilité. Pour une raison quelconque, dans mes méthodes, l'utilisation des variables a produit des résultats erronés. quand je suis retourné et les a remplacés par les mathématiques à nouveau, cela a fonctionné.

Ma question est pourquoi les variables que j'ai faites (sous // WEIRD VARIABLES) ne fonctionnent pas dans la méthode contains?

voici mon code:

package com.example; 

public class MyRectangle2D { 
    double x,y; 
    double width, height; 
    //a couple of getters and setters 
    //constructor 
    MyRectangle2D(){ 
     x=0.0; 
     y=0.0; 
     width=1.0; 
     height=1.0; 
    } 
    MyRectangle2D(double X, double Y, double Width, double Height){ 
     x=X; 
     y=Y; 
     width=Width; 
     height=Height; 
    } 

    // WEIRD VARIABLES 
    private double x1 = x-(width/2); 
    private double x2 = (x+(width/2)); 
    private double y1 = (y-(height/2)); 
    private double y2 = (y+(height/2)); 

    //methods 
    boolean contains(double X, double Y){ 
     /* initially wrote: 
      return (!(X<x1 || X>x2 || Y <y1 || Y>y2)); 
      didnt work, bc for some reason x1,x2,y1,y2 were all 0.0 
      the below works well: */ 
     return (!(X<(x-(width/2)) || X>(x+(width/2)) || Y <(y-(height/2)) || Y>(y+(height/2)))); 
    } 


    public static void main(String[] args) { 
     MyRectangle2D b = new MyRectangle2D(1, 2, 3, 4); 
     System.out.println(b.x1); // 0.0 (should be -0.5) 
     System.out.println(b.x); // 1.0 (correct) 
     System.out.println(b. width); // 3.0 (correct) 
     System.out.println("(1.0,2.0) in b? (true?) " + b.contains(1.0,2.0)); //true (correct) 
    } 
} 

Je suis parfaitement bien en train d'écrire les maths encore et encore, mais dans mes devoirs qu'ils voulaient que je crée une méthode pour vérifier si ce rectangle contient un autre rectangle, comme

boolean contains(MyRectangle2D r){} 

qui signifie que je dois écrire r. (X- (largeur/2)) < = (X- (largeur/2)), etc. pour écrire mes conditions, ce qui semble fastidieux et en désordre. Il m'a semblé logique de créer ces variables x1, x2, y1, y2 comme une forme de raccourci, puisque les maths étaient la même formule et il serait plus propre et je pourrais directement utiliser r.x1 au lieu de r (x- (largeur/2))

tl; dr: lorsque i printlnQ x1, elle me donne 0,0, mais quand i println x- (largeur/2), elle me donne -0,5, ce qui est correct. J'ai essayé de comprendre pourquoi les maths se trompent mais je suis toujours perdu. Toute aide serait très appréciée!

Answer 1

Cette affectation ci-dessous est effectuée avant tout constructeur. Peu importe que les constructores viennent en premier. Toutes les déclarations de champs sont traitées en premier.

// WEIRD VARIABLES 
    private double x1 = x-(width/2); 
    private double x2 = (x+(width/2)); 
    private double y1 = (y-(height/2)); 
    private double y2 = (y+(height/2)); 

Peut-être une solution à votre problème est de faire l'affectation à l'intérieur du contructor, comme:

//declare the filds outside any method 
private double x1; 
private double x2; 
private double y1; 
private double y2; 

MyRectangle2D(){ 
    //... Your normal code here 
    buildWeird(); 
} 
MyRectangle2D(double X, double Y, double Width, double Height){ 
    //... Your normal code here 
    buildWeird(); 
} 
private void buildWeird(){ 
    this.x1 = x-(width/2); 
    this.x2 = (x+(width/2)); 
    this.y1 = (y-(height/2)); 
    this.y2 = (y+(height/2)); 
} 

Answer 2

L'affectation des champs au cours de leur déclaration (comme x1, x2, y1 et y2) sont effectuées après l'appel à super() et avant toute autre déclaration dans le constructeur. Dans votre cas, cela se produit avant que la cession de x, y, width et height si x1, x2, y1 et y2 sera de 0, peu importe si vous placez les déclarations sur le terrain avant ou après le constructeur.

La solution consiste à déplacer l'affectation dans le constructeur, à la fin.