 |
|
||||
Você está aqui: JavaScript ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas |
Como testar se um ponto está dentro de um círculo em JavaScript - Desenvolvimento de Games com JavaScriptQuantidade de visualizações: 1279 vezes |
|
Quando estamos trabalhando com computação gráfica, geometria e trigonometria ou desenvolvimento de jogos em JavaScript, é 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 JavaScript 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)
----------------------------------------------------------------------
<!doctype html>
<html>
<head>
<title>Desenvolvimento de Games usando HTML5 e JavaScript</title>
</head>
<body>
<script type="text/javascript">
// vamos declarar a classe Circulo
class Circulo{
constructor(xc, yc, raio){
this.xc = xc; // x do centro
this.yc = yc; // y do centro
this.raio = raio; // raio do círculo
}
}
// agora vamos declarar a classe Ponto
class Ponto{
constructor(x, y){
this.x = x; // coordenada x
this.y = y; // coordenada y
}
}
// vamos criar um objeto Circulo
var c = new Circulo(90, 50, 115);
// vamos criar um objeto Ponto
var p = new Ponto(140, 90);
// vamos verificar se o ponto está dentro do
// círculo
var dx = p.x - c.xc;
var dy = p.y - c.yc;
if((Math.pow(dx, 2) + Math.pow(dy, 2)) < Math.pow(c.raio, 2)){
document.writeln("O ponto está dentro do círculo");
}
else{
document.writeln("O ponto NÃO está dentro do círculo");
}
</script>
</body>
</html>
Ao executar este código 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. |
 Link para compartilhar na Internet ou com seus amigos: |
