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;
  }
}

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);
  }
}

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
      );
  }
}

<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>

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;

<?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);
    }
  }
?>

Linha 1 e coluna 1: 8
Linha 1 e coluna 2: 1
Linha 1 e coluna 3: 5
Linha 2 e coluna 1: 3
Linha 2 e coluna 2: 9
Linha 2 e coluna 3: 30
Linha 3 e coluna 1: 7
Linha 3 e coluna 2: 23
Linha 3 e coluna 3: 10

Valores na matriz

    8     1     5 
    3     9    30 
    7    23    10 

Os valores pares são: 8 30 10

// Um algoritmo que lê uma matriz 3x3
programa {
  funcao inicio() {
    // variáveis usadas na resolução do problema
    inteiro matriz[3][3]
    inteiro i, j

    // vamos pedir para o usuário informar os valores
    // dos elementos da matriz, uma linha de cada vez
    para (inteiro i = 0; i < 3; i++) { 
      para (inteiro j = 0; j < 3; j++) {
        escreva("Linha ", (i + 1), " e coluna ", (j + 1), ": ")
        leia(matriz[i][j])
      }
    }

    // vamos mostrar a matriz da forma que ela foi informada
    escreva("\nValores na matriz:\n\n")
    para (inteiro i = 0; i < 3; i++) {
      para (inteiro j = 0; j < 3; j++) {
        escreva(matriz[i][j], "   ")
      }
      // passa para a próxima linha da matriz
      escreva("\n")
    }

    // agora vamos percorrer a matriz novamente e mostrar
    // apenas os valores pares
    escreva("\nOs valores pares são: ")

    para (inteiro i = 0; i < 3; i++) {
      para (inteiro j = 0; j < 3; j++) {
        // é um número par?
        se (matriz[i][j] % 2 == 0) {
          escreva(matriz[i][j], "  ")
        }
      }
    }
  }
}

c = 36.056 # medida da hipotenusa
b = 30 # medida do cateto adjascente
  
# agora vamos calcular o comprimento da cateto oposto
a = sqrt(power(c, 2) - power(b, 2))
 
# e mostramos o resultado
fprintf("A medida do cateto oposto é: %f\n", a);

package estudos;

import java.util.*;

public class Estudos{
  public static void main(String[] args){
    // vamos declarar e construir um vetor de 5 inteiros
    int[] valores = new int[5];
 
    // inicializa os elementos do array
    valores[0] = 23;
    valores[1] = 65;
    valores[2] = 2;
    valores[3] = 87;
    valores[4] = 34;

    // exibe os valores dos elementos do array
    // usando o laço for melhorado
    System.out.println("Elementos na ordem original:");
    for(int valor : valores){
      System.out.print(valor + " ");  
    }
    
    // ordena os valores em ordem crescente
    Arrays.sort(valores);

    // exibe os valores dos elementos do array
    // usando o laço for melhorado
    System.out.println("\n\nElementos classificados em ordem crescente:");
    for(int valor : valores){
      System.out.print(valor + " ");  
    }
  
    System.out.println("\n\n");
    System.exit(0);
  }
}