Ejemplo de movimiento planetario simulado implementado por la programación Java

Este artículo describe la simulación del movimiento planetario implementado por la programación Java. Compártelo para su referencia, como sigue:

La programación de lenguaje Java que había estado esperando durante mucho tiempo también ha llegado a su fin. En unos pocos meses, básicamente he dominado el uso simple de Java, aprendí el principal conocimiento básico de Java, pensamiento orientado a objetos, control de concurrencia múltiple, diseño de interfaz de swing, producción de animación, etc. Finalmente, planeo crear un diseño de cursos que pueda cubrir la mayor cantidad de conocimiento aprendida como sea posible y conectarlo en la serie. Por lo tanto, he considerado implementar un software simple para simular el movimiento planetario. Las ideas principales son las siguientes:

La animación se utiliza para simular el movimiento planetario. Hay un planeta central en el panel principal, y se dibuja una órbita elíptica, y un planeta en movimiento se mueve alrededor del planeta central. Al mismo tiempo, hay cuatro botones establecidos en la esquina inferior derecha, a saber, "inicio", "pausa", "acelerar" y "desacelerar" que pueden hacer que los planetas se muevan, pausen, aceleren y desaceleren respectivamente.

1. Diseño de clase:

La estrella hereda de Jpanel. La clase Star es la clase base de planetas, y todos los planetas en movimiento se heredan de la clase Star. El método interno Draw () dibuja principalmente un círculo sólido, y el propósito es garantizar que el planeta central siempre se muestre cada vez que se dibuja. El método PaintComponent () anula el método de dibujo JPanel, con el objetivo de garantizar que la clase de objetos de instancia de las estrellas heredadas de la clase Star pueda dibujar sus propios planetas. como sigue:

 Star de paquete; import java.awt.color; import java.awt.graphics; import javax.swing.jpanel; la estrella de clase pública extiende jpanel { / *** clase planetaria básica* / privado estático final Long SerialVersionUid = 1L; int x, y; int ancho, altura; public star () {width = 10; altura = 10; } public Star (int x, int y) {this.x = x; this.y = y; ancho = 10; altura = 10; } public void Draw (Graphics g) {G.SetColor (color.blue); G.Filloval (x, y, ancho, altura); } protegido void pintarComponent (Graphics g) {super.PaintComponent (g); G.Filloval (x, y, ancho, altura); }}

La clase Stars hereda de la clase Star, que es un refinamiento adicional de la clase Star, que representa los planetas en movimiento. La clase ALFA en la clase STARS representa el ángulo inicial del planeta en movimiento, y la velocidad representa la velocidad del movimiento, que puede modificarse. Largo y corto representan el eje principal y el eje menor de la trayectoria elíptica respectivamente. El centro representa el planeta central de su objeto instanciado. La función PaintComponent () anula PaintComponent (), se refiere internamente a la función Draw () de la clase principal y dibuja la pista elíptica de acuerdo con Long, Short y Long y Short se determinan por el objeto de instancia que llama al constructor. La función Move () describe la ecuación de cambio de X e Y, es decir, cambia alrededor de la órbita elíptica, y también especifica la forma en que cambia Alfa. La función start () indica el inicio del hilo, la función pausa () indica la pausa de hilo, la función de aceleración () indica la operación de aceleración en el planeta y la función desacelerada () indica la operación en la desaceleración del planeta.

El propósito de la clase PTHREAD es controlar los hilos, es decir, el movimiento inicial, el movimiento de pausa, acelerar y desacelerar el planeta mediante la instancia de la clase PTHRADO. La clase PTHREAD hereda de la clase de hilo y se incluye en la clase de inicio. Por lo tanto, la clase PTHREAD no puede definirse como una clase común. La clase PTHREAD proporciona un método run (), llama constantemente el método Repint () para volver a pintar la imagen. El método setSuspend () utiliza cambiar la variable booleana para pausar el hilo (llamar al método notifyall ()). Debido a que la clase PTHREAD es una clase interna de arranque, se generará un objeto de la clase PTHREAD en la clase de inicio y el hilo se operará usando este objeto.

