 |
|
||||
Você está aqui: Cards de Engenharia Civil - Estruturas de Concreto Armado |
||
|
||
 Link para compartilhar na Internet ou com seus amigos: |
||
Java ::: Dicas & Truques ::: Programação Orientada a Objetos |
Como usar o modificador abstract em suas classes e métodos Java - Programação Orientada a Objetos em Java - Java POOQuantidade de visualizações: 18535 vezes |
O modificador abstract pode ser aplicado a classes e métodos. Seu uso com variáveis pode causar o erro abaixo:
abstract String nome;
Estudos.java:2: modifier abstract not
allowed here
abstract String nome;
^
1 error
Classes abstratas não podem ser instanciadas, ou seja, não podemos chamar seu construtor. Veja um exemplo:
public class Estudos{
public static void main(String args[]){
Cliente cliente = new Cliente();
System.exit(0);
}
}
abstract class Cliente{
public Cliente(){
}
}
Ao tentarmos compilar esta classe teremos o seguinte erro:
Estudos.java:3: Cliente is abstract; cannot be
instantiated
Cliente cliente = new Cliente();
^
1 error
A função principal de classes abstratas é forçar a implementação para as sub-classes. Desta forma, seus métodos são declarados com o modificador abstract e sem corpo. Veja:
abstract class Cliente{
abstract void obterNome();
}
Sempre que suas classes contiverem um ou mais métodos abstratos, você deverá declará-la abstrata. Não seguir esta regra provocará o seguinte erro:
class Cliente{
abstract void obterNome();
}
Estudos.java:9: Cliente is not abstract and does
not override abstract method obterNome() in Cliente
class Cliente{
^
1 error
As situações que fazem com que uma classe deva ser declarada abstract são:
Para finalizar, abstract é o oposto de final. Uma classe final não pode ter sub-classes. Uma classe abstract precisa ter sub-classes. |
JavaScript ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas |
Como calcular o coeficiente angular de uma reta em JavaScript dados dois pontos no plano cartesianoQuantidade de visualizações: 2005 vezes |
|
O Coeficiente Angular de uma reta é a variação, na vertical, ou seja, no eixo y, pela variação horizontal, no eixo x. Sim, isso mesmo. O coeficiente angular de uma reta tem tudo a ver com a derivada, que nada mais é que a taxa de variação de y em relação a x. Vamos começar analisando o seguinte gráfico, no qual temos dois pontos distintos no plano cartesiano:  Veja que o segmento de reta AB passa pelos pontos A (x=3, y=6) e B (x=9, y=10). Dessa forma, a fórmula para obtenção do coeficiente angular m dessa reta é: \[\ \text{m} = \frac{y_2 - y_1}{x_2 - x_1} = \frac{\Delta y}{\Delta x} = tg \theta \] Note que __$\Delta y__$ e __$\Delta x__$ são as variações dos valores no eixo das abscissas e no eixo das ordenadas. No triângulo retângulo que desenhei acima, a variação __$\Delta y__$ se refere ao comprimento do cateto oposto e a variação __$\Delta y__$ se refere ao comprimento do cateto adjascente. Veja agora o trecho de código na linguagem JavaScript que solicita as coordenadas x e y dos dois pontos, efetua o cálculo e mostra o coeficiente angular m da reta que passa pelos dois pontos:
<html>
<head>
<title>Estudos JavaScript</title>
</head>
<body>
<script type="text/javascript">
// x e y do primeiro ponto
var x1 = 3;
var y1 = 6;
// x e y do segundo ponto
var x2 = 9;
var y2 = 10;
var m = (y2 - y1) / (x2 - x1);
// mostramos o resultado
document.writeln("O coeficiente angular é: " + m);
</script>
</body>
</html>
Ao executar este código JavaScript nós teremos o seguinte resultado: O coeficiente angular é: 0.6666666666666666 Veja agora como podemos calcular o coeficiente angular da reta que passa pelos dois pontos usando o Teorema de Pitágoras. Note que agora nós estamos tirando proveito da tangente do ângulo Theta (__$\theta__$), também chamado de ângulo Alfa ou Alpha (__$\alpha__$):
<html>
<head>
<title>Estudos JavaScript</title>
</head>
<body>
<script type="text/javascript">
// x e y do primeiro ponto
var x1 = 3;
var y1 = 6;
// x e y do segundo ponto
var x2 = 9;
var y2 = 10;
// vamos obter o comprimento do cateto oposto
var cateto_oposto = y2 - y1;
// e agora o cateto adjascente
var cateto_adjascente = x2 - x1;
// vamos obter o ângulo tetha, ou seja, a inclinação da hipetunesa
// (em radianos, não se esqueça)
var tetha = Math.atan2(cateto_oposto, cateto_adjascente);
// e finalmente usamos a tangente desse ângulo para calcular
// o coeficiente angular
var tangente = Math.tan(tetha);
// mostramos o resultado
document.writeln("O coeficiente angular é: " + tangente);
</script>
</body>
</html>
Ao executar este código você verá que o resultado é o mesmo. No entanto, fique atento às propriedades do coeficiente angular da reta: 1) O coeficiente angular é positivo quando a reta for crescente, ou seja, m > 0; 2) O coeficiente angular é negativo quando a reta for decrescente, ou seja, m < 0; 3) Se a reta estiver na horizontal, ou seja, paralela ao eixo x, seu coeficiente angular é zero (0). 4) Se a reta estiver na vertical, ou seja, paralela ao eixo y, o coeficiente angular não existe. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Recursão (Recursividade) |
Exercícios Resolvidos de Java - Como calcular a potência de um número usando recursividade em Java - Funções recursivas em JavaQuantidade de visualizações: 5032 vezes |
|
Pergunta/Tarefa: A potenciação ou exponenciação é a operação de elevar um número ou expressão a uma dada potência. Escreva um método Java recursivo que recebe uma base e um expoente e eleva a base ao expoente. Seu método deverá possuir a seguinte assinatura:
public static int potencia(int base, int expoente){
// sua implementação aqui
}
Sua saída deverá ser parecida com: Informe a base: 5 Informe o expoente: 3 A base 5 elevada ao exponente 3 é 125 Veja a resolução comentada deste exercício usando Java console:
package estudos;
import java.util.Scanner;
public class Estudos {
public static void main(String[] args) {
// cria um novo objeto da classe Scanner
Scanner entrada = new Scanner(System.in);
// solicita a base
System.out.print("Informe a base: ");
// lê a base
int base = Integer.parseInt(entrada.nextLine());
// solicita o expoente
System.out.print("Informe o expoente: ");
// lê o expoente
int expoente = Integer.parseInt(entrada.nextLine());
// mostra o resultado
System.out.print("A base " + base + " elevada ao exponente " +
expoente + " é " + potencia(base, expoente));
System.out.println("\n");
}
// método recursivo que eleva uma base a um determinado expoente
public static int potencia(int base, int expoente){
// a recursivida deve parar quando o expoente for igual a 1
if(expoente == 1){
return base;
}
else{
// efetua uma nova chamada recursiva fornecendo o expoente - 1
return base * potencia(base, expoente - 1);
}
}
}
|
C ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes) |
Como testar se uma matriz é uma matriz identidade usando CQuantidade de visualizações: 2092 vezes |
|
Seja M uma matriz quadrada de ordem n. A matriz M é chamada de Matriz Identidade de ordem n (indicada por In) quando os elementos da diagonal principal são todos iguais a 1 e os elementos restantes são iguais a zero. Para melhor entendimento, veja a imagem de uma matriz identidade de ordem 3, ou seja, três linhas e três colunas:  Veja um código C completo no qual nós declaramos uma matriz quadrada de ordem 3, pedimos para o usuário informar os valores de seus elementos e no final informamos se a matriz é uma matriz identidade ou não:
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
int main(int argc, char *argv[]){
setlocale(LC_ALL,""); // para acentos do português
int n = 3; // ordem da matriz quadrada
int matriz[n][n]; // matriz quadrada
int i, j, linha, coluna;
int identidade = 1;
// vamos pedir para o usuário informar os elementos da matriz
for (i = 0; i < n; i++){
for (j = 0; j < n; j++) {
printf("Elemento na linha %d e coluna %d: ", (i + 1), (j + 1));
scanf("%d", &matriz[i][j]);
}
}
// agora verificamos se a matriz é uma matriz identidade
for(linha = 0; linha < n; linha++){
for(coluna = 0; coluna < n; coluna++){
if(matriz[linha][coluna] != 1 && matriz[coluna][linha] != 0){
identidade = 0;
break;
}
}
}
// agora mostramos a matriz lida
printf("\n");
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
printf("%d ", matriz[i][j]);
}
printf("\n");
}
if (identidade){
printf("\nA matriz informada é uma matriz identidade.");
}
else{
printf("\nA matriz informada não é uma matriz identidade.");
}
printf("\n\n");
system("PAUSE");
return 0;
}
Ao executar este código C nós teremos o seguinte resultado: Elemento na linha 1 e coluna 1: 1 Elemento na linha 1 e coluna 2: 0 Elemento na linha 1 e coluna 3: 0 Elemento na linha 2 e coluna 1: 0 Elemento na linha 2 e coluna 2: 1 Elemento na linha 2 e coluna 3: 0 Elemento na linha 3 e coluna 1: 0 Elemento na linha 3 e coluna 2: 0 Elemento na linha 3 e coluna 3: 1 1 0 0 0 1 0 0 0 1 A matriz informada é uma matriz identidade. |
Java ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes) |
Como ordenar um vetor de inteiros em ordem decrescente em JavaQuantidade de visualizações: 1066 vezes |
|
Nesta dica mostrarei como é possível ordenar um array (vetor) de ints em ordem decrescente usando o método sort() da classe Arrays e um método inverter() personalizado. É claro que há várias outras formas de se conseguir realizar esta tarefa. Espero que esta seja mais uma técnica adicionada ao seu arsenal. Veja o código Java completo:
package arquivodecodigos;
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;
// ordena os valores
Arrays.sort(valores);
System.out.println("Ordenado em ordem crescente:");
for(int valor : valores){
System.out.print(valor + " ");
}
// vamos inverter o vetor agora
inverter(valores);
// exibe os valores dos elementos do array
// usando o laço for melhorado
System.out.println("\nOrdenado em ordem decrescente:");
for(int valor : valores){
System.out.print(valor + " ");
}
System.out.println("\n");
System.exit(0);
}
// método que recebe um array e inverte a ordem
// de seus elementos
public static void inverter(int[] b){
int esquerdo = 0;
int direito = b.length-1;
while (esquerdo < direito) {
int temp = b[esquerdo];
b[esquerdo] = b[direito];
b[direito] = temp;
esquerdo++;
direito--;
}
}
}
Ao executar este código Java nós teremos o seguinte resultado: Ordenado em ordem crescente: 2 23 34 65 87 Ordenado em ordem decrescente: 87 65 34 23 2 |
Desafios, 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 |
