Hola amigos de nuevo molestandolos espero que me puedan ayudar, bueno nos dejaron crear una clase rectangulo a patir de dos clases linea y punto, ya la e echo casi toda solo me falta la union interseccion y rotarlo si me ayudan se los agradecere.
Codigo linea:
Código Java:
Ver original/**
* Linea.java
*/
public class Linea{
private Punto p1;
private Punto p2;
public Linea(){
this(new Punto(0,0),new Punto(1,1));
}
public Linea (Punto p1Ini, Punto p2Ini) {
if(!p1Ini.equals(p2Ini)){
p1 = p1Ini;
p2 = p2Ini;
}
else{
p1 = new Punto(3,5);
p2 = new Punto(4,6);
}
}
public Linea(Linea l) {
p1 = l.p1;
p2 = l.p2;
}
public Punto getP1(){
return p1;
}
public Punto getP2(){
return p2;
}
if (p1.getY() == p2.getY())
return "y = " + p1.getY(); //Recta paralela al eje x
if (p1.getX() == p2.getX())
return "x = " + p1.getX(); //Recta paralela al eje y
double m = pendiente();
double b = ordenada();
return (b > 0) ? "y = " + m + "x + " + b
: "y = " + m + "x " + b;
}
public double pendiente() {
double divisor = p2.getX() - p1.getX();
return (divisor != 0) ?
(p2.getY() - p1.getY())/divisor
: Double.
POSITIVE_INFINITY; //Recta paralela al eje Y }
public double ordenada() {
return p1.getX() == p2.getX()?
: p1.getY() - pendiente()*p1.getX();
}
public boolean contiene(Punto p) {
return p.estanAlineados(p1,p2);
}
public boolean equals(Linea l1) {
return pendiente() == l1.pendiente() && ordenada() == l1.ordenada();
}
public boolean esParalela(Linea l1) {
return pendiente () == l1.pendiente();
}
public boolean esPerpendicular(Linea l1) {
double m = pendiente();
double m1 = l1.pendiente();
final double INFINITO
= Double.
POSITIVE_INFINITY;
if (m == 0 || m1 == 0 || m == INFINITO || m1 == INFINITO){
return ((m == 0 && m1 == INFINITO) || (m1 == 0 && m == INFINITO))
? true : false;
}
return m == -1/m1;
}
public Punto interseccion(Linea l1) {
int nuevaX, nuevaY;
if (esParalela(l1)){
nuevaX
= nuevaY
= (int)Double.
POSITIVE_INFINITY; }
else {
nuevaX = (int)(ordenada()- l1.ordenada())/(int)(l1.pendiente() - pendiente());
nuevaY = (int)(pendiente()*nuevaX + ordenada());
}
return new Punto(nuevaX, nuevaY);
}
}
Codiglo punto:
Código Java:
Ver original/**
* Punto.java
*/
public class Punto {
private int x; // Coordenada x
private int y; // Coordenada y
public Punto() {
this(0,0);
}
public Punto(int x, int y) {
this.x = x; //setX(x);
this.y = y; //setY(y);
}
public Punto(Punto p) {
x = p.x; //p.getX();
y = p.y; //p.getY();
}
/**
* Asigna valor a la coordenada x del punto.
* @param int nuevo valor para la coordenada x
*/
public void setX(int nuevaX) {
x = nuevaX;
}
/**
* Asigna valor a la coordenada y del punto.
* @param int nuevo valor para la coordenada y.
*/
public void setY(int nuevaY) {
y = nuevaY;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public void desplazar(int deltaX, int deltaY) {
x += deltaX; // x = x + deltaX;
y += deltaY;
}
public double distancia(Punto p) {
//Math.pow(x-p.x,2) + Math.pow(y-p.y,2)
return Math.
sqrt((double)((x
-p.
x)*(x
-p.
x) + (y-p.y)*(y-p.y)));
}
public boolean estanAlineados(Punto p1, Punto p2) {
return (y - p1.y)*(p2.x - p1.x) == (p2.y - p1.y)*(x -p1.x);
}
public boolean equals(Punto p) {
return x == p.x && y == p.y;
}
return "(" + x + "," + y + ")";
}
}
Codigo
Rectangulo:
Código Java:
Ver originalimport javax.swing.JOptionPane;
public class Rectangulo {
private Linea L1;
private Linea L2;
private Linea L3;
private Linea L4;
/**
* Constructor del rectangulo inicial formado por los puntos
*/
public Rectangulo() {
Punto p1;
Punto p2;
Punto p3;
Punto p4;
p1 = new Punto(20, 20);
p2 = new Punto(200, 20);
p3 = new Punto(20, 150);
p4 = new Punto(200, 150);
L1 = new Linea(p1, p2);
L2 = new Linea(p3, p4);
L3 = new Linea(p1, p3);
L4 = new Linea(p2, p4);
}
/**
* Constructor de un rectangulo que recibe como parametros cuatro lineas.
* @param a Recibe una linea de la clase Linea.java.
* @param b Recibe una linea de la clase Linea.java.
* @param c Recibe una linea de la clase Linea.java.
* @param d Recibe una linea de la clase Linea.java.
*/
public Rectangulo(Linea a, Linea b, Linea c, Linea d) {
L1 = a;
L2 = b;
L3 = c;
L4 = d;
}
/**
* Costructor de un rectangulo a patir de otro(costructor copia).
* @param r Recibe un objeto de la clase Rectangulo.java.
*/
public Rectangulo(Rectangulo r) {
L1 = r.L1;
L2 = r.L2;
L3 = r.L3;
L4 = r.L4;
}
/**
* Metodo que determina el lado A del rectangulo
* @return double El primer lado del rectangulo
*/
public double ladoA() {
return L1.getP1().distancia(L1.getP2());
}
/**
* Metodo que determina el lado B del rectangulo
* @return double El segundo lado del rectangulo
*/
public double ladoB() {
return L2.getP1().distancia(L2.getP2());
}
/**
* Metodo que determina el lado C del rectangulo
* @return double El tercer lado del rectangulo
*/
public double ladoC() {
return L3.getP1().distancia(L3.getP2());
}
/**
* Metodo que determina el lado D del rectangulo
* @return double El cuarto lado del rectangulo
*/
public double ladoD() {
return L4.getP1().distancia(L4.getP2());
}
/**
* Metodo que calcula el perimetro de un rectangulo.
* @return double Devuelve el perimetro del rectángulo es igual a la suma de
* las longitudes de sus cuatro lados(p = 2[b*h]).
*/
public double perimetro() {
double p;
p = 2 * (ladoB() + ladoD());
return p;
}
/**
* Metodo que determina el area de un rectangulo.
* @return dobule Devuelve la area de un rectangulo que es igual a la base
* por la altura(a = b*h).
*/
public double area() {
double a;
a = (ladoB() * ladoD());
return a;
}
/**
* Metodo para determinar si se trata de un rectangulo o un cuadrado
*/
public void TipoFigura() {
double d1, d2, d3, d4;
d1 = ladoA();
d2 = ladoB();
d3 = ladoC();
d4 = ladoD();
if (d1 == d2 & d2 == d3 & d3 == d4) {
JOptionPane.
showMessageDialog(null,
"La figura creda es un \"Cuadrado\""); } else if (d1 == d2 & d2 != d3 & d3 == d4) {
JOptionPane.
showMessageDialog(null,
"La figura creda es un \"Rectangulo\""); } else {
JOptionPane.
showMessageDialog(null,
"La figura creda no es nada ni Rectangulo o Cuadrado"); }
}
/**
* Metodo que determina si dos rectangulos son iguales.
* @param Rectangulo Objeto de la clase rectangulo con el cual se comparara.
* @return boolean Devuelve true sin son iguales, false en otro caso.
*/
public boolean equals(Rectangulo r) {
boolean a;
if (L1.equals(r.L1) == L2.equals(r.L2) == L3.equals(r.L3)) {
a = true;
} else if (ladoA() == r.ladoA() && ladoB() == r.ladoB() && ladoC() == r.ladoC() && ladoD() == r.ladoD()) {
a = true;
} else {
a = false;
}
return a;
}
/**
* Metodo que desplasa el rectangulo horizontalmente(eje X).
* @param d Recibe un entero la cantidad de unidades para desplazar.
*/
public void desplasarX(int d){
int f = 0;
L1.getP1().desplazar(d, f); L1.getP2().desplazar(d, f);
L2.getP1().desplazar(d, f); L2.getP2().desplazar(d, f);
L3.getP1().desplazar(d, f); L3.getP2().desplazar(d, f);
L4.getP1().desplazar(d, f); L4.getP2().desplazar(d, f);
}
/**
* Metodo que desplasa el rectangulo verticalmente(eje Y).
* @param d Recibe un entero la cantidad de unidades para desplazar.
*/
public void desplasarY(int d){
int f = 0;
L1.getP1().desplazar(f, d); L1.getP2().desplazar(f, d);
L2.getP1().desplazar(f, d); L2.getP2().desplazar(f, d);
L3.getP1().desplazar(f, d); L3.getP2().desplazar(f, d);
L4.getP1().desplazar(f, d); L4.getP2().desplazar(f, d);
}
/**
* Metodo que calcula la union de dos rectangulos es decir, el rectangulo
* menor que incluya a ambos
*/
public Rectangulo union(Rectangulo r){
return null;
}
/**
* Metodo para calcular la interseccion de dos rectangulos
*/
public Rectangulo interseccion(Rectangulo r){
}
}