Este artigo descreve a simulação de movimento planetário implementado pela programação Java. Compartilhe -o para sua referência, como segue:
A programação da linguagem Java que eu estava ansiosa há muito tempo também chegou ao fim. Em alguns meses, basicamente dominei o uso simples de Java, aprendi o principal conhecimento básico de Java, pensamento orientado a objetos, controle de simultaneidade com vários threads, design de interface de giro, produção de animação, etc. Finalmente, planejo criar um design de curso que possa cobrir o máximo de conhecimento aprendido possível e conectá-lo em série. Portanto, considerei a implementação de um software simples para simular o movimento planetário. As principais idéias são as seguintes:
A animação é usada para simular o movimento planetário. Há um planeta central no painel principal, e uma órbita elíptica é desenhada, e um planeta em movimento está se movendo em torno do planeta central. Ao mesmo tempo, existem quatro botões definidos no canto inferior direito, a saber, "Start", "Pausar", "Acelerar" e "desacelerar" que podem fazer com que os planetas se movam, pausem, acelerem e desacelerem, respectivamente.
1. Design de classe:
Estrelas herda do JPanel. A classe Star é a classe base de planetas, e todos os planetas em movimento são herdados da classe Star. O método interno draw () desenha principalmente um círculo sólido, e o objetivo é garantir que o planeta central sempre seja exibido toda vez que for desenhado. O método PaintComponent () substitui o método de desenho JPanel, com o objetivo de garantir que os objetos de instância da classe Stars herdados da classe Star possam desenhar seus próprios planetas. do seguinte modo:
Pacotes Star; importar java.awt.color; importar java.awt.graphics; importar javax.swing.jpanel; a classe pública Star estende Jpanel { / *** classe planetária básica* / private estático final serialversionUid long longUid = 1L; int x, y; int largura, altura; public star () {width = 10; altura = 10; } public star (int x, int y) {this.x = x; this.y = y; largura = 10; altura = 10; } public void Draw (gráficos g) {g.setColor (color.blue); G.Filloval (x, y, largura, altura); } Void PaintComponent protegido (gráficos g) {super.paintcomponent (g); G.Filloval (x, y, largura, altura); }}A classe Stars herda da classe Star, que é um refinamento adicional da classe Star, representando planetas em movimento. A classe Alfa in the Stars representa o ângulo de partida do planeta em movimento, e a velocidade representa a velocidade do movimento, que pode ser modificada. Longo e curto representam o eixo principal e o eixo menor da trajetória elíptica, respectivamente. O centro representa o planeta central de seu objeto instanciado. A função taintComponent () substitui o pintura de tinta (), refere -se internamente à função draw () da classe pai e desenha a faixa elíptica de acordo com longa, curta e longa e curta são determinadas pelo objeto de instanciação que chama o construtor. A função move () descreve a equação de mudança de x e y, ou seja, alterações em torno da órbita elíptica e também especifica a maneira como a ALFA muda. A função inicial () indica o início do encadeamento, a função pausa () indica a pausa do encadeamento, a função aceleração () indica a operação de aceleração no planeta e a função desacelerada () indica a operação na desaceleração do planeta.
O objetivo da classe PTHread é controlar os threads, ou seja, o movimento inicial, pausar movimento, acelerar e desacelerar do planeta através da instanciação da classe PTHread. A classe Pthread herda da classe Thread e está incluída na classe Start. Portanto, a classe Pthread não pode ser definida como uma classe comum. A classe PTHread fornece um método RUN (), constantemente chama o método Repaint () para repintar a figura. O método setSUSPEND () usa a alteração da variável booleana para pausar o thread (ligue para o método notifyAll ()). Como a classe Pthread é uma classe interna de partidas, um objeto da classe PTHread será gerado na classe Start e o thread será operado usando esse objeto.
O design é o seguinte:
Pacote Star; importar java.awt.color; importar java.awt.graphics; as estrelas da classe pública estende a estrela { / *** Planeta em movimento* / private estático final serialversionuid = 1L; Alfa duplo; velocidade dupla; Star Center; int long; // Darken Axis Int Short; // Eixo curto Estrelas públicas (int px, int py, Star Center) {super (px, py); this.Center = Center; Long = (px - Center.x)*2; Curto = (py - centro.y)*2; this.setOpAque (true); // move (); alfa = 0; velocidade = 0,001; } Void PaintComponent protegido (gráficos g) {super.paintcomponent (g); Center.Draw (g); // desenhe o ponto central do ponto (); g.setColor (color.green); G.Drawoval (Center.x-Long/2, Center.y-short/2, longo, curto); } public void move () {x = Center.x + (int) (long/2*math.cos (alfa)); y = Center.y + (int) (curto/2*math.sin (alfa)); // Execute alfa ao longo da trajetória elíptica += velocidade; // O ângulo está mudando constantemente} classe pThread estende o thread {// RepiAnt Thread classe Private boolean suspender = true; String privado Control = ""; public void run () {while (true) {sincronizado (control) {if (suspense) {// move (); repintar (); }}}} public void SetSSSOPEND (boolean s) {// Defina o método de pausa de thread se (! }} this.suspend = s; }} public pthread pt = new pthread (); public void start () {pt.SetSUSPEND (true); pt.start (); } public void pause () {pt.SetSUSPEND (false); } public void acelere () {// Acelere o método se (velocidade> 0) {// Aceleração do ângulo 0,0002 Velocidade += 0,0002; } else Speed = 0,001; } public void DeCelerate () {// DeCelerate Method if (speed> 0) {speed -= 0,0002; // Desaceleração em cada ângulo 0,0002} // Se a velocidade for desacelerada para 0, você não poderá continuar desacelerando. A velocidade é 0. Stop Motion Else Speed = 0; }}A classe Starframe é o painel de inicialização deste programa. Ao instantar essa classe, a interface principal do programa é gerada e os componentes, botões e etiquetas planetários são adicionados ao painel. O método interno getPanel () define os dois botões e retorna um jpanel (adiciona quatro botões ao jpanel). O método getLabel () retorna um jlabel com uma descrição literal. O objeto central é uma instanciação da classe Star, e P1 é uma instanciação da classe Stars, representando o planeta central e o planeta orbitador, respectivamente. JB1, JB2, JB3 e JB4 são os botões de controle para partida, pausa, aceleração e desaceleração do planeta, respectivamente. A imagem representa a imagem de fundo da interface e o LayeredPanel é o painel hierárquico da interface, que facilita a configuração da imagem de fundo. JP, JL é o componente que define a imagem de fundo. O design é o seguinte:
Pacotes Star Pacotes Java.awt.borderlayout; importar java.awt.color; importar java.awt.font; importar java.awt.event.actionEvent; importar java.ilkt.event.actionListener; importação javaxswing.imageicon; import.event.jbutton; javax.swing.jlabel; importar javax.swing.jlayeredpane; importar javax.swing.jpanel; classe pública starframe estende jframe { / ***painel de inicialização de simulação planetária* / private Static Final Long SerialversionUid = 1L; Star Center = New Star (300.200); // Defina as estrelas do Planeta Center P1 = Novas Estrelas (300+230.200+130, Centro); // O planeta ao redor das estrelas centrais P2 = novas estrelas (300+230+20.200+130+20, P1); Jbutton jb1 = new jbutton ("start"); Jbutton jb2 = novo jbutton ("pausa"); Jbutton jb3 = novo jbutton ("acelerar"); Jbutton jb4 = novo jbutton ("desacelero"); Imageicon imagem = new imageicon ("timg.jpg"); // imagem de fundo, use o caminho relativo para definir o jlayeredpane em camada em camada; // define um painel hierárquico para colocar imagens de fundo jpanel jp; Jlabel JL; public starframe () {// Defina a posição para P1 e tamanho P1.setbounds (40.40.600.400); // p2.setbounds (40,40.600.400); // Defina a imagem em segundo plano, coloque a imagem de fundo em Jlabel, coloque o jlabel em jpanel em camada em camada = new jlayeredpane (); jp = new jpanel (); jp.setBounds (0,0, image.geticonwidth (), image.geticonheight ()); jl = novo Jlabel (imagem); jp.add (JL); // Coloque o JP na camada inferior. LayeredPane.add (jp, jlayeredpane.default_layer); // coloque o JB no primeiro andar em camada em camada.add (p1, jlayeredpane.modal_layer); // layeredpane.add (p2, jlayeredpane.modal_layer); LayeredPane.add (getPanel (), jlayeredpane.modal_layer); LayeredPane.add (getLabel (), jlayeredpane.modal_layer); LayeredPane.add (getLabel (), jlayeredpane.modal_layer); // Defina ações relacionadas para JB1, JB2, JB3 e JB4, respectivamente, JB1.AddactionListener (new ActionListener () {public void ActionPormed (ActionEvent E) {// TODO Método Auto-Generated Stub P1.start ();}}); jb2.addactionListener (new ActionListener () {public void ActionPerformed (ActionEvent E) {// TODO Método Geral Goletado Stub P1.Pause ();}}); jb3.addactionListener (new ActionListener () {public void ActionPerformed (ActionEvent E) {// TODO Método Geral Golido Stub P1.acceleate ();}}); jb4.addactionListener (new ActionListener () {public void ActionPerformed (ActionEvent E) {// TODO Método Geralizado Stub P1.Decelerate ();}}); this.setLayeredPane (LayeredPane); this.settitle ("estrela"); this.setbounds (100.100.1000.600); this.setDefaultCloseoperation (jframe.exit_on_close); this.setVisible (true); } private jpanel getPanel () {// retorna os quatro botões definidos jpanel jp = new jpanel (); jp.add (JB1); jp.add (JB2); jp.add (JB3); jp.add (JB4); jp.setbounds (750.450,200,70); retornar jp; } private jpanel getLabel () {// retorna o texto Descrição Jlabel jl = new jlabel ("simulação planetária"); jl.setforeground (color.red); // Defina a fonte de cor jl.setFont (new Font ("diálogo", 0,20)); // Defina a fonte jpanel jp = new jpanel (); jp.add (JL, borderlayout.center); jp.setbounds (800,0,150,40); retornar jp; } public static void main (string [] args) {@suppresswarnings ("não utilizado") starframe f = new starframe (); }}Efeito de corrida:
2. Objeto:
Como o Java é um idioma orientado a objetos, é claro, não pode ser implementado por funções como o idioma C. Como não pode haver objetos na estrutura do curso?
Principais objetos:
centro de objeto, ou seja, planeta central
Objeto P1, orbitando o planeta
Objeto PT, isto é, o objeto responsável por controlar o segmento
Objeto F, ou seja, o painel de inicialização do programa
3. Relação entre objetos (interação)
A relação entre P1 e Center: The Star Class é a classe base do planeta, herdada do JPanel, e o raio básico e as coordenadas são definidos internamente. De fato, o centro de objeto instanciado é o centro do planeta em movimento. A classe Stars herdada da Star representa um planeta em movimento, que é um refinamento adicional. Portanto, o objeto de instanciação P1 representa um planeta 1 em movimento e se move ao redor do centro. Ao mesmo tempo, o centro é passado como um parâmetro para P1 para concluir a interação entre os dois. Esta é a relação entre o objeto P1 e o centro. Após instantar o centro de objeto, um círculo sólido será desenhado sob as coordenadas especificadas e as coordenadas X e Y do objeto central não mudarão. Com base no desenho de um círculo sólido, o objeto P1 desenha as órbitas elípticas do eixo principal especificado e do eixo menor, de acordo com as coordenadas do centro. Ao mesmo tempo, implementa a classe Thread internamente, o que não interrompe o thread de execução. A relação de herança mútua permite que o centro e o P1 desenhem gráficos sem interferir um com o outro. Vale ressaltar que, no método PaintComponent () na classe Stras, o método de draw () do objeto central ainda precisa ser chamado, porque o thread chamará o método Repaint () no início. Se o método de draw () do centro não for implementado, o resultado final não mostrará o planeta central.
A relação entre Pt e P1: a classe PTHread herda da classe Thread e define o método run (). Ao instantar o objeto P1, o método START () pode ser chamado para iniciar o thread. A classe PTHread está dentro da classe Start, para que o encadeamento possa ser controlado através dos métodos em P1, ou seja, pode controlar sua velocidade, acelerar e desacelerar e controlar se é executado ou não.
A relação entre F e cada objeto: Starframe herda JFrame. De fato, o objeto de instanciação F adiciona cada objeto à tela, cria uma interface e controla o tamanho e a posição de cada componente, que é a chave para a operação do programa.
4. Entendimento orientado a objetos:
Tudo é um objeto. Alguns alunos me perguntaram qual é o objeto. Respondi que aqueles com novos são objetos e objetos são instanciais de classes. Neste programa, inúmeros planetas podem ser criados instantando a classe Stars (teoricamente, sim). No entanto, alguns problemas na implementação de funções internas são difíceis de resolver. O principal é reescrever o método PaintComponent (). Depois de criar o objeto novamente, o método será reescrito novamente, para que ocorra um problema inevitável, o que também é um arrependimento que não pode ser resolvido!
For more Java-related content, readers who are interested in this site can view the topics: "Introduction and Advanced Tutorial on Java Object-Oriented Programming", "Tutorial on Java Data Structure and Algorithm", "Summary of Java Operation DOM Node Skills", "Summary of Java File and Directory Operation Skills" and "Summary of Java Cache Operation Skills"
Espero que este artigo seja útil para a programação Java de todos.