Java ::: Fundamentos da Linguagem ::: Variáveis e Constantes |
Java para iniciantes - Como usar os diferentes tipos de variáveis em JavaQuantidade de visualizações: 17180 vezes |
|
Na linguagem de programação Java podemos encontrar diferentes tipos de variáveis. Veja a lista e uma descrição detalhada de cada um destes tipos: Variáveis de instância (Instance Variables) - Estas variáveis são não-estáticas, ou seja, declaradas sem o modificador static. Variáveis de instância são assim chamadas porque seus valores são únicos para cada instância da classe. Assim, a variável nomeCliente pode armazenar valores diferentes para cada cópia da classe Cliente. Variáveis de classes - Estas variáveis são declaradas com o modificador static. Isso informa ao compilador que há exatamente uma única cópia desta variável, independente do número de instâncias da classe. Um bom exemplo de tal variável é quantCliente, que pode ser incrementada cada vez que uma nova cópia da classe é criada. Variáveis locais - São usadas para armazenar o estado temporário de um método. Variáveis locais são acessíveis somente dentro do método em que são declaradas, e automaticamente abandonadas na saída deste. Parâmetros - São os parâmetros de métodos. Tais variáveis são acessíveis somente ao código no corpo do método. Geralmente quando falamos de "campos em geral" (excluindo variáveis locais e parâmetros), podemos simplesmente dizer "campos". Se a discussão se aplica a todas as variáveis acima, usamos "variáveis". Se o contexto pede uma distinção, usamos termos específicos (campo estático, variável local, etc) como apropriado. Podemos ainda usar o termo "membro". Os campos, métodos e tipos aninhados de um tipo podem ser chamados de seus membros. |
Java ::: Projetos Java Completos - Códigos Fonte Completos Java ::: Projetos Java Programação Orientada a Objetos - Exemplos Java |
Sistema para Biblioteca usando Programação Orientada a Objetos em Java - Projeto completo com código fonte - Versão consoleQuantidade de visualizações: 13414 vezes |
|
Sistema para Gestão de Biblioteca usando Programação Orientada a Objetos em Java - Projeto completo com código fonte - Versão console Controle de Biblioteca - Sobre este projeto Java  Nesta dica apresento a idéia de um Controle de Gestão de Biblioteca em Java usando Programação Orientada a Objetos. Trata-se de um programa com código fonte em duas versões console. Na primeira versão temos os dados sendo gerenciados por objetos ArrayList. Na segunda versão nós tiramos proveito dos métodos dos métodos readObject() e writeObject() e da interface Serializable para implementar a serialização de objetos em Java. Dessa forma, os dados do sistema podem ser salvos e carregados todas as vezes que o sistema for iniciado. Um Controle de Gestão de Biblioteca é um projeto ideal para dominar a programação orientada a objetos em Java, além de permitir colocar em prática várias coisas que estudamos na linguagem e não temos a oportunidade de implementar. Assim, este código, se bem estudado e bem entendido, pode render um controle de biblioteca pronto para ser vendido no mercado ou implementado em sua própria escola ou faculdade. Basta conectar as funcionalidades das classes a um banco de dados tal como o MySQL e adicionar mais alguns pequenos detalhes. O Diagrama de Classes Java Antes de falarmos mais sobre o projeto do Sistema de Biblioteca, dê uma boa olhada no seu diagrama de classes:  Como a aplicação está estruturada? Como podemos ver no diagrama de classes, todo o controle do sistema é feito a partir da classe Biblioteca, que contém objetos da classe ArrayList para guardar objetos das classes Usuario, Autor, Editora, Livro, Emprestimo e Multa. O relacionamento entre os objetos das classes envolvidas está bem definido no código fonte, com comentários e menus individuais para o gerenciamento de cada parte que compõe o controle de biblioteca apresentado. Um empréstimo envolve um livro e um usuário, e pode gerar uma multa caso a devolução seja feita fora do prazo. A multa é gerada somente na devolução. Em sistemas reais, o usuário não pode fazer uma nova locação caso a multa não seja paga. Deixamos como sugestão e desafio, essa implementação no código. No entanto, já fizemos todo o restante do cálculo para você, ou seja, fizemos a diferença entre a data do empréstimo e sua devolução e geramos a multa, se houver, já com o devido valor a ser pago. Um livro está relacionado a um autor e a uma editora. Inicialmente o livro é cadastrado como disponível. Porém, esse status é alterado para indisponível quando ele está envolvido em um empréstimo, e novamente disponível quando é feita a devolução. Tudo isso é feito por meio de vários menus de opções, como mostro a seguir. As opções de menu para o gerencimento do sistema da biblioteca O menu principal foi escrito usando-se o seguinte código:
// método que exibe o menu principal do sistema
public void menuPrincipal(){
Scanner entrada = new Scanner(System.in);
while(true){
limparTela();
System.out.println("\n:: B I B L I O T E C A ::\n");
System.out.println("Bem-vindo(a) ao sistem.
Escolha a opção desejada");
System.out.println("1 - Livros");
System.out.println("2 - Autores");
System.out.println("3 - Editoras");
System.out.println("4 - Usuários");
System.out.println("5 - Empréstimos");
System.out.println("6 - Multas");
System.out.println("7 - Sair");
System.out.print("Sua opção: ");
// lê a opção do usuário
int opcao = Integer.parseInt(entrada.nextLine());
switch(opcao){
case 1:
// chama o menu de gerenciamento de livros
menuGerenciarLivros();
break;
case 2:
// chama o menu de gerenciamento de autores
menuGerenciarAutores();
break;
case 3:
// chama o menu de gerenciamento de editoras
menuGerenciarEditoras();
break;
case 4:
// chama o menu de gerenciamento de usuários
menuGerenciarUsuarios();
break;
case 5:
// chama o menu de gerenciamento de emprestimos
menuGerenciarEmprestimos();
break;
case 6:
// chama o menu de gerenciamento de multas
menuGerenciarMultas();
break;
case 7:
System.out.println("\nObrigado por usar o
Sistema de Biblioteca\n");
System.exit(0);
}
}
}
Note que cada case do switch do menu principal chama um método que será responsável por exibir um menu individual para o gerencimento da classe correspondente. Veja, por exemplo, o menu para cadastrar um novo usuário na biblioteca:
// menu para cadatrar, listar, pesquisar, excluir
// e atualizar os usuários da biblioteca
public int menuGerenciarUsuarios(){
Usuario temp; // serve para várias operações neste menu
// serve para as pesquisas dos usuários
String pesquisaUsuario;
Scanner entrada = new Scanner(System.in);
// mostra o menu de forma repetitiva até o usuário
// usar a opção de sair
while(true){
// tire caso não funcionar no seu sistema operacional
limparTela();
System.out.println("\n:: G E R E N C I A R U S U Á R I O S ::\n");
System.out.println("Escolha a opção desejada");
System.out.println("1 - Novo Usuário");
System.out.println("2 - Listar Usuários");
System.out.println("3 - Pesquisar Usuário");
System.out.println("4 - Excluir Usuário");
System.out.println("5 - Atualizar Usuário");
System.out.println("6 - Voltar Menu Anterior");
System.out.print("Sua opção: ");
// lê a opção do usuário
int opcao = Integer.parseInt(entrada.nextLine());
switch(opcao){
case 1: // vamos cadastrar um novo usuário
System.out.print("\nNome: ");
String nomeUsuario = entrada.nextLine();
System.out.print("Idade: ");
int idadeUsuario = Integer.parseInt(entrada.nextLine());
System.out.print("Sexo: ");
char sexoUsuario = entrada.nextLine().charAt(0);
// vamos incrementar o contador de usuários
Usuario.contadorUsuarios++;
// agora vamos criar um novo objeto da classe Usuario
Usuario u = new Usuario(Usuario.contadorUsuarios,
nomeUsuario, idadeUsuario, sexoUsuario);
// e o adicionamos no ArrayList de usuários
usuarios.add(u);
// e finalmente mostramos uma mensagem de sucesso.
System.out.println("\nO usuário foi cadastrado com sucesso");
salvarDadosArquivo(); // salva os dados no arquivo
break;
...
Devo usar ArrayList do Java para desenvolver o sistema? Sim, objetos da classe ArrayList são perfeitos quando precisamos representar relacionamentos um para muitos e muitos para um. É claro que poderíamos usar vetores de objetos (usando array), mas ficaríamos restritos a tamanhos fixos, enquanto o ArrayList nos permite cadastrar quantos usuários, livros, editoras, autores e empréstimos nós quisermos. Dessa forma, veja, por exemplo, o trecho de código que registra um novo empréstimo:
case 1: // vamos cadastrar um novo empréstimmo
// para registrar um novo empréstimo nós precisamos
// de um usuário
// o usuário que será relacionado a este empréstimo
Usuario usuario = null;
while(usuario == null){
System.out.print("\nInforme o id ou nome do usuário: ");
String pesquisaUsuario = entrada.nextLine();
// chamamos o método que pesquisa o usuario
usuario = pesquisarUsuario(pesquisaUsuario);
if(usuario == null){ // usuario não encotrado
System.out.print("\nUsuário não
encontrado.\n\nDigite 1 para pesquisar
novamente ou 2 para voltar ao menu anterior: ");
int opcaoTemp = Integer.parseInt(entrada.nextLine());
if(opcaoTemp == 2){
return 1; // saímos daqui e voltamos para o menu anterior
}
}
}
System.out.println("Usuário selecionado: " + usuario.getNome());
// fim para registrar um novo empréstimo nós
// precisamos de um usuário
// para registrar um novo empréstimo nós precisamos
// de um livro
Livro livro = null; // o livro que será relacionado
// a este empréstimo
while(livro == null){
System.out.print("Informe o id, título ou ISBN do livro: ");
String pesquisaLivro = entrada.nextLine();
// chamamos o método que pesquisa o livro
livro = pesquisarLivro(pesquisaLivro);
// livro não encontrado ou indisponível
if((livro == null) || (!livro.isDisponivel())){
System.out.print("\nLivro não encontrado
ou indisponível.\n\nDigite 1 para
pesquisar novamente ou 2 para voltar ao
menu anterior: ");
int opcaoTemp = Integer.parseInt(entrada.nextLine());
if(opcaoTemp == 2){
return 1; // saímos daqui e voltamos para o menu anterior
}
}
}
System.out.println("Livro selecionado: " + livro.getTitulo());
// fim para cadastrar um novo empréstimo nós
// precisamos de um livro
try{
System.out.print("Data do Empréstimo: ");
String dataEmprestimo = entrada.nextLine();
Date dataEmprestimoDate =
new SimpleDateFormat("dd/MM/yyyy").parse(dataEmprestimo);
System.out.print("Data de Devolução: ");
String dataDevolucao = entrada.nextLine();
Date dataDevolucaoDate =
new SimpleDateFormat("dd/MM/yyyy").parse(dataDevolucao);
// a data de devolução é menor que a data de empréstimo?
if(dataDevolucaoDate.getTime() <= dataEmprestimoDate.getTime()){
System.out.println("\nA data de devolução
deve ser maior que a data de empréstimo.\n");
}
else{
// vamos incrementar o contador de empréstimos
Emprestimo.contadorEmprestimos++;
// vamos marcar o livro escolhido como indisponível
livro.setDisponivel(false);
// agora vamos criar um novo objeto da classe Emprestimo
Emprestimo emprestimo = new Emprestimo(usuario,
livro, Emprestimo.contadorEmprestimos,
dataEmprestimoDate, dataDevolucaoDate,
null, false);
// e o adicionamos no ArrayList de empréstimos
emprestimos.add(emprestimo);
// e finalmente mostramos uma mensagem de sucesso.
System.out.println("\nO empréstimo foi registrado com sucesso");
salvarDadosArquivo(); // salva os dados no arquivo
}
}
catch(ParseException e){
System.out.println("\nAs datas informadas são inválidas.\n");
}
break;
Note que este trecho de código é parte do case da opção Novo Empréstimo do menu Gerenciar Empréstimos. Veja como usamos uma variável estática contadorEmprestimos da classe Emprestimo para criarmos um valor inteiro auto-incremento que nos permite identificadores únicos para cada empréstimo da biblioteca. Viu que código mais lindo? Note como a Programação Orientada a Objetos em Java nos permite desenvolver idéias de forma bem parecida mesmo ao mundo real. Como posso obter este código fonte? O código fonte desta aplicação é fornecido em duas versões: 1) SBIBLIOJCNB-A - Sistema de Gestão de Biblioteca em Java com Código Fonte Versão Console - NetBeans IDE ou Eclipse. 2) SBIBLIOJCNB-B - Sistema de Gestão de Biblioteca em Java com Código Fonte Versão Console - Lê e salva os dados em arquivo usando serialização (Serializable), ou seja, os métodos readObject() e writeObject() - NetBeans IDE ou Eclpse. Para adquirir, entre em contato conosco usando o WhatsApp ou e-mail indicados na lateral do site. Podemos combinar alterações e a adição de novas funcionalidades. Não se esqueça: Uma boa forma de estudar o código é fazendo pequenas alterações e rodando para ver os resultados. Outra opção é começar um projeto Java do zero e ir adicionando trechos do código fonte para melhor entendimento de suas partes. |
C# ::: Dicas & Truques ::: Strings e Caracteres |
Como remover espaços em excesso de uma string C# usando expressões regularesQuantidade de visualizações: 14272 vezes |
|
Nesta dica mostrarei como podemos usar expressões regulares em C# para remover os espaços em excesso de uma frase ou texto. Esta técnica é bem útil quando estamos trabalhando com dados informados pelos usuários de nossas aplicações. Temos sempre que verificar, não somente o excesso de espaços no meio do texto, quanto espaços no início e no fim das strings informadas. 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)
----------------------------------------------------------------------
using System;
using System.Text.RegularExpressions;
namespace Estudos {
class Program {
static void Main(string[] args) {
// vamos construir o Regex com o padrão que queremos
Regex regex = new Regex("\\s +", RegexOptions.IgnoreCase |
RegexOptions.Compiled);
// frase com espaços
string frase = " Gosto muito de C# ";
// frase sem espaços
string resultado = (regex.Replace(frase, " ")).Trim();
// mostramos o resultado
Console.WriteLine("Frase com espaços em excesso: {0}", frase);
Console.WriteLine("Espaços em excesso removidos: {0}", resultado);
Console.WriteLine("\n\nPressione uma tecla para sair...");
Console.ReadKey();
}
}
}
Ao executar este código C# nós teremos o seguinte resultado: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
Frase com espaços em excesso:
Gosto muito de C#
Espaços em excesso removidos:
Gosto muito de C#
|
Python ::: NumPy Python Library (Biblioteca Python NumPy) ::: Números Aleatórios, Números Randômicos, Amostras Aleatórias, Amostras Randômicas |
Como gerar números aleatórios em Python usando o método random.randint() da biblioteca NumPyQuantidade de visualizações: 2405 vezes |
|
Nesta dica mostrarei como podemos gerar números inteiros randômicos usando random.randint() da biblioteca NumPy. Note que a geração de números aleatórias é uma parte importante para o desenvolvimento de modelos de teste (test models) em Inteligência Artificial (IA), Machine Learning e outras áreas de estudo que envolvem Data Science. Veja um exemplo da forma mais simples do uso da função random.randint(): ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
# importamos o módulo random da bibliteca NumPy
from numpy import random
def main():
# vamos gerar um número inteiro aleatório de 0 (incluído) à
# 10 (não incluído)
valor = random.randint(10)
print("O número sorteado foi: ", valor)
if __name__== "__main__":
main()
Ao executar este código teremos um resultado parecido com: O número sorteado foi: 3 Aqui nós informamos o limite alto do valor aleatório a ser gerado (mas ele não é incluído). Se quisermos limitar a faixa inferior, podemos tirar proveito dos parâmetros low e high da função randint(). Veja: ----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------
# importamos o módulo random da bibliteca NumPy
from numpy import random
def main():
# vamos gerar um número inteiro aleatório de 5 (incluído)
# à 10 (não incluído)
valor = random.randint(5, 10)
print("O número sorteado foi: ", valor)
if __name__== "__main__":
main()
A partir da versão 1.19 da NumPy, os desenvolvedores da biblioteca recomendam o uso do método integers() do módulo default_rng(). |
Java ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes) |
Como passar vetores e matrizes (arrays) para seus métodos JavaQuantidade de visualizações: 15974 vezes |
|
Nesta dica mostrarei como você pode passar um array (vetor ou matriz) para seus métodos Java. Observe que um array é um objeto Java, e objetos são sempre passados por referência. Assim, as alterações feitas no vetor ou matriz dentro do método afetarão o array original. 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)
----------------------------------------------------------------------
package arquivodecodigos;
public class Estudos{
public static void main(String[] args){
int[] valores = {43, 6, 17, 23, 8};
// Exibe os valores antes de passar o
// array para o método multiplicar
for(int i = 0; i < valores.length; i++){
System.out.print(valores[i] + ", ");
}
System.out.println();
// fornece o array para o método multiplicar
multiplicar(valores, 2);
// Exibe os valores depois de passar o
// array para o método multiplicar
for(int i = 0; i < valores.length; i++){
System.out.print(valores[i] + ", ");
}
System.exit(0);
}
public static void multiplicar(int a[], int num){
for(int i = 0; i < a.length; i++){
a[i] = a[i] * num;
}
}
}
Ao executar este código nós teremos o seguinte resultado: 43, 6, 17, 23, 8, 86, 12, 34, 46, 16, |
Desafios, Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
Códigos Fonte |
 Software de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimentoDiga 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 funcionalidadesTenha 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 |
