Você está aqui: Java ::: Java para Engenharia ::: Física - Mecânica

Como calcular a Energia Potencial Gravitacional de um corpo dado a sua massa e altura em Java

Quantidade de visualizações: 186 vezes
A Energia Potencial Gravitacional ou Energia Gravitacional é a energia potencial que um objeto massivo tem em relação a outro objeto massivo devido à gravidade. É a energia potencial associada ao campo gravitacional, que é parcialmente convertida em energia cinética quando os objetos caem uns contra os outros. A energia potencial gravitacional aumenta quando dois objetos são separados.

A fórmula para obtenção da Energia Potencial Gravitacional de um corpo em relação à sua massa e distância do chão, ou seja, da superfície terrestre, é:

\[ E_\text{pg} = \text{m} \cdot \text{g} \cdot \text{h} \]

Onde:

Epg ? energia potencial gravitacional (em joule, J).

m ? massa do corpo (em kg).

g ? aceleração da gravidade (m/s2).

h ? altura do objeto em relação ao chão (em metros).

Como podemos ver, a Energia Potencial Gravitacional está diretamente relacionada à distância do corpo em relação à superfície terrestre. Dessa forma, quanto mais distante da terra o objeto estiver, maior a sua energia gravitacional. Isso nós diz também que, um objeto de altura zero possui Energia Potencial Gravitacional nula.

Vamos ver um exemplo agora? Observe o seguinte enunciado:

1) Uma pessoa levanta um tijolo com peso de 2 quilogramas à distância de 1,5 metros do chão. Qual é a Energia Potencial Gravitacional deste corpo?

Como o exercício nos dá a massa do objeto em kg e a distância dele em relação ao chão já está em metros, tudo que temos a fazer é jogar na fórmula. Veja o código Java completo para o cálculo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

public class Estudos {
  public static void main(String[] args) {
    // gravidade terrestre em m/s2
    double gravidade = 9.80665;
    // massa do corpo
    double massa = 2; // em kg
    // altura do corpo em relação ao chão
    double altura = 1.5; // em metros
  
    // vamos calcular a energia potencial gravitacional
    double epg = massa * gravidade * altura;
  
    // mostramos o resultado
    System.out.println("A Energia Potencial Gravitacional é: " 
      + epg + "J");
  }
}

Ao executar este código Java nós teremos o seguinte resultado:

A Energia Potencial Gravitacional é: 29.419950J

Link para compartilhar na Internet ou com seus amigos:

Angular ::: Artigos e Tutorias ::: CRUD - CREATE, READ, UPDATE, DELETE

Tutorial Angular para iniciantes: Como criar uma aplicação que grava novos alunos em uma base de dados MySQL usando PHP como back-end - Versão Angular CLI

Quantidade de visualizações: 5946 vezes
Neste pequeno tutorial mostrarei como é possível usar o framework Angular para desenvolver um front-end que permite cadastrar alunos no banco de dados MySQL usando a linguagem PHP como back-end. É claro que você poderá trocar o PHP por Node.js ou qualquer linguagem do lado do servidor. O importante aqui é entender o processo de desenvolvimento.

Então, se você ainda não o fez, verifique se o Angular CLI está devidamente instalado e funcionando na sua máquina. Isso pode ser feito abrindo-se uma nova janela de terminal e disparando o comando:

c:\estudos_web>ng --version

Sua máquina deverá retornar algo parecido com:

Angular CLI: 11.2.1
Node: 14.15.4
OS: win32 x64

Obteve resultado semelhante? Então podemos prosseguir. Comece disparando o comando abaixo para criar uma nova aplicação Angular usando o Angular CLI:

c:\docs_osmar>cd c:\estudos_angular
c:\estudos_angular>ng new escola

Veja que pedi para o comando ng do Angular CLI criar um novo projeto com o nome escola (você pode escolher o nome que desejar). Aguarde alguns minutos até que o processo seja finalizado.

Criando a entidade Aluno, ou a classe Aluno, ou melhor ainda, o model Aluno

Como nossa aplicação vai gravar alunos na base de dados, nada melhor do que começar criando nossa entidade ou model Aluno. Vá até a pasta "C:\estudos_angular\escola\src\app" e crie um arquivo chamado aluno.ts com o seguinte conteúdo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

