![]() |
|
|
Planilha de Dimensionamento de Tubulações
Hidráulicas Água Fria e Água Quente CompletaNossa planilha automática de dimensionamento de tubulações de água fria e quente é uma ferramenta desenvolvida para auxiliar engenheiros e projetistas no cálculo rápido e preciso das redes hidráulicas de edificaçoes. Por meio da inserçao de dados como vazao, diâmetro da tubulaçao, comprimento da rede, material do tubo e coeficientes hidráulicos, a planilha realiza automaticamente os cálculos necessários para verificar velocidade da água, perda de carga e dimensionamento adequado das tubulaçoes. |
||
Você está aqui: Cards de Cards de Hidrologia |
||
|
||
|
|
||
Java ::: Fundamentos da Linguagem ::: Tipos de Dados |
Java para iniciantes - Como usar o tipo de dados short da linguagem JavaQuantidade de visualizações: 12597 vezes |
O tipo de dados short pode ser usado quando queremos armazenar valores inteiros na faixa -32,768 à 32,767. Veja um exemplo:
public class Estudos{
static short valor = 30000;
public static void main(String args[]){
System.out.println("O valor da variável é: "
+ valor);
System.exit(0);
}
}
Porém, é preciso estar atento a um detalhe muito importante (testado na versão 6 do SDK). Veja o trecho de código seguinte:
public class Estudos{
public static void main(String args[]){
short a = 32;
short b = 19;
short soma = a + b;
System.out.println("O resultado é: " + soma);
System.exit(0);
}
}
À primeira vista este código está correto, visto que a soma das variáveis a e b não ultrapassam a faixa do tipo short. Porém, ao tentarmos compilar, temos a seguinte mensagem de erro:
Estudos.java:5: possible loss of precision
found : int
required: short
short soma = a + b;
^
1 error
short a = 32; short b = 19; short soma = (short)(a + b); O tipo de dados short pode ser convertido (sem a necessidade de cast) para os seguintes tipos: short -> int -> long -> float -> double Se precisarmos converter o tipo short para os tipos char e byte, teremos que lançar mão de uma coerção (cast). Veja: short a = 32; short b = 19; byte soma = (byte)(a + b); |
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 CLIQuantidade de visualizações: 7127 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:
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:
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:
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:
<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> </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: 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):
<?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. |
C++ ::: Dicas & Truques ::: MIDI Musical Instrument Digital Interface, Mapeamento e sequenciamento MIDI, Entrada e saída MIDI |
Programação MIDI usando C++ - Como usar um vetor de chars para construir uma mensagem MIDI e passá-lo para a função midiOutShortMsg() da API do WindowsQuantidade de visualizações: 2869 vezes |
|
Nas dicas dessa seção nós vimos como é possível enviar uma mensagem MIDI para o dispositivo de saída por meio da função midiOutShortMsg() da API do Windows. Essa função recebe um handle para o dispositivo de saída MIDI e um valor DWORD contendo a mensagem MIDI. Se você revisitar essas dicas, verá que na maioria delas nós informamos a mensagem MIDI diretamente no parâmetro da função (como um valor hexadecimal). Nesta dica mostrarei como é possível construir as mensagens MIDI usando seus valores individuais e, o que é melhor, usando valores decimais. Para isso nós vamos construir um vetor de char e informar os valores que compõem a mensagem. É importante observar que a função midiOutShortMsg() exige que a mensagem MIDI seja informada na ordem de bytes "little endian" ou seja, o status MIDI é informado no byte de ordem mais baixa. Isso é conseguido com um cast do vetor para um unsigned long. Veja o trecho de código: // vamos criar um vetor contendo os valores que compõem a mensagem MIDI unsigned char vetor[4]; vetor[0] = 144; // Note-on no Canal 1 vetor[1] = 40; // Nota Mi na 4ª oitava vetor[2] = 100; // Velocidade/volume da nota vetor[3] = 0; // Não é usado // e aqui é que acontece a mágica. Quando fazemos o cast do // vetor para o tipo long sem sinal, os valores são colocados em // little endian, justamente a ordem de bytes esperada pela // função midiOutShortMsg() unsigned long mensagem = *(unsigned long*)vetor; // envia a mensagem MIDI midiOutShortMsg(saida, mensagem); Note que não coloquei o código todo. Para completá-lo, veja outras dicas dessa seção. |
Android Java ::: android.widget ::: Toast |
Como usar a classe Toast em suas aplicações AndroidQuantidade de visualizações: 10580 vezes |
|
Um objeto da classe pública Toast (do pacote android.widget) nos oferece uma forma de exibir uma pequena e rápida mensagem aos usuários de nossas aplicações Android. A mensagem exibida aparecerá como uma view flutuante sobre a tela atual da aplicação e não receberá foco. O objetivo é alertar o usuário sobre o sucesso ou fracasso de alguma atividade, aguardar alguns segundos e fazer a mensagem desaparecer. Veja a posição desta classe na hierarquia de classes do Android SDK: java.lang.Object android.widget.Toast Eis um exemplo de como usar um objeto desta classe para exibir uma breve mensagem quando o usuário clicar um botão na view:
package arquivo.estudos;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;
public class EstudosActivity extends Activity
{
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Button button = (Button) findViewById(R.id.btn);
button.setOnClickListener(new View.OnClickListener(){
public void onClick(View v) {
Toast.makeText(EstudosActivity.this,
"Bem-vindo à minha aplicação Android",
Toast.LENGTH_SHORT).show();
}
});
}
}
O botão usado neste exemplo foi criado em um layout XML com a seguinte declaração:
<Button
android:id="@+id/btn"
android:layout_height="wrap_content"
android:layout_width="wrap_content"
android:text="Clique" />
Veja que aqui nós usamos o método estático makeText() da classe Toast para exibir a mensagem ao usuário. A constante Toast.LENGTH_SHORT faz com que a mensagem seja exibida por um curto período de tempo. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Recursão (Recursividade) |
Exercícios Resolvidos de Java - Uma função recursiva que conta quantas vezes um valor inteiro k ocorre em um vetor de inteirosQuantidade de visualizações: 2427 vezes |
|
Pergunta/Tarefa: Escreva um método recursivo que conta quantas vezes um valor inteiro k ocorre em um vetor de 10 inteiros. Seu método deverá ter a seguinte assinatura:
public static int quantRepeticoes(int indice, int valor, int[] vetor){
// sua implementação aqui
}
Informe o 1 valor: 2 Informe o 2 valor: 7 Informe o 3 valor: 4 Informe o 4 valor: 7 Informe o 5 valor: 1 Informe o valor a ser pesquisado no vetor: 7 O valor informado se repete 2 vezes. Veja a resolução comentada deste exercício usando Java console:
package exercicio;
import java.util.Scanner;
public class Exercicio {
public static void main(String[] args) {
// cria um novo objeto da classe Scanner
Scanner entrada = new Scanner(System.in);
// vamos declarar um vetor de 10 inteiros
int valores[] = new int[5];
// vamos pedir ao usuário que informe os valores do vetor
for(int i = 0; i < valores.length; i++){
System.out.print("Informe o " + (i + 1) + " valor: ");
// efetua a leitura do valor informado para a posição atual do vetor
valores[i] = Integer.parseInt(entrada.nextLine());
}
// agora vamos pedir para informar o valor a ser pesquisado
System.out.print("\nInforme o valor a ser pesquisado no vetor: ");
int valor = Integer.parseInt(entrada.nextLine());
// e vamos ver a quantidade de repetições
int repeticoes = quantRepeticoes(0, valor, valores);
System.out.print("O valor informado se repete " + repeticoes + " vezes.");
System.out.println("\n");
}
// método recursivo que recebe um valor
public static int quantRepeticoes(int indice, int valor, int[] vetor){
if(indice == vetor.length - 1){ // caso base...hora de parar a recursividade
if(vetor[indice] == valor){
return 1; // mais um repetição foi encontrada
}
}
else{ // dispara mais uma chamada recursiva
if(vetor[indice] == valor){ // houve mais uma repetição
return 1 + quantRepeticoes(indice + 1, valor, vetor);
}
else{
return 0 + quantRepeticoes(indice + 1, valor, vetor); // não repetiu
}
}
return 0; // só para deixar o compilador satisfeito...esta linha nunca é executada
}
}
|
Mais Desafios de Programação e Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |






