Cet article expliquera comment utiliser la programmation orientée objet Java pour calculer le périmètre et l'aire d'une forme, et améliorer la conception grâce à l'héritage et au polymorphisme, rendant le code plus concis et plus facile à maintenir.
- Définir la forme de la classe abstraite
Tout d'abord, nous devons définir une classe abstraite Shape, qui contient un double PI constant statique immuable, et deux méthodes abstraites getPerimeter et getArea, qui sont utilisées respectivement pour calculer le périmètre et l'aire de la forme. Voici le code de la classe Shape :
public abstract class Shape {
public static final double PI = 3.14;
public abstract double getPerimeter();
public abstract double getArea();
}
- Définir les classes Rectangle et Cercle
Ensuite, nous devons définir deux classes, Rectangle et Circle, qui héritent toutes deux de la classe Shape et implémentent les méthodes getPerimeter et getArea. La classe Rectangle contient une propriété privée de largeur et de longueur privée, qui représentent la largeur et la longueur du rectangle ; la classe Circle contient une propriété privée de rayon, qui représente le rayon du cercle. Voici le code des classes Rectangle et Circle :
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 + "]";
}
}
- Écrire les méthodes sumAllArea et sumAllPerimeter
Afin de calculer la somme de l'aire et du périmètre de tous les objets du tableau de formes, nous pouvons écrire deux méthodes statiques sumAllArea et sumAllPerimeter. Voici le code des méthodes sumAllArea et 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;
}
- Utilisé dans la fonction principale
Dans la fonction principale, nous pouvons d’abord saisir un entier n, indiquant que n formes doivent être saisies. Ensuite, nous pouvons lire n lignes de données via une boucle, créer un objet Rectangle ou Cercle basé sur le type de forme d'entrée et le placer dans le tableau de formes. Ensuite, nous pouvons appeler respectivement les méthodes sumAllArea et sumAllPerimeter pour calculer la somme des aires et la somme du périmètre de toutes les formes, et utiliser la méthode Arrays.toString pour générer les informations de toutes les formes. Enfin, nous pouvons afficher le type et le type parent de chaque forme séparément. Voici le code de la fonction principale :
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());
}
}
}
Dans le code ci-dessus, nous saisissons d'abord l'entier n, puis lisons n lignes de données via une boucle, créons un objet Rectangle ou Cercle basé sur le type de forme d'entrée et le plaçons dans le tableau de formes. Ensuite, nous appelons respectivement les méthodes sumAllArea et sumAllPerimeter pour calculer la somme des aires et la somme du périmètre de toutes les formes, et utilisons la méthode Arrays.toString pour générer les informations de toutes les formes. Enfin, nous utilisons une boucle for pour parcourir le tableau de formes et afficher respectivement le type et le type parent de chaque forme.
- Résumer
Cet article explique comment utiliser la programmation orientée objet Java pour calculer le périmètre et l'aire d'une forme, et améliore la conception grâce à l'héritage et au polymorphisme, rendant le code plus concis et plus facile à maintenir. En apprenant les méthodes présentées dans cet article, les lecteurs peuvent mieux maîtriser les connaissances de base de la programmation orientée objet Java et améliorer leurs capacités de programmation.
Il convient de noter que lors de la lecture d'un mélange de nextInt et nextLine, un problème de retour chariot et de saut de ligne en fin de ligne peut survenir. Vous devez utiliser scanner.nextLine() pour lire le retour chariot et le saut de ligne à la fin. de la ligne et jetez-la pour éviter les erreurs.
Le code complet est le suivant :
importer java.util.Arrays ;
importer java.util.Scanner ;
classe abstraite publique Forme { public static final double PI = 3,14 ;
public abstrait double getPerimeter();
public abstrait double getArea();
}
class Rectangle extends Shape { private int width ; longueur entière privée ;
public Rectangle (int width, int length) { this.width = width; this.length = longueur; }
public double getPerimeter() { return 2 * (largeur + longueur); }
public double getArea() { return width * length; }
public String toString() { return "Rectangle [width=" + width + ", length=" + length + "]"; } }
Le cercle de classe étend la forme { rayon int privé ;
public Circle(int rayon) { this.radius = rayon; }
public double getPerimeter() { return 2 * PI * rayon ; }
public double getArea() { return PI * rayon * rayon ; }
public String toString() { return "Cercle [rayon=" + rayon + "]"; } }
public class Main { public static double sumAllArea (Shape[] formes) { double sum = 0; pour (Forme forme : formes) { sum += shape.getArea(); } renvoie la somme ; }
public static double sumAllPerimeter(Shape[] formes) { double sum = 0; for (Forme forme : formes) { sum += shape.getPerimeter(); } renvoie la somme ; }
public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); scanner.nextLine(); // Entrée et saut de ligne à la fin de la ligne de lecture
Shape[] formes = new Shape[n];
for (int i = 0; i < n; i++) { Type de chaîne = scanner.next(); if (type.equals("rect")) { int width = scanner.nextInt(); int longueur = scanner.nextInt(); formes[i] = nouveau Rectangle(largeur, longueur); } else if (type.equals("cir")) { int radius = scanner.nextInt(); formes[i] = nouveau Cercle(rayon); } scanner.nextLine(); // 读入行尾回车换行 }
double sumArea = sumAllArea(formes);
double sumPerimeter = sumAllPerimeter(formes);
System.out.println(sumPerimeter);
System.out.println(sumArea);
System.out.println(Arrays.toString(formes));
pour (Forme forme : formes) { System.out.println(shape.getClass() + "," + shape.getClass().getSuperclass()); } } }