export class Aluno{
  id: number = 0;
  matricula: number;
  nome: string;
  curso: string;
  
  constructor(matricula: number, nome: string,
    curso: string, id?: number) {
    this.matricula = matricula;
    this.nome = nome;
    this.curso = curso;
  }
}

Veja que nosso model Aluno possui os atributos matricula, nome, curso e id (que é opcional na classe, pois será gerado automaticamente pela tabela no banco de dados MySQL.

O passo seguinte é criar o serviço que nos permitirá a comunicação com o servidor remoto, a saber: a página PHP que gravará os dados na base MySQL.

Criando o serviço aluno.service para a comunicação com o servidor remoto

Para criar o serviço que nos permitirá gravar os alunos na base de dados MySQL, abra uma janela de terminal (ou use a que você já tem aberta) e dispare o seguinte comando:

c:\escola>ng generate service cadastros/aluno --flat
CREATE src/app/cadastros/aluno.service.spec.ts (352 bytes)
CREATE src/app/cadastros/aluno.service.ts (134 bytes)

Note que este comando deve ser disparado dentro da pasta da sua aplicação. Agora, temos um arquivo aluno.service.ts dentro da pasta cadastros no diretório C:\estudos_angular\escola\src\app (o seu deve ser diferente, não se esqueça).

Assim, abra o arquivo aluno.service.ts e vamos modificá-lo para o seguinte código:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

import {Injectable} from '@angular/core';

// precisamos do serviço HTTP para fazer a requisição AJAX
import {HttpClient, HttpErrorResponse, HttpParams} from '@angular/common/http';

// precisamos também do Observable, do map e catchError
import {Observable, throwError} from 'rxjs';
import {map, catchError} from 'rxjs/operators';

// precisamos também da classe Aluno
import {Aluno} from '../aluno';

@Injectable({
  providedIn: 'root'
})
export class AlunoService {
  // url base do endereço do serviço remoto
  baseUrl = 'http://localhost/servicos';
  // vetor de alunos já gravados
  alunos: Aluno[] = [];
  
  // vamos fazer uma injeção de dependência aqui
  constructor(private http: HttpClient){}

  // método que permite fazer uma requisição HTTP e gravar
  // o novo aluno
  cadastrar(aluno: Aluno): Observable<Aluno[]> {
    const dados = {
      nome: aluno.nome, matricula: aluno.matricula, 
      curso: aluno.curso,
    };

    return this.http.post(`${this.baseUrl}/gravar_aluno.php`, {dados: aluno})
      .pipe(map((res) => {
        // adiciona o novo aluno no vetor de alunos
        this.alunos.push(res['dados']);
        // e o retorna para o chamador deste método
        return this.alunos;
      }),
      
      catchError(this.tratarErro));
  }

  private tratarErro(error: HttpErrorResponse) {
    // vamos mostrar o erro no console
    console.log(error);

    // e vamos matar a aplicação aqui, pois não há mais nada
    // a fazer
    return throwError('Houve um erro: ' + error);
  }
}

Há algumas importações importantes neste serviço: Injectable do '@angular/core', HttpClient, HttpErrorResponse e HttpParams do '@angular/common/http', Observable e throwError do 'rxjs', map e catchError do 'rxjs/operators' e, mais importante, a classe Aluno de '../aluno'. Em outras dicas em nosso site você aprenderá melhor sobre cada um desses imports.

No construtor da classe AlunoService nós fazemos uma injeção de dependência (DI) para um objeto HttpClient, que será usado para fazer uma requisição POST. Esta requisição ocorre no método cadastrar(), que recebe um objeto da classe Aluno e o fornece como JSON na requisição POST. Assim que o novo aluno é cadastrado na base de dados MySQL, este método retorna o novo aluno (como JSON) e nós o adicionamos a um vetor de alunos, que será exibido na tela de cadastro para indicar os alunos já cadastrados.

Antes de prosseguirmos, que diacho é esse erro "implicitly has an 'any' type"?

Se você tentar executar a aplicação agora, de imediato já notará duas mensagens de erro (ou pelo menos uma delas):

Error: src/app/app.component.ts:24:18 - error TS7006: Parameter 'f' implicitly has an 'any' type.
24 cadastrarAluno(f) {

Error: src/app/cadastros/aluno.service.ts:36:26 - error TS7053: Element implicitly has an 'any' type because expression of type '"dados"' can't be used to index type 'Object'.
Property 'dados' does not exist on type 'Object'.
36 this.alunos.push(res['dados']);

Se elas aparecem na sua versão do Angular, basta adicionar a linha

"noImplicitAny": false

no arquivo tsconfig.json na raiz da aplicação e o problema será resolvido.

Já estamos bem adiantados. Hora de escrever o código do app.component.ts

O Angular CLI já criou um arquivo app.component.ts. Abra-o e altere o seu código para a versão abaixo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

import {Component} from '@angular/core';

// importamos a classe Aluno
import {Aluno} from './aluno';
// importamos o serviço AlunoService
import {AlunoService} from './cadastros/aluno.service';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  alunos: Aluno[] = [];
  // criamos uma nova instância da classe Aluno
  aluno = new Aluno(0, '', '', 0);
  erro = '';
  sucesso = '';

  // fazemos uma injeção de dependência aqui
  constructor(private alunoService: AlunoService) {}

  // aqui temos o método que permitirá cadastrar um novo aluno
  cadastrarAluno(f) {
    this.alunoService.cadastrar(this.aluno)
      .subscribe(
        (res: Aluno[]) => {
          // recebemos a lista atualizada de alunos
          this.alunos = res;

          // enviamos um ok para o formulário
          this.sucesso = 'Aluno cadastrado com sucesso.';

          // finalmente resetamos o formulário
          f.reset();
        },
        (err) => this.erro = err
      );
  }
}


Neste arquivo temos uns imports importantes: Component do '@angular/core', Aluno de './aluno' e AlunoService de './cadastros/aluno.service'. Em seguida, dentro da anotação @Component nós temos as definições para o selector, o templateUrl e o styleUrls. Finalmente, na classe AppComponent, nós temos as declaramos de um vetor de Aluno[], um objeto da classe Aluno e algumas variáveis auxiliares.

No construtor dessa classe nós fazemos uma injeção de dependência (DI) para um objeto da classe AlunoService. Então temos o método cadastrarAluno(), que recebe o formulário HTML e o repassa para o método cadastrar() do aluno.service. Como retorno desse método nós obtemos a lista atualizada dos alunos já cadastrados nessa sessão (atenção: não estamos obtendo os alunos cadastrados anteriomente na base de dados MySQL. Isso será visto em outra parte do tutorial).

Já temos o app.component.ts, vamos complementar o app.component.html

Com o app.component.ts devidamente ajustado, vamos nos concentrar agora no app.component.html, que contém o formulário que nos permitirá cadastrar os alunos. Veja o código completo para ele:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

<h3>Cadastrar Novo Aluno</h3>

<form #f="ngForm" name="cadastrarForm">
<table width="200" border="0" cellspacing="3" cellpadding="3">
    <tr>
      <td>Matrícula:</td>
      <td><input type="text" name="matricula" [(ngModel)]="aluno.matricula"></td>
    </tr>
    <tr>
      <td>Nome:</td>
      <td><input type="text" name="nome" [(ngModel)]="aluno.nome"></td>
    </tr>
    <tr>
      <td>Curso:</td>
      <td><input type="text" name="curso" [(ngModel)]="aluno.curso"></td>
    </tr>
    <tr>
      <td>&nbsp;</td>
      <td><button (click)="cadastrarAluno(f)">Gravar</button></td>
    </tr>
  </table>
</form>

<div *ngIf="erro" class="alert alert-danger">{{erro}}</div>
<div *ngIf="sucesso" class="alert alert-success">{{sucesso}}</div>

<ul *ngFor="let aluno of alunos; let i = index;">
    <li>{{i + 1}}; {{aluno.matricula}}; {{aluno.nome}}; {{aluno.curso}}</li>
</ul>

Veja que fiz um código HTML bem simples, sem firulas. Depois que você entender todos os elementos, então você poderá formatar e deixar mais bonito. O importante é observar como usamos ngModel para ligar os campos do formulário aos atributos da classe Aluno. Coloquei também dois ngIf para mostrar as mensagens de sucesso e de erro, e, finalmente, um ngFor para percorrer e exibir os alunos já cadastrados durante essa sessão.

Vamos lá? Já podemos executar o exemplo. A partir da pasta raiz da aplicação, dispare o comando abaixo:

c:\estudos_angular\escola>ng serve --open

Depois de alguns segundos teremos o seguinte resultado:



Obteve o mesmo resultado? Que maravilha! Mas não podemos cadastrar alunos ainda, pois a parte do back-end ainda não foi desenvolvida. Mas isso é coisa simples.

Criando a tabela no banco de dados MySQL

Nosso front-end já está completo e rodando. Chegou a hora de nos concentrarmos no back-end. Inicialmente vamos criar a tabela na base de dados MySQL. Veja sua estrutura e o código SQL DDL para a sua criação:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

CREATE TABLE `alunos` (
  `id` int(11) NOT NULL,
  `matricula` int(11) NOT NULL,
  `nome` varchar(100) NOT NULL,
  `curso` varchar(100) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Marque o campo id como chave primária e auto-incremento. Agora vamos ao código PHP, que mantive muito simples também, sem validações, o que deixo por sua conta.

A página PHP que recebe os alunos e os gravam na tabela MySQL

Segue abaixo o código completo para a página gravar_aluno.php, colocada no diretório "C:\xampp\htdocs\servicos" (fique atento ao endereço onde você vai colocá-la, seja na sua máquina local ou em um servidor remoto):

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

<?php
  // não deixe quebra de linha nos headers abaixo
  header('Access-Control-Allow-Origin: *');
  header('Access-Control-Allow-Methods: POST, GET, 
    PUT, DELETE, OPTIONS');
  header('Access-Control-Allow-Headers: Origin, 
    X-Requested-With, Content-Type, Accept');
  header("Content-Type: application/json; charset=utf-8");

  // vamos obter os dados vindo do formulário
  // atenção: em um código real temos que validar
  $dados = file_get_contents("php://input");
  
  // a requisição foi post?
  if(isset($dados) && !empty($dados)){
    $request = json_decode($dados);
    $nome = $request->dados->nome;
    $matricula = $request->dados->matricula;
    $curso = $request->dados->curso;

    // vamos efetuar a conexão com o banco
    $con = new mysqli("localhost", "root",
      "osmar1234", "estudos");
   
    // conexão efetuada com sucesso?
    if($con->connect_errno){
      echo "Não foi possível efetuar a conexão: " . 
        $mysqli->connect_error;
      exit(); // vamos sair daqui 
    }   
  
    // comando sql
    $query = "INSERT INTO alunos(id, matricula, nome, 
      curso) VALUES (null, '$matricula', '$nome', '$curso')";

    // vamos disparar o comando sql
    if(mysqli_query($con, $query)){
      http_response_code(201);
      $aluno = [
        'matricula' => $matricula,
        'nome' => $nome,
        'curso' => $curso,
        'id' => mysqli_insert_id($con)
      ];
  
      // vamos retornar o aluno recém cadastrado
      echo json_encode(['dados'=>$aluno]);
    }
    else{
      http_response_code(422);
    }
  }
?>

Se você observar atentamente o nosso exemplo, verá que a aplicação Angular está rodando em http://localhost:4200 enquanto a página PHP estará rodando em http://localhost/servicos/gravar_aluno.php, ou seja, mesmo servidor mas portas diferentes. Dessa forma, a requisição AJAX feita a partir da aplicação Angular vai falhar, com a seguinte mensagem de erro:

Access to XMLHttpRequest at 'http://localhost/servicos/gravar_aluno.php' from origin 'http://localhost:4200' has been blocked by CORS policy: Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Origin' header is present on the requested resource.

Por essa razão, a página PHP contém os headers que liberam o acesso cross-site (de servidor diferente):

// não deixe quebra de linha nos headers abaixo
header('Access-Control-Allow-Origin: *');
header('Access-Control-Allow-Methods: POST, GET, PUT, DELETE, OPTIONS');
header('Access-Control-Allow-Headers: Origin, X-Requested-With, Content-Type, Accept');
header("Content-Type: application/json; charset=utf-8");

Um outro detalhe interessante é o uso da função PHP file_get_contents("php://input") para receber o JSON enviado pela aplicação Angular. Programadores PHP vão achar isso uma "gambiarra", mas, atualmente, essa é a única forma de recebermos uma requisição POST usando JSON no PHP.

O restante do código é fácil de entender: criamos a conexão com o banco de dados, gravamos o aluno e retornamos um novo JSON contendo o novo aluno inserido. Note o uso de mysqli_insert_id() para obter o id do registro recém-inserido com o propósito de devolvermos o novo aluno com esse atributo já preenchido.

E agora o resultado final. Veja a imagem abaixo:



Conseguiu executar o exemplo também? Em outra dicas de Angular você encontra as demais partes do tutorial, a saber: listar, editar e excluir os alunos. Até lá e bons estudos.


Ruby ::: Dicas & Truques ::: Programação Orientada a Objetos

Como acessar variáveis de instâncias para escrita em Ruby sem a necessidade de métodos mutatórios usando a função attr_accessor

Quantidade de visualizações: 6927 vezes
Por padrão, variáveis de instância em Ruby só podem ser acessadas para escrita usando métodos mutatórios, ou seja, uma variável de instância @nome deve ser modificada usando um método definir_nome.

É possível dispensar o uso de métodos mutatórios empregando o método attr_accessor nos nomes das variáveis que poderão ser acessadas e modificadas. Lembre-se que, ao contrário de attr_reader, o método attr_accessor possibilita o acesso à variável de instância tanto para leitura quanto para escrita.

Veja um exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# Definição da classe Cliente
class Cliente
   attr_accessor :nome, :idade
   
   def initialize(nome, idade)
      @nome = nome
      @idade = idade
   end
end

# Cria uma instância da classe Cliente e inicializa as
# variáveis de instância @nome e @idade
cliente = Cliente.new("Osmar J. Silva", 35)

# Acessa as variáveis de instância sem a necessidade
# de métodos acessórios
puts cliente.nome
puts cliente.idade

# Modifica as variáveis de instância sem a necessidade
# de métodos mutatórios
cliente.nome = "Carlos da Silva"
cliente.idade = 56

# Obtém os resultados
puts cliente.nome
puts cliente.idade

Se tentarmos acessar e modificar as variáveis nome e idade diretamente, sem os métodos mutatórios e a função attr_accessor nós teremos um erro do tipo:

Traceback (most recent call last):
estudos.arb:15:in `<main>': undefined method `nome' for #<Cliente:0x0000029a7211f080 @nome="Osmar J. Silva", @idade=35> (NoMethodError)


Python ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas

Como testar se um ponto está dentro de um círculo em Python - Desenvolvimento de Games com Python

Quantidade de visualizações: 752 vezes
Quando estamos trabalhando com computação gráfica, geometria e trigonometria ou desenvolvimento de jogos em Python, é comum precisarmos verificar se um determinado ponto (uma coordenada x, y) está contido dentro de um círculo.

Para melhor entendimento, veja a imagem a seguir:



Veja que temos um círculo com raio igual a 115 e com centro nas coordenadas (x = 205; y = 166). Temos também dois pontos. O ponto vermelho está nas coordenadas (x = 140; y = 90) e o ponto azul está nas coordenadas (x = 330; y = 500.

Como podemos ver na imagem, o ponto vermelho está dentro do círculo, enquanto o ponto azul está fora. E nosso intenção nesta dica é escrever o código Python que permite fazer essa verificação. Tenha em mente que está técnica é muito útil para o teste de colisões no desenvolvimento de games.

Veja o código completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# vamos importar o módulo Math
import math

# vamos declarar a classe Circulo
class Circulo:
  # construtor da classe
  def __init__(self, xc, yc, raio):
    self.xc = xc
    self.yc = yc
    self.raio = raio
  
# agora vamos declarar a classe Ponto
class Ponto:
  def __init__(self, x, y):
    self.x = x # coordenada x
    self.y = y # coordenada y	

# método principal
def main():
  # vamos criar um objeto Circulo
  c = Circulo(205, 166, 115)
  # vamos criar um objeto Ponto
  p = Ponto(140, 90)
  
  # vamos verificar se o ponto está dentro do
  # círculo
  dx = p.x - c.xc;
  dy = p.y - c.yc;
  
  if((math.pow(dx, 2) + math.pow(dy, 2)) < math.pow(c.raio, 2)):
    print("O ponto está dentro do círculo")
  else:
    print("O ponto NÃO está dentro do círculo")

if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

O ponto está dentro do círculo.

Experimente com círculos de raios e coordenadas centrais diferentes e também com pontos em várias coordenadas e veja como os resultados são interessantes.


VB.NET ::: Dicas & Truques ::: Strings e Caracteres

Como comparar strings em VB.NET usando o método Equals() da classe String do .NET Framework

Quantidade de visualizações: 8677 vezes
Nesta dica mostrarei como podemos comparar palavras, frases ou textos em VB.NET usando o método Equals() da classe String do .NET Framework. Este método retorna um valor True se as duas strings forem iguais e False em caso contrário.

Lembre-se de que o método Equals() diferencia maiúsculas de minúsculas.

Veja um exemplo completo de seu uso:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

Imports System

Module Program
  Sub Main(args As String())
    Dim palavra1, palavra2 As String
    palavra1 = "Visual Basic"
    palavra2 = "Visual Basic"

    If palavra1.Equals(palavra2) Then
      Console.WriteLine("As duas strings são iguais")
    Else
      Console.WriteLine("As duas strings são diferentes")
    End If

    Console.WriteLine(vbCrLf & "Pressione qualquer tecla para sair...")
    ' pausa o programa
    Console.ReadKey()
  End Sub
End Module

Ao executar este código VB.NET nós teremos o seguinte resultado:

As duas strings são iguais


JavaFX ::: Pacote javafx.scene.layout (Package javafx.scene.layout) ::: HBox (Classe HBox)

Como definir o espaço interno do HBox do JavaFX usando o método setPadding()

Quantidade de visualizações: 712 vezes
Em algumas situações nós precisamos definir o espaço interno, ou seja, o padding, do gerenciador de layout HBox. Para isso nós podemos usar o método setPadding() e fornecer a ele um objeto da classe javafx.geometry.Insets. Este método é herdado da classe javafx.scene.layout.Region.

Lembre-se de que a função setPadding() define o espaço interno do VBox, ou seja, o espaço que deverá existir entre suas margens e os componentes contidos nele.

Veja um trecho de código JavaFX no qual temos um gerenciador de layout HBox e três botões:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudosjavafx;
 
import javafx.application.Application;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;
 
public class EstudosJavaFX extends Application {
  public static void main(String[] args){
    launch(args);
  }
 
  @Override
  public void start(Stage primaryStage){
    // vamos criar três botões
    Button btn1 = new Button("Botão 1");
    Button btn2 = new Button("Botão 2");
    Button btn3 = new Button("Botão 3");
     
    // agora criamos um laytou HBox e colocamos
    // os três botões nele
    HBox hBox = new HBox();
    hBox.getChildren().add(btn1);
    hBox.getChildren().add(btn2);
    hBox.getChildren().add(btn3);
     
    // vamos definir o espaço interno do HBox usando
    // um Inserts (top, direita, baixo, esquerda)
    hBox.setPadding(new Insets(20, 20, 20, 20));
    
    // criamos a cena e fornecemos o layout a ela
    // e definimos a largura e altura da cena
    Scene scene = new Scene(hBox, 400, 300);
     
    // adicionamos a cena ao palco principal
    primaryStage.setScene(scene);
    // e mostramos o palco
    primaryStage.show();
  }
}

Execute este código, experimente alterar os valores do objeto Insets fornecido ao método setPadding e veja os resultados obtidos.


Veja mais Dicas e truques de JavaFX

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2024 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 64 usuários muito felizes estudando em nosso site.