El diseño es el siguiente:

 paquete estrella; import java.awt.color; import java.awt.graphics; las estrellas de clase pública extienden estrella { / *** Planeta en movimiento* / Private Static final Long SerialVersionUid = 1l; doble alfa; doble velocidad; Centro estrella; int // oscurece el eje int short; // estrellas públicas de eje corto (int px, int py, centro de estrellas) {super (px, py); this.center = Center; Long = (px - center.x)*2; Short = (Py - Center.y)*2; this.SetOpaque (true); // Move (); alfa = 0; velocidad = 0.001; } protegido void pintarComponent (Graphics g) {super.PaintComponent (g); Center.draw (g); // Dibuja el movimiento del punto central (); G.SetColor (color.green); G.Drawoval (Center.x-Long/2, Center.y-Short/2, largo, corto); } public void Move () {x = center.x + (int) (long/2*math.cos (Alfa)); y = Center.y + (int) (Short/2*Math.sin (Alfa)); // Ejecute Alfa a lo largo de la trayectoria elíptica += velocidad; // El ángulo está cambiando constantemente} La clase pThread extiende el hilo {// Repintio de hilo de la clase Private boolean suspend = true; control de cadena privada = ""; public void run () {while (true) {sincronizado (control) {if (suspender) {// mude (); repintado (); }}}} public void setsSopend (boolean s) {// establecer el método de pausa de hilo if (! suspend) {sincronizado (control) {control.notifyAll (); }} this.suspend = s; }} public pthread pt = new pthread (); public void start () {pt.setsuspend (true); pt.start (); } public void pause () {pt.setsUspend (falso); } public void acelerate () {// Método de acelerar if (Speed> 0) {// Aceleración de ángulo 0.0002 Velocidad += 0.0002; } más velocidad = 0.001; } public void DeCelerate () {// Método desacelerado if (Speed> 0) {Speed -= 0.0002; // Desaceleración en cada ángulo 0.0002} // Si la velocidad se desacelera a 0, no puede continuar desacelerando. La velocidad es 0. Stop Motion Else Speed = 0; }}

La clase StarFrame es el panel de inicio de este programa. Al instancias de esta clase, se genera la interfaz del programa principal y se agregan componentes planetarios, botones y etiquetas al panel. El método GetPanel () interno establece los dos botones y devuelve un jpanel (agrega cuatro botones al jpanel). El método getLabel () devuelve un jlabel con una descripción literal. El objeto central es una instanciación de la clase Star, y P1 es una instanciación de la clase Stars, que representa el planeta central y el planeta en órbita, respectivamente. JB1, JB2, JB3 y JB4 son los botones de control para comenzar, pausar, acelerar y desacelerar el planeta respectivamente. La imagen representa la imagen de fondo de la interfaz, y CapeeredPanel es el panel jerárquico de la interfaz, que facilita la configuración de la imagen de fondo. JP, JL es el componente que establece la imagen de fondo. El diseño es el siguiente:

 Star de paquete; import java.awt.borcyloutout; import java.awt.color; import java.awt.font; import java.awt.event.ActionEvent; import java.awt.event.actionListener; import javax.swing.imageicon; import javax.swing.jbutton; import javax.swing.jframe; import; javax.swing.jlabel; import javax.swing.jlayeredpane; import javax.swing.jpanel; public class StarFrame extiende Jframe { / ***Panel de inicio de simulación planetaria* / Private Static final Long SerialverSionuid = 1L; Star Center = New Star (300,200); // Defina las estrellas del planeta central P1 = nuevas estrellas (300+230,200+130, centro); // El planeta que rodea las estrellas centrales P2 = nuevas estrellas (300+230+20,200+130+20, P1); JButton JB1 = new JButton ("Start"); JButton JB2 = new JButton ("Pausa"); JButton JB3 = new JButton ("Acelerate"); JButton JB4 = new JButton ("Decelerate"); Imageicon image = new Imageicon ("timg.jpg"); // Imagen de fondo, use ruta relativa para definir jlayeredpane capas capas; // Defina un panel jerárquico para colocar imágenes de fondo jpanel jp; Jlabel JL; public starFrame () {// establece la posición para P1 y tamaño P1.setBounds (40,40,600,400); // p2.setBounds (40,40,600,400); // Defina la imagen de fondo, coloque la imagen de fondo en JLabel, coloque el jlabel en jpanel capaseredpane = new jlayeredPane (); jp = nuevo JPanel (); jp.setBounds (0,0, image.geticonwidth (), image.geticonheight ()); jl = new JLabel (imagen); JP.Add (JL); // Pon JP a la capa inferior. CapeeredPane.Add (JP, JlayeredPane.default_layer); // Pon JB al primer piso CapeeredPane.add (P1, JlayeredPane.Modal_Layer); // CapeeredPane.add (P2, JlayeredPane.Modal_Layer); CapeeredPane.Add (getPanel (), jlayeredpane.modal_layer); CapeeredPane.Add (getLabel (), jlayeredPane.modal_layer); CapeeredPane.Add (getLabel (), jlayeredPane.modal_layer); // Establezca acciones relacionadas para JB1, JB2, JB3 y JB4, respectivamente, jb1.addactionListener (new ActionListener () {public void ActionPerformed (ActionEvent E) {// TODO Método generado por autos. jb2.AddActionListener (new ActionListener () {public void ActionPerformed (ActionEvent E) {// TODO Método generado automático Stub p1.Pause ();}}); jb3.addactionListener (new ActionListener () {public void ActionPerformed (ActionEvent E) {// TODO Auto Generado Method Stub p1.accelate ();}}); JB4.AdDactionListener (new ActionListener () {public void ActionPerformed (ActionEvent E) {// TODO Auto Generado Method Stub p1.Decelerate ();}}); this.setLayeredPane (CapeeredPane); this.settitle ("estrella"); this.setBounds (100,100,1000,600); this.setDefaultCloseOperation (jframe.exit_on_close); this.setVisible (verdadero); } private jpanel getPanel () {// Devuelve los cuatro botones definidos jpanel jp = new jPanel (); JP.Add (JB1); JP.Add (JB2); JP.Add (JB3); JP.Add (JB4); JP.SetBounds (750,450,200,70); regresar jp; } private jpanel getLabel () {// Devuelve la descripción del texto jlabel jl = new jlabel ("simulación planetaria"); JL.SetForeGround (color.red); // Establezca el color de la fuente jl.setFont (nueva fuente ("diálogo", 0,20)); // Establezca la fuente jpanel jp = new jpanel (); JP.Add (JL, BorderLayout.Center); JP.SetBounds (800,0,150,40); regresar jp; } public static void main (string [] args) {@supresswarnings ("sin usar") StarFrame f = new StarFrame (); }}

Efecto de ejecución:

2. Objeto:

Debido a que Java es un lenguaje orientado a objetos, por supuesto, no puede ser implementado por funciones como el lenguaje C. ¿Cómo puede no haber objetos en la estructura del curso?

Objetos principales:

Centro de objetos, es decir, planeta central

Objeto P1, orbitando el planeta

Objeto pt, es decir, el objeto responsable de controlar el hilo

Objeto F, es decir, el panel de inicio del programa

3. Relación entre objetos (interacción)

La relación entre P1 y Center: la clase Star es la clase base del planeta, heredada de JPanel, y el radio y las coordenadas básicas se definen internamente. De hecho, el centro de objetos instanciado es el centro del planeta móvil. La clase Stars heredada de Star representa un planeta en movimiento, que es un refinamiento adicional. Por lo tanto, el objeto de instancia P1 representa un planeta en movimiento 1 y se mueve alrededor del centro. Al mismo tiempo, el centro se pasa como un parámetro a P1 para completar la interacción entre los dos. Esta es la relación entre el objeto P1 y el centro. Después de instanciar el centro del objeto, se dibujará un círculo sólido debajo de las coordenadas especificadas, y las coordenadas X e Y del objeto central no cambiarán. Sobre la base de dibujar un círculo sólido, el objeto P1 dibuja las órbitas elípticas del eje mayor especificados y el eje menor de acuerdo con las coordenadas del centro. Al mismo tiempo, implementa la clase de hilo internamente, que no interrumpe el hilo de ejecución. La relación de herencia mutua permite que Center y P1 dibujen gráficos sin interferir entre sí. Vale la pena mencionar que en el método PaintComponent () en la clase STRAS, el método Draw () del objeto central aún debe llamarse, porque el hilo llamará al método Repaint () al principio. Si no se implementa el método Draw () del centro, el resultado final no mostrará el planeta central.

La relación entre PT y P1: la clase PTHREAD hereda de la clase de subprocesos y define el método run (). Al instanciar el objeto P1, se puede llamar al método Start () para iniciar el hilo. La clase PTHREAD está dentro de la clase de inicio, por lo que el hilo se puede controlar a través de los métodos en P1, es decir, puede controlar su velocidad, acelerar y desacelerar, y controlar si se ejecuta o no.

La relación entre F y cada objeto: StarFrame hereda de Jframe. De hecho, el objeto de instancia F agrega cada objeto al lienzo, crea una interfaz y controla el tamaño y la posición de cada componente, que es la clave para la operación del programa.

4. Comprensión orientada a objetos:

Todo es un objeto. Algunos estudiantes me preguntaron cuál es el objeto. Respondí que aquellos con nuevos son objetos, y los objetos son la instanciación de las clases. En este programa, se pueden crear innumerables planetas instanciando la clase Stars (teóricamente, sí). Sin embargo, algunos problemas en la implementación de funciones internas son difíciles de resolver. Lo principal es reescribir el método PaintComponent (). Después de crear el objeto nuevamente, el método volverá a escribir, por lo que ocurrirá un problema inevitable, ¡lo cual también es un arrepentimiento que no se puede resolver!

Para obtener más contenido relacionado con Java, los lectores interesados en este sitio pueden ver los temas: "Introducción y tutorial avanzado sobre la programación orientada a objetos de Java", "Tutorial sobre la estructura de datos de Java y el algoritmo", "Resumen de la operación de Java DOM Node Node", "Summary of Java File and Directory Operation Skilly" y "Summary of Java Cache Skitch" Habilidades "

Espero que este artículo sea útil para la programación Java de todos.