 |
|
|
 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 Engenharia Civil - Estruturas de Concreto Armado |
||
|
||
 Link para compartilhar na Internet ou com seus amigos: |
||
Java ::: Tratamento de Erros ::: Erros de Tempo de Execução |
Tratamento de erros em Java - Como tratar o erro NoClassDefFoundError em seus programas JavaQuantidade de visualizações: 12999 vezes |
|
A exceção (erro) NoClassDefFoundError acontece quando a Java Virtual Machine (JVM) ou uma instância de ClassLoader tenta carregar a definição de uma classe (como parte de uma chamada de método normal ou como parte da criação de uma nova instância usando a expressão new) e nenhuma definição de tal classe puder ser encontrada. Antes de vermos uns exemplos, veja a posição da classe pública NoClassDefFoundError na hierarquia de classes da plataforma Java:
java.lang.Object
java.lang.Throwable
java.lang.Error
java.lang.LinkageError
java.lang.NoClassDefFoundError
Veja que NoClassDefFoundError herda de Error e portanto, é uma das exceções lançadas como parte do funcionamento da JVM. Isso quer dizer que não podemos usar blocos try...catch para evitá-lo. A exceção é quando estamos tentando carregar uma instância de classe usando o ClassLoader. Para provocar o erro NoClassDefFoundError só precisamos efetuar algumas das ações abaixo: 1) Fornecer um nome de classe que não existe (ou com diferenças entre minúsculas e maiúsculas do nome pretendido). Assim: java MinhaClasse Se a classe não existir no diretório atual ou em um arquivo jar, a mensagem de erro abaixo será exibido: C:\java>java MinhaClasse Exception in thread "main" java.lang.NoClassDefFoundError: MinhaClasse 2) Fornecer um nome de classe seguida por .class: java MinhaClasse.class |
C++ ::: Fundamentos da Linguagem ::: Estruturas de Controle |
C++ para iniciantes - Como usar o laço for em C++Quantidade de visualizações: 23608 vezes |
O laço for é usado quando queremos executar um bloco de códigos um determinado número de vezes. Este laço é composto de três partes:
for(início; condição; incremento/decremento){
bloco de instruções
}
A parte início é executada uma única vez (na entrada do laço). Geralmente é nesta parte que declaramos e inicializamos a variável de controle. Na parte condição nós testamos a condição atual da variável de controle, para verificar se o laço pode continuar sua execução. Na parte do incremento/decremento nós alteramos o valor da variável de controle. Finalmente o bloco de instruções representa as instruções que serão executadas no laço. Veja um exemplo de laço for no qual exibimos os números de 0 a 10:
#include <string>
#include <iostream>
using namespace std;
int main(int argc, char *argv[]){
// um laço for que conta de 0 a 10
for(int i = 0; i <= 10; i++){
cout << i << "\n";
}
cout << "\n\n";
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
Veja agora um laço for usado para exibir os números de 10 a 0:
#include <string>
#include <iostream>
using namespace std;
int main(int argc, char *argv[]){
// um laço for que conta de 10 a 0
for(int i = 10; i >= 0; i--){
cout << i << "\n";
}
cout << "\n\n";
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
É importante observar que mais de uma expressão podem ser executadas nas partes início e incremento/decremento de um laço for. Veja um exemplo:
#include <string>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
// um laço for que conta de 10 a 0
for(int i = 0, x = 4; i <= 10; i++, x += 2){
cout << (i * x) << "\n";
}
cout << "\n\n";
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
|
Ruby ::: Dicas & Truques ::: Strings e Caracteres |
Como trabalhar com strings em RubyQuantidade de visualizações: 8803 vezes |
|
Strings em Ruby são usadas para representar palavras, frases e textos e são bem parecidas com strings em outras linguagens dinâmicas, tais como Perl, Python e PHP. Além disso, strings em Ruby são dinâmicas, mutáveis e flexíveis. Podemos declarar e definir uma variável do tipo string em Ruby da seguinte forma: nome = "Osmar J. Silva" puts nome Em ruby, strings são objetos da classe String. Isso quer dizer que podemos efetuar chamadas à uma grande variedade de métodos desta classe a partir de qualquer variável do tipo string. Veja um exemplo: nome = "Osmar" puts nome.length Este exemplo exibirá a quantidade de caracteres contidos na string nome. Strings em Ruby podem estar contidas em aspas duplas ou aspas simples: nome = "Osmar J Silva" puts(nome) nome = 'Osmar J Silva' puts(nome) A diferença é que, quando usamos aspas duplas, podemos codificar dados binários dentro da string, assim como usar "\n" para provocar quebras de linha. Quando usamos aspas simples, podemos usar apenas "\'" para exibir uma aspa simples e "\\" para exibir uma barra invertida. |
R ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas |
Como calcular o coeficiente angular de uma reta em R dados dois pontos no plano cartesianoQuantidade de visualizações: 2188 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 R 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:
# x e y do primeiro ponto
x1 <- readline("Coordenada x do primeiro ponto: ")
y1 <- readline("Coordenada y do primeiro ponto: ")
x1 <- as.numeric(x1)
y1 <- as.numeric(y1)
# x e y do segundo ponto
x2 <- readline("Coordenada x do segundo ponto: ")
y2 <- readline("Coordenada y do segundo ponto: ")
x2 <- as.numeric(x2)
y2 <- as.numeric(y2)
# agora vamos calcular o coeficiente angular
m <- (y2 - y1) / (x2 - x1)
# mostramos o resultado
paste("O coeficiente angular é:", m)
Ao executar este código em linguagem R nós teremos o seguinte resultado: [1] "O coeficiente angular é: 0.666666666666667" 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__$):
# x e y do primeiro ponto
x1 <- readline("Coordenada x do primeiro ponto: ")
y1 <- readline("Coordenada y do primeiro ponto: ")
x1 <- as.numeric(x1)
y1 <- as.numeric(y1)
# x e y do segundo ponto
x2 <- readline("Coordenada x do segundo ponto: ")
y2 <- readline("Coordenada y do segundo ponto: ")
x2 <- as.numeric(x2)
y2 <- as.numeric(y2)
# vamos obter o comprimento do cateto oposto
cateto_oposto <- y2 - y1
# e agora o cateto adjascente
cateto_adjascente <- x2 - x1
# vamos obter o ângulo tetha, ou seja, a inclinação da hipetunesa
# (em radianos, não se esqueça)
tetha <- atan2(cateto_oposto, cateto_adjascente)
# e finalmente usamos a tangente desse ângulo para calcular
# o coeficiente angular
tangente <- tan(tetha)
# mostramos o resultado
paste("O coeficiente angular é:", tangente)
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 ::: Reflection (introspecção) e RTI (Runtime Type Information) ::: Passos Iniciais |
Java Reflection - Como obter um objeto Class usando os métodos getClass() e forName() da classe Class da linguagem JavaQuantidade de visualizações: 11245 vezes |
|
Uma das tarefas mais básicas que devemos fazer quando estamos usando reflexão em Java, é obter um objeto Class. Uma vez que tenhamos uma instância de Class, podemos obter várias informações sobre uma classe, até mesmo manipulá-la. Nesta dica veremos como usar o método getClass() para obter um objeto Class. Esta forma de obter um objeto Class é frequentemente útil em situações nas quais temos uma instância de uma classe, mas não sabemos a qual classe esta instância pertence (instanceOf). Há várias formas de se obter um objeto Class. Se você tiver uma classe para a qual o nome de tipo é conhecido em tempo de compilação, há uma forma ainda mais fácil de se obter uma intância da classe. Só precisamos usar a palavra chave do compilador .class. Veja: Class classe = JButton.class; Se o nome da classe não foi conhecido em tempo de compilação, mas estiver disponível em tempo de execução (runtime), podemos usar o método forName() para obter um objeto Class. O código a seguir mostra como criar um objeto Class associado à classe javax.swing.JPanel:
try{
Class classe = Class.forName("javax.swing.JPanel");
}
catch(ClassNotFoundException e){
// trate os erros aqui
}
Podemos usar também o método getSuperClass() em um objeto Class para obter o objeto Class representando a superclasse da classe que está sofrendo introspecção. O trecho de código a seguir mostra como o objeto classe1 reflete a classe JTextField, e classe2 reflete a classe JTextComponent, uma vez que esta classe é a superclasse de JTextField: JTextField txtNome = new JTextField(); Class classe1 = txtNome.getClass(); Class classe2 = classe1.getSuperclass(); Esta dica foi revisada e atualizada para o Java 8. |
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 |
