Este artículo presentará cómo utilizar la programación orientada a objetos Java para calcular el perímetro y el área de una forma, y mejorará el diseño mediante herencia y polimorfismo, haciendo que el código sea más conciso y más fácil de mantener.
- Definir forma de clase abstracta
Primero, necesitamos definir una clase abstracta Shape, que contiene un PI doble constante estático inmutable, y dos métodos abstractos getPerimeter y getArea, que se utilizan para calcular el perímetro y el área de la forma respectivamente. El siguiente es el código para la clase Forma:
public abstract class Shape {
public static final double PI = 3.14;
public abstract double getPerimeter();
public abstract double getArea();
}
- Definir clases de Rectángulo y Círculo
A continuación, necesitamos definir dos clases, Rectángulo y Círculo, que heredan de la clase Forma e implementan los métodos getPerimeter y getArea. La clase Rectángulo contiene propiedades privadas de ancho y largo, que representan el ancho y el largo del rectángulo; la clase Círculo contiene una propiedad privada de radio, que representa el radio del círculo. El siguiente es el código para las clases Rectángulo y Círculo:
public class Rectangle extends Shape {
private int width;
private int length;
public Rectangle(int width, int length) {
this.width = width;
this.length = length;
}
public double getPerimeter() {
return 2 * (width + length);
}
public double getArea() {
return width * length;
}
public String toString() {
return "Rectangle [width=" + width + ", length=" + length + "]";
}
}
public class Circle extends Shape {
private int radius;
public Circle(int radius) {
this.radius = radius;
}
public double getPerimeter() {
return 2 * PI * radius;
}
public double getArea() {
return PI * radius * radius;
}
public String toString() {
return "Circle [radius=" + radius + "]";
}
}
- Escribir métodos sumAllArea y sumAllPerimeter
Para calcular la suma del área y el perímetro de todos los objetos en la matriz de formas, podemos escribir dos métodos estáticos sumAllArea y sumAllPerimeter. El siguiente es el código para los métodos sumAllArea y sumAllPerimeter:
public static double sumAllArea(Shape[] shapes) {
double sum = 0;
for (Shape shape : shapes) {
sum += shape.getArea();
}
return sum;
}
public static double sumAllPerimeter(Shape[] shapes) {
double sum = 0;
for (Shape shape : shapes) {
sum += shape.getPerimeter();
}
return sum;
}
- Utilizado en la función principal.
En la función principal, primero podemos ingresar un número entero n, lo que indica que se van a ingresar n formas. Luego, podemos leer n filas de datos a través de un bucle, crear un objeto Rectángulo o Círculo según el tipo de forma de entrada y colocarlo en la matriz de formas. A continuación, podemos llamar a los métodos sumAllArea y sumAllPerimeter respectivamente para calcular la suma del área y el perímetro de todas las formas, y usar el método Arrays.toString para generar la información de todas las formas. Finalmente, podemos generar el tipo y el tipo principal de cada forma por separado. El siguiente es el código de la función principal:
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
Shape[] shapes = new Shape[n];
for (int i = 0; i < n; i++) {
String type = scanner.next();
if (type.equals("rect")) {
int width = scanner.nextInt();
int length = scanner.nextInt();
shapes[i] = new Rectangle(width, length);
} else if (type.equals("cir")) {
int radius = scanner.nextInt();
shapes[i] = new Circle(radius);
}
}
double sumArea = sumAllArea(shapes);
double sumPerimeter = sumAllPerimeter(shapes);
System.out.println(sumPerimeter);
System.out.println(sumArea);
System.out.println(Arrays.toString(shapes));
for (Shape shape : shapes) {
System.out.println(shape.getClass() + "," + shape.getClass().getSuperclass());
}
}
}
En el código anterior, primero ingresamos el número entero n, luego leemos n filas de datos a través de un bucle, creamos un objeto Rectángulo o Círculo según el tipo de forma de entrada y lo colocamos en la matriz de formas. A continuación, llamamos a los métodos sumAllArea y sumAllPerimeter respectivamente para calcular la suma del área y el perímetro de todas las formas, y usamos el método Arrays.toString para generar la información de todas las formas. Finalmente, usamos un bucle for para recorrer la matriz de formas y generar el tipo y el tipo principal de cada forma respectivamente.
- Resumir
Este artículo presenta cómo utilizar la programación orientada a objetos Java para calcular el perímetro y el área de una forma, y mejora el diseño mediante herencia y polimorfismo, haciendo que el código sea más conciso y más fácil de mantener. Al aprender los métodos presentados en este artículo, los lectores pueden dominar aún más los conocimientos básicos de la programación orientada a objetos de Java y mejorar sus habilidades de programación.
Cabe señalar que al leer una combinación de nextInt y nextLine, puede ocurrir un problema de retorno de carro y avance de línea al final de la línea. Debe usar scanner.nextLine() para leer el retorno de carro y el avance de línea al final. de la línea y descártelo para evitar errores.
El código completo es el siguiente:
importar java.util.Arrays;
importar java.util.Scanner;
clase abstracta pública Forma { doble final estático público PI = 3,14;
getPerimeter doble abstracto público();
resumen público doble getArea();
}
clase Rectángulo extiende Forma { privado int ancho; longitud interna privada;
Rectángulo público (int ancho, int largo) { this.width = ancho; this.length = longitud; }
public double getPerimeter() { return 2 * (ancho + largo); }
público doble getArea() { retorno ancho * largo; }
public String toString() { return "Rectángulo [ancho=" + ancho + ", largo=" + largo + "]"; } }
clase Círculo extiende Forma { radio int privado;
Círculo público (radio int) { this.radius = radio; }
public double getPerimeter() { return 2 * PI * radio; }
public double getArea() { return PI * radio * radio; }
public String toString() { return "Círculo [radio=" + radio + "]"; } }
clase pública Principal { pública estática doble sumaTodaÁrea(Forma[] formas) { doble suma = 0; for (Forma forma: formas) { suma += forma.getArea(); } suma devuelta; }
pública estática doble sumaTodoPerímetro(Forma[] formas) { doble suma = 0; for (Forma forma: formas) { suma += forma.getPerimeter(); } suma devuelta; }
public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); scanner.nextLine(); // Ingrese y avance de línea al final de la línea de lectura
Forma[] formas = nueva Forma[n];
for (int i = 0; i < n; i++) { Tipo de cadena = scanner.next(); if (type.equals("rect")) { int ancho = scanner.nextInt(); longitud int = escáner.nextInt(); formas[i] = nuevo Rectángulo(ancho, largo); } else if (type.equals("cir")) { int radio = scanner.nextInt(); formas[i] = nuevo Círculo(radio); } escáner.nextLine(); // 读入行尾回车换行 }
double sumaArea = sumAllArea(formas);
doble sumaPerímetro = sumaTodoPerímetro(formas);
System.out.println(sumaPerimetro);
System.out.println(sumaArea);
System.out.println(Arrays.toString(formas));
for (Forma forma: formas) { System.out.println(shape.getClass() + "," + shape.getClass().getSuperclass()); } } }