 |
|
||||
Você está aqui: Java ::: Dicas & Truques ::: Threads |
Threads em Java - O que são threads e como usá-las em seus programas JavaQuantidade de visualizações: 13540 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(); ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
// 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: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
// 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. |
 Link para compartilhar na Internet ou com seus amigos: |
Java ::: Dicas & Truques ::: Threads |
Java Threads - Como interromper a execução de uma thread em suas aplicações JavaQuantidade de visualizações: 15430 vezes |
|
A classe Thread fornece um método chamado interrupt() que serve para interrompermos a execução de uma determinada thread. Os métodos sleep() e yield() transferem a thread sendo executada no momento do estado "executando" para o estado "pronta". O método interrupt(), por sua vez, faz com que uma thread vá para o estado "finalizada", ou seja, ela não voltará mais a ser executada. O problema é que, nem sempre, o método interrupt() parece surtir o efeito desejado, ou seja, fazer com que a thread pare de executar imediatamente. Por esta razão, a forma mais fácil de "matar" uma thread é forçar a saída de seu método run(). Veja um exemplo: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
// 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);
if((i >= 3) && (nome.equals("Thread 1"))){
try{
System.out.println(nome + " foi eliminada");
return; // interrompe a execução do método run()
}
catch(SecurityException e){
System.out.println(e.getMessage());
}
}
}
}
}
public class Estudos{
public static void main(String[] args){
// vamos criar duas threads
MinhaThread t1 = new MinhaThread("Thread 1");
t1.start();
MinhaThread t2 = new MinhaThread("Thread 2");
t2.start();
}
}
Ao usar a instrução return nós forçamos a saída do método run() e consequentemente, o fim da tarefa sendo realizada pela thread. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Arrays e Matrix (Vetores e Matrizes) |
Exercícios Resolvidos de Java - Declarar e construir um vetor de inteiros e usar um laço for para inicializar seus elementos com os valores de 1 até 10 em JavaQuantidade de visualizações: 17359 vezes |
|
Pergunta/Tarefa: Escreva um programa Java que declara e constrói um array de 10 elementos do tipo int. Em seguida use um laço for para inicializar os elementos com os valores de 1 até 10. Para finalizar exiba os valores dos elementos do vetor na vertical. Seu programa deverá exibir a seguinte saída: 1 2 3 4 5 6 7 8 9 10 A resolução desta tarefa passa pela declaração e construção do array. Aqui eu demonstro como isso pode ser feito em dois passos. Primeiro a declaração e depois a construção: // vamos declarar um vetor de 10 ints int valores[]; // vamos construir o vetor...neste momento seus elementos // terão, todos, o valor 0 valores = new int[10]; Veja a resolução completa do exercício: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
public static void main(String[] args){
// vamos declarar um array de 10 ints
int valores[];
// vamos construir o array...neste momento seus elementos
// terão, todos, o valor 0
valores = new int[10];
// vamos usar o laço for para inicializar seus elementos
// com os valores de 1 até 10
for(int i = 0; i < valores.length; i++){
// aqui nós usamos o valor da variável i para acessar o
// elemento do array e também para atribuir o valor de i + 1
// ao elemento sendo acessado
valores[i] = (i + 1);
}
// só nos resta exibir os valores de todos os elementos
for(int i = 0; i < valores.length; i++){
System.out.println(valores[i]);
}
}
|
Java ::: Dicas & Truques ::: Threads |
Threads em Java - Como usar a interface Runnable da Java API em suas aplicaçõesQuantidade de visualizações: 17821 vezes |
|
A interface pública Runnable deve ser implementada em nossas classes quando queremos que instâncias destas possam ser executadas por uma thread. Esta interface está no pacote java.lang e entre as classes que a implementam podemos citar AsyncBoxView.ChildState, FutureTask, RenderableImageProducer, Thread e TimerTask. Esta interface apresenta apenas um método, a saber: public void run(); Este interface foi idealizada para fornecer um protocolo comum para objetos que têm como objetivo executar determinadas porções de código enquanto ativos. Por exemplo, Runnable é implementada pela classe Thread. Estar ativa significa que uma thread foi iniciada e ainda não finalizou sua tarefa. Além disso, a interface Runnable fornece meios para que uma classe esteja ativa sem fazer sub-classe de Thread. Uma classe que implementa Runnable pode ser executada sem fazer sub-classe de Thread criando-se uma instância de Thread e fornecendo tal classe como alvo. Na maioria dos casos, a interface Runnable deve ser usada se estivermos planejando apenas sobrescrever o método run() e nenhum outro método da classe Thread. Isso é importante, uma vez que não devemos extender classes a menos que tenhamos a intenção de modificar ou extender o comportamento fundamental da classe. Veja uma aplicação na qual temos uma classe que implementa Runnable. Note como criamos instâncias de Thread e fornecemos nossa classe como alvo: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
// 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);
}
}
|
Java ::: Dicas & Truques ::: Operadores de Manipulação de Bits (Bitwise Operators) |
Como usar o operador de bits & (E/AND sobre bits) em Java - Java Avançado - Manipulação de bits em JavaQuantidade de visualizações: 6683 vezes |
|
Esta dica de Java é muito útil para quem está se preparando para entrevistas de código ou desafios de programação. A manipulação de bits é fator importante para testar as habilidades de candidatos a vagas de programador, pois ela demonstra um conhecimento muito aprofundado de lógica de programação e também de rotinas de baixo nível. O operador de bits & (E/AND sobre bits) da linguagem Java é usado quando queremos comparar os bits individuais de dois valores integrais (inteiros) e produzir um terceiro resultado. Os bits no resultado serão configurados como 1 se os bits correspondentes nos dois outros valores foram 1. Em caso contrário os bits são configurados como 0. Vamos analisar os seguintes valores binários: a) 0101 (5 decimal) b) 0100 (4 decimal) Quando aplicamos o operador & nestes dois valores teremos o seguinte resultado: 0101 0100 ---- 0100 Veja que o resultado é 0100, uma vez que apenas o segundo bit de cada valor está configurado como 1. Vamos ver isso em Java agora. Observe o seguinte trecho de código: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
public class Main {
public static void main(String[] args) {
int a = 5;
int b = 4;
int c = a & b;
// exibe o resultado (em inteiro e em bytes)
System.out.println("a = " + obterBits(a) + " (" + a + ")");
System.out.println("b = " + obterBits(b) + " (" + b + ")");
System.out.println("a & b = " + obterBits(c) + " (" + c + ")");
}
// método auxiliar que converte um inteiro em sua representação em bits
public static String obterBits(int valor){
int mascara = 1 << 31;
StringBuffer buffer = new StringBuffer(35);
for(int i = 1; i <= 32; i++){
if((valor & mascara) == 0){
buffer.append('0');
}
else{
buffer.append('1');
}
valor <<= 1;
if(i % 8 == 0){
buffer.append(' ');
}
}
return buffer.toString();
}
}
Ao executar este código teremos o seguinte resultado: a = 00000000 00000000 00000000 00000101 (5) b = 00000000 00000000 00000000 00000100 (4) a & b = 00000000 00000000 00000000 00000100 (4) |
Java ::: Reflection (introspecção) e RTI (Runtime Type Information) ::: Passos Iniciais |
Saiba o que é Reflexão (Reflection) em Java - Como usar Reflexão (Reflection) na linguagem Java - RevisadoQuantidade de visualizações: 18348 vezes |
|
Reflection (ou Reflexão), também conhecida como RTI (Runtime Type Information) em algumas linguagens, é um mecanismo para descobrir dados a respeito de um programa em tempo de execução. Reflection em Java nos permite descobrir informações sobre atributos ou membros (campos), métodos e construtores de classes. Podemos também operar nos campos e métodos que descobrimos. A Reflection permite o que é normalmente chamada de programação dinâmica em Java. A Reflection em Java é conseguida usando a Java Reflection API. Esta API consiste de classes nos pacotes java.lang e java.lang.reflect. Antes de prosseguirmos, veja um exemplo de como podemos listar todos os métodos públicos da classe Object: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
package arquivodecodigos;
import java.lang.reflect.*;
public class Estudos{
public static void main(String args[]){
// vamos carregar a classe Object
try{
Class c = Class.forName("java.lang.Object");
// obtém os nomes dos métodos
Method[] metodos = c.getMethods();
// exibe o nome de cada método
for(int i = 0; i < metodos.length; i++){
System.out.println(metodos[i].getName());
}
}
catch(ClassNotFoundException e){
System.out.println(e.getMessage());
}
System.exit(0);
}
}
Ao executarmos este código nós teremos o seguinte resultado: wait wait wait equals toString hashCode getClass notify notifyAll Eis uma lista das coisas que podemos fazer com a Java Reflection API: 1) Determinar a classe de um objeto; 2) Obter informações sobre os modificadores, campos (atributos), métodos, construtores e superclasses de uma classe; 3) Descobrir quais constantes e declarações de métodos pertencem a uma interface; 4) Criar uma instância de uma classe cujo nome não sabemos até o tempo de execução; 5) Obter e definir o valor do campo de um objeto; 6) Invocar um método em um objeto; 7) Criar um novo array, cujo tamanho e tipo de dados só saberemos em tempo de execução. A Java Reflection API é geralmente usada para criar ferramentas de desenvolvimento tais como debuggers, class browsers e construtores de GUI. Geralmente, neste tipo de ferramentas, precisamos interagir como classes, objetos, métodos e campos, e não sabemos quais em tempo de compilação. Assim, a aplicação deve, dinamicamente, encontrar e acessar estes itens. Esta dica foi revisada e testada no Java 8. |
Java ::: Dicas & Truques ::: Arquivos e Diretórios |
Como criar diretórios em Java usando o método mkdir() da classe FileQuantidade de visualizações: 2 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: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
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. |
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Java Básico |
Exercícios Resolvidos de Java - Um programa Java que pede ao usuário que informe seu nome e exiba uma mensagem de boas-vindasQuantidade de visualizações: 15650 vezes |
|
Pergunta/Tarefa: Escreva um programa Java que pede ao usuário que informe seu nome e exiba uma mensagem de boas-vindas. Se o usuário informar "Osmar J. Silva" seu programa deverá exibir a mensagem: Seja bem-vindo(a), Osmar J. Silva Faça duas versões do exercício. Na primeira você deverá usar a classe Scanner para efetuar a leitura e System.out.println() para exibir a saída. Na segunda versão você deverá usar os métodos showInputDialog() e showMessageDialog() da classe JOptionPane (presente no pacote javax.swing). Resposta/Solução: Vamos primeiro à resolução do exercício usando a classe Scanner para efetuar a leitura e System.out.println() para exibir a saída: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
public static void main(String[] args){
// não se esqueça de adicionar um import para a classe Scanner
// import java.util.Scanner;
// vamos criar um objeto da classe Scanner
Scanner entrada = new Scanner(System.in);
// vamos solicitar ao usuário que informe seu nome
System.out.print("Informe seu nome: ");
// vamos ler o nome informado
String nome = entrada.nextLine();
// agora vamos exibir a mensagem de boas-vindas
System.out.println("Seja bem-vinda(a), " + nome);
}
Agora veja a resolução usando os métodos showInputDialog() e showMessageDialog() da classe JOptionPane: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
public static void main(String[] args){
// não se esqueça de adicionar um import para a classe JOptionPane
// import javax.swing.JOptionPane;
// vamos solicitar ao usuário que informe seu nome
String nome = JOptionPane.showInputDialog(null, "Informe seu nome");
// agora vamos exibir a mensagem de boas-vindas
JOptionPane.showMessageDialog(null, "Seja bem-vinda(a), " + nome);
}
|
Java ::: Dicas & Truques ::: Imagens e Processamento de Imagens |
Manipulação de imagens em Java - Como converter uma imagem JPG colorida para uma imagem na escala cinza (gray scale)Quantidade de visualizações: 12052 vezes |
Uma das formas mais comuns de se converter uma imagem colorida para uma imagem na escala cinza (grayscale) é desenhar a imagem colorida em um BufferedImage do tipo TYPE_BYTE_GRAY. Veja o resultado na imagem abaixo: E agora o código completo para o exemplo: ----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)
Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br
----------------------------------------------------------------------
package arquivodecodigos;
import java.awt.*;
import java.io.*;
import java.awt.image.*;
import java.awt.event.*;
import javax.swing.*;
import javax.imageio.*;
public class Estudos extends JFrame{
private BufferedImage imagem;
private BufferedImage imagemCinza;
AreaImagem areaImagem;
public Estudos(){
super("Estudos Java");
Container c = getContentPane();
c.setLayout(new BorderLayout());
JButton btn = new JButton("Carregar Imagem");
btn.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
JFileChooser fc = new JFileChooser();
int res = fc.showOpenDialog(null);
if(res == JFileChooser.APPROVE_OPTION){
File arquivo = fc.getSelectedFile();
imagem = null;
try{
imagem = ImageIO.read(arquivo);
}
catch(IOException exc){
JOptionPane.showMessageDialog(null,
"Erro ao carregar a imagem: " +
exc.getMessage());
}
if(imagem != null){
areaImagem.imagem = imagem;
areaImagem.repaint();
}
}
}
}
);
JButton btn2 =
new JButton("Converter Escala Cinza");
btn2.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
converterEscalaCinza();
}
}
);
JPanel painel = new JPanel();
painel.setLayout(new FlowLayout());
painel.add(btn);
painel.add(btn2);
c.add(painel, BorderLayout.SOUTH);
// Cria a área de exibição da imagem
areaImagem = new AreaImagem();
c.add(areaImagem, BorderLayout.CENTER);
setSize(400, 300);
setVisible(true);
}
public void converterEscalaCinza(){
imagemCinza = new BufferedImage(
imagem.getWidth(), imagem.getHeight(),
BufferedImage.TYPE_BYTE_GRAY);
Graphics g = imagemCinza.getGraphics();
g.drawImage(imagem, 0, 0, null);
g.dispose();
areaImagem.imagem = imagemCinza;
areaImagem.repaint();
}
public static void main(String args[]){
Estudos app = new Estudos();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
// Sub-classe de JPanel para exibir a imagem
class AreaImagem extends JPanel{
public BufferedImage imagem;
public void paintComponent(Graphics g){
super.paintComponent(g);
// desenha a imagem no JPanel
g.drawImage(imagem, 0, 0, this);
}
}
|
Vamos testar seus conhecimentos em |
| Dimensionamento de lajes e escadas maciças Considere uma laje retangular maciça, com condições de contorno definidas na imagem a seguir. A laje tem vãos de 4,00m x 3,00m e está sujeita a uma máxima reação de apoio correspondente ao lado do engaste de Vd = 9,97kN/m. A laje tem espessura de 8cm (com altura útil igual a 6cm), em concreto fck 20MPa. Considere que 50% da armadura inferior não chega até o apoio (k = 1), que a laje terá armadura mínima e que não há força normal atuando na laje.  Em relação à utilização de armaduras para combater o esforço cortante, é correto afirmar que:​ A) VRd1 = 20,87kN e a laje pode prescindir de armadura para força cortante. B) VRd1 = 20,9 N, sendo necessária a utilização de armadura para força cortante. C) VRd1 = 9,97kN e a laje pode prescindir de armadura para força cortante. D) VRd1 = 16,97kN, sendo necessária a utilização de armadura para força cortante. E) VRd1 = 12,35kN, sendo necessária a utilização de armadura para força cortante. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Ética e Legislação Profissional |
| O exercício do direito à propriedade O tema dos direitos de vizinhança tem uma série de regras no Código Civil, que delimita o que um vizinho pode realizar em relação aos limites do exercício regular de seus direitos, que terminam onde iniciam os direitos do outro. Quanto ao tema dos direitos de vizinhança, seus desdobramentos conceituais e regras existentes no Código Civil, analise as assertivas marcando a opção correta: A) Os direitos de vizinhança são obrigações ambulatórias, propter rem, pois acompanham a coisa, assim como o IPTU e as dívidas de condomínio. B) Pela teoria da anterioridade ou pré-ocupação, o vizinho que se estabeleceu depois não pode reclamar do barulho do que já estava ali antes. C) A função social da propriedade é um dos nortes da matéria dos direitos de vizinhança e é construção jurisprudencial, não estando prevista legislativamente. D) O dono das árvores que estiverem situadas em seu terreno tem direito sobre elas, seus frutos e sua poda, sendo seus os frutos que caem no terreno do vizinho, e seu direito às raízes das árvores que crescem em terreno do vizinho, pois são direitos que decorrem da sua propriedade. E) O dono ou possuidor do prédio inferior está obrigado a tolerar fluxo de águas artificialmente levadas (a exemplo de aquedutos ou captação de águas pluviais). Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Ética e Legislação Profissional |
| Ética, Legislação e Entidades que regulamentam a profissão Pensando no papel dos códigos de conduta ética desenvolvidos pelas empresas, qual afirmativa a seguir é incorreta? A) Podem ser apresentados através das políticas e objetivos da empresa, bem como pode ser repassado de modo informal através da cultura da empresa. B) Em geral, os códigos abordam temas relativos à qualidade dos serviços e produtos, assuntos sigilosos, tratamento de clientes e fornecedores, entre outros. C) O código de ética é a referência suprema para conduta dos funcionários, sendo, inclusive, mais relevante que as leis e códigos das entidades de classe em uma situação de impasse. D) Você deve sempre procurar seguir o código de conduta ética de sua empresa, o que lhe orientará na qualidade do trabalho e relacionamento com colegas, clientes e fornecedores. E) É correto, em uma entrevista de trabalho, abordar o código de ética da organização, solicitando-o e perguntando sobre alguma temática. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Fenômeno de Transportes e Hidráulica |
| Fórmula de Chézy Um canal reto e retangular tem 2,1m de largura e 1,2m de profundidade e está com uma declividade de fundo de 3°. Sendo o fator de atrito igual a 0,022, a vazão para escoamento uniforme será: A) 23,97m3/s. B) 25,78m3/s. C) 30,87m3/s. D) 37,00m3/s. E) 37,55m3/s. Verificar Resposta Estudar Cards Todas as Questões |
Vamos testar seus conhecimentos em Engenharia Civil - Construção Civil |
| Alvenaria: Técnicas construtivas Durante o levantamento de alvenaria, para atenuar as tensões que ficarão concentradas nos contornos dos vãos de portas e janelas devido à descontinuidade da parede, é necessária a execução de elementos estruturais específicos. O elemento localizado acima dos vãos é denominado de: A) Marco. B) Caixilho. C) Esquadria. D) Verga. E) Contramarco. Verificar Resposta Estudar Cards Todas as Questões |
Desafios, Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
|
Python - Como testar se um ponto está dentro de um círculo em Python - Desenvolvimento de Games com Python |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |
