![]() |
|
|
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 |
||
|
||
|
|
||
MySQL ::: Dicas & Truques ::: Chaves, Índices e Restrições de Integridade Referencial |
Como adicionar uma chave primária a uma tabela MySQL usando o comando ALTER TABLE ADD PRIMARY KEYQuantidade de visualizações: 8647 vezes |
|
Em algumas situações poderá ocorrer a necessidade, talvez por motivos de manutenção na base de dados, de criar uma chave primária para uma tabela MySQL já existente. Isso pode ser feito com o auxílio do comando DDL ALTER TABLE ADD PRIMARY KEY. Comece criando uma tabela livros sem chave primária. Veja o comando CREATE TABLE: CREATE TABLE livros( id int(11) unsigned NOT NULL, titulo varchar(45) NOT NULL, paginas int(10) unsigned NOT NULL )ENGINE=InnoDB; Se dispararmos um comando DESCRIBE livros veremos a seguinte estrutura: Field Type Null Key Default Extra id int(11) unsigned NO - - - titulo varchar(45) NO - - - paginas int(10) unsigned NO - - - ALTER TABLE livros ADD PRIMARY KEY(id); Dispare o comando DESCRIBE livros novamente e veja o resultado. Agora o campo id está marcado como chave primária: Field Type Null Key Default Extra id int(11) unsigned NO PRI - - titulo varchar(45) NO - - - paginas int(10) unsigned NO - - - |
Python ::: Fundamentos da Linguagem ::: Métodos, Procedimentos e Funções |
Como usar os argumentos padrões das funções e métodos em PythonQuantidade de visualizações: 8289 vezes |
Geralmente quando efetuamos chamadas às funções, nosso código fica responsável por fornecer os valores para os argumentos da função. Em Python é possível termos argumentos padrões, e tais argumentos já podem ter um valor pré-definido. Desta forma, a passagem dos parâmetros se torna opcional. Veja um exemplo:
# função com argumento padrão
def erro(msg = "Houve um erro."):
print(msg)
def main():
# chamada à função fornecendo o argumento
erro("Erro desconhecido.")
# chamada à função sem fornecer o argumento
erro()
if __name__== "__main__":
main()
Ao executarmos este exemplo nós teremos o seguinte resultado: Erro desconhecido. Houve um erro. Veja mais um exemplo: # função com argumentos padrões def volume(comprimento = 1, largura = 1, altura = 1): return (comprimento * largura * altura) def main(): # chamada à função fornecendo um argumento print(volume(3)) # chamada à função fornecendo dois argumentos print(volume(4, 5)) # chamada à função fornecendo três argumentos print(volume(4, 5, 7)) # chamada à função fornecendo nenhum argumento print(volume()) if __name__== "__main__": main() Ao executarmos este exemplo nós teremos o seguinte resultado: 3 20 140 1 É importante observar que os argumentos padrões devem estar sempre à direita dos demais argumentos. Falhar em cumprir esta exigência pode causar um erro do tipo: SyntaxError: non-default argument follows default argument |
Java ::: Coleções (Collections) ::: ArrayList |
Java Collections para iniciantes - Arrays (vetores) ou a ArrayList? Qual devo usar?Quantidade de visualizações: 16847 vezes |
|
Uma das perguntas mais frequentes que os usuários do nosso site nos fazem é aquela sobre o uso de simples arrays (vetores e matrizes) ou objetos da classe ArrayList. Se o número de elementos for fixo ou você precisar de muita eficiência ao lidar com tipos primitivos, então arrays podem ser a melhor escolha. Porém, muitos problemas envolvendo o armazenamento de dados requerem estruturas de dados que possam ser redimensionadas de acordo com a necessidade do algorítmo. Neste caso, uma ArrayList (ou qualquer uma das outras classes Collections) pode ser a escolha certa. Veja um trecho de código para ficar mais fácil o entendimento:
package arquivodecodigos;
public class Estudos{
public static void main(String args[]){
int valores[] = {4, 12, 8, 5, 13};
System.out.println("Primeiro elemento no vetor: "
+ valores[0]);
}
}
Ao executar este código nós teremos o seguinte resultado: Primeiro elemento no vetor: 4 Como podemos ver neste exemplo, um array (nesse caso um vetor) possui um tamanho fixo, ou seja, o compilador não nos permite reduzir ou aumentar a quantidade de elementos em um vetor ou matriz criado a partir da notação de arrays. Assim, apesar de todas as facilidades que os arrays trazem consigo, este pode ser um empecilho para o tipo de aplicação que queremos desenvolver em um determinado momento. A classe ArrayList, por outro lado, possui tamanho variado. Isso quer dizer que seu tamanho é aumentado ou reduzido de acordo com as necessidades do seu código. Uma outra questão que diferencia arrays de ArrayList, é que não podemos armazenar tipos primitivos em um objeto da classe ArrayList. Se precisarmos fazer isso, o tipo primitivo deve ser colocado em uma classe encapsuladora, por exemplo, a classe Integer. Em algumas situações o compilador faz isso nos bastidores, e esta operação é chamada de auto-boxing. |
Java ::: Dicas & Truques ::: Threads |
Threads em Java - O que são threads e como usá-las em seus programas JavaQuantidade de visualizações: 14125 vezes |
|
Uma thread é um fluxo de execução de uma determinada tarefa em um programa. Na programação tradicional, temos apenas um fluxo de execução que começa a executar no início do programa e vai até o final. Com o uso de threads podemos ter várias tarefas sendo executadas ao mesmo tempo, cada uma independente da outra. Em programas que contêm interfaces gráficas, o uso de múltiplos fluxos de execução (ou threads) é muito comum. Enquanto digitamos em uma caixa de texto, uma animação pode estar sendo executada ou um arquivo sendo baixado. O Java permite que tenhamos várias threads sendo executadas ao mesmo tempo. Cada tarefa (ou thread) é uma instância da interface Runnable. Esta interface descreve apenas um método: public void run();
// criamos uma classe que servirá como thread
class MinhaThread extends Thread{
private String nome;
public MinhaThread(String nome){
this.nome = nome;
}
public void run(){
for(int i = 1; i <= 20; i++){
System.out.println(nome + ": " + i);
}
}
}
public class Estudos{
public static void main(String[] args){
// vamos criar duas threads
MinhaThread t1 = new MinhaThread("Thread 1");
t1.start(); // chamamos o método start() e não run()
MinhaThread t2 = new MinhaThread("Thread 2");
t2.start(); // chamamos o método start() e não run()
System.exit(0);
}
}
Salve este código como Estudos.java, compile e execute. Veja que cada thread escreverá de 1 a 20 na tela. Observe como as duas threads se alternam em suas tarefas, ou seja, de tempos em tempos uma cede lugar para que a outra seja executada. Note também que, embora nossa classe tenha um método run() nós não o chamamos. O que fazemos é chamar o método start(), que torna a thread elegível para ser executada a qualquer momento. Uma outra forma de criarmos uma thread é fazer com que nossa classe implemente a interface Runnable. Veja:
// criamos uma classe que servirá como thread
class MinhaThread implements Runnable{
private String nome;
public MinhaThread(String nome){
this.nome = nome;
}
public void run(){
for(int i = 1; i <= 20; i++){
System.out.println(nome + ": " + i);
}
}
}
public class Estudos{
public static void main(String[] args){
// vamos criar duas threads
MinhaThread mt1 = new MinhaThread("Thread 1");
Thread t1 = new Thread(mt1);
t1.start();
MinhaThread mt2 = new MinhaThread("Thread 2");
Thread t2 = new Thread(mt2);
t2.start();
System.exit(0);
}
}
O funcionamento do código é o mesmo. A diferença é que agora, a classe usada como thread implementa a interface Runnable. A forma de criação da thread também foi alterada. Agora nós criamos instâncias de Thread fornecendo nossa classe thread como argumento e chamamos o método start da classe Thread e não de nossa própria classe, como fizemos anteriormente. |
Java ::: Dicas & Truques ::: Arquivos e Diretórios |
Como criar diretórios em Java usando o método mkdir() da classe FileQuantidade de visualizações: 3 vezes |
|
Em algumas ocasiões nossos programas precisam criar diretórios. Na linguagem Java isso pode ser feito com o auxílio do método mkdir() da classe File, do pacote java.io. Este método não recebe nenhum parâmetro e atua em cima de uma instância da classe File. Além disso, ele retorna um boolean indicando o sucesso ou não da operação. Veja o código completo para um exemplo:
package arquivodecodigos;
// precisamos importar o pacote java.io
import java.io.*;
public class Estudos{
public static void main(String[] args){
// nome e caminho do diretório que será criado
File diretorio = new File("c:\\estudos_java\\imagens");
// o diretório foi criado com sucesso?
if(diretorio.mkdir()){
System.out.println("Diretório criado com sucesso");
}
else{
System.out.println("Nao foi possível criar o diretório");
}
}
}
Se o diretório puder ser criado, você verá uma mensagem: Diretório criado com sucesso Observe que este método pode disparar uma exceção do tipo SecurityException se você não tiver permissão para criar diretórios nos locais especificados. |
Desafios, Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
|
VB.NET - Como usar o laço While em VB.NET |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |



