Escolar Documentos
Profissional Documentos
Cultura Documentos
07 Desenvolvimentode Aplicaes
07 Desenvolvimentode Aplicaes
SUMÁRIO
DESENVOLVIMENTO DE APLICAÇÕES....................................................................4
INTRODUÇÃO..............................................................................................................4
TEMA 01....................................................................................................................... 5
INTRODUÇÃO E HISTÓRIA DO JAVA.........................................................................5
TEMA 02..................................................................................................................... 26
INTRODUÇÃO À LÓGICA DE PROGRAMAÇÃO...................................................... 26
TEMA 03..................................................................................................................... 41
CLASSES JAVA: STRINGS........................................................................................ 41
TEMA 04..................................................................................................................... 48
ESTRUTURAS DE CONTROLE - CONDICIONAIS................................................... 48
TEMA 05..................................................................................................................... 55
ESTRUTURAS DE CONTROLE – REPETIÇÃO........................................................ 55
TEMA 06..................................................................................................................... 62
VETORES E MATRIZES EM JAVA............................................................................. 62
TEMA 07..................................................................................................................... 68
POO – CONCEITOS INICIAIS.................................................................................... 68
TEMA 08..................................................................................................................... 79
CONSTRUTORES...................................................................................................... 79
TEMA 09..................................................................................................................... 85
ENCAPSULAMENTO E OS MÉTODOS MODIFICADORES E ACESSORES...........85
TEMA 10..................................................................................................................... 93
MODIFICADORES DE ACESSO EM JAVA................................................................ 93
3
DESENVOLVIMENTO DE APLICAÇÕES
INTRODUÇÃO
TEMA 01
INTRODUÇÃO E HISTÓRIA DO JAVA
Habilidades
Introdução
Java surgiu em um projeto chamado "Oak" por James Gosling em junho de 1991. O objetivo
de Gosling era implementar uma máquina virtual e uma linguagem que tivesse uma notação
semelhante ao C, mas com maior uniformidade e simplicidade do que C/C++. A primeira
implementação pública foi Java 1.0 em 1995. Ele fez uma promessa: "Escreva uma vez, execute em
qualquer lugar", com tempos de execução gratuitos em plataformas populares. Era bastante seguro e
configurável, permitindo que o acesso à rede e aos arquivos fosse limitado. Os principais navegadores
da web logo o incorporaram em suas configurações padrão em uma configuração de "mini aplicativo"
segura.
5
Disponível em: <https://wallpapersafari.com/w/lvH8Qg>. Acesso em 11 set. 2023.
Popularização
Novas versões surgiram para grandes e pequenas plataformas (J2EE e J2ME) logo foram
projetadas com o advento do "Java 2". A Sun não anunciou nenhum plano
para um "Java 3".Em 1997, a Sun abordou os padrões ISO/ IEC JTC1 e mais tarde a Ecma
International para formalizar o Java, mas logo se retirou do processo. Java continua sendo um padrão
proprietário de fato controlado por meio do Java Community Process. A Sun disponibilizava a maioria
de suas implementações Java gratuitamente.
A Sun distinguia entre seu Software Development Kit (SDK) e Runtime Environment (JRE), que
é um subconjunto do SDK, sendo a principal diferença que no JRE o compilador não está presente.Em
2010, a Oracle comprou a Sun Microsystems – criadora do Java – por US$ 7,4 bilhões e se tornou
proprietária dessa linguagem de programação.
6
INTRODUÇÃO E HISTÓRIA DO JAVA
Filosofia
Orientação do objeto
7
A reutilização de software encontrou resultados práticos mistos, com duas dificuldades
principais: o design de objetos verdadeiramente genéricos é mal compreendido e falta uma
metodologia para comunicação ampla de oportunidades de reutilização.
Independência de plataforma
Existem também implementações de compiladores Java que compilam para código de objeto
nativo, como GCJ, removendo o estágio de bytecode intermediário, mas a saída desses compiladores
só pode ser executada em uma única arquitetura.
A licença da Sun para Java insiste em que todas as implementações sejam "compatíveis". Isso
resultou em uma disputa legal com a Microsoft depois que a Sun alegou que a implementação da
Microsoft não suportava as interfaces RMI e JNI e tinha adicionado recursos específicos de
plataforma próprios. Em resposta, a Microsoft não fornece mais o Java com o Windows e, nas versões
recentes do Windows, o Internet Explorer não oferece suporte a mini aplicativos Java sem um plug-in
8
INTRODUÇÃO E HISTÓRIA DO JAVA
de terceiros. No entanto, a Sun e outros disponibilizaram sistemas de tempo de execução Java sem
nenhum custo para essas e outras versões do Windows.
As primeiras implementações da linguagem usaram uma máquina virtual interpretada para
conseguir portabilidade. Essas implementações produziram programas que rodavam mais
lentamente do que programas compilados em executáveis nativos, por exemplo escritos em C ou C
++, então a linguagem sofreu uma reputação de baixo desempenho. Implementações de JVM mais
recentes produzem programas que são executados significativamente mais rápido do que antes,
usando várias técnicas.
A primeira técnica é simplesmente compilar diretamente no código nativo como um
compilador mais tradicional, pulando os bytecodes completamente. Isso proporciona um bom
desempenho, mas às custas da portabilidade.
Outra técnica, conhecida como compilação just-in-time (JIT), converte os bytecodes Java em
código nativo no momento em que o programa é executado, o que resulta em um programa que
executa mais rápido do que o código interpretado, mas também incorre em sobrecarga de
compilação durante a execução. VMs mais sofisticadas usam recompilação dinâmica, na qual a VM
pode analisar o comportamento do programa em execução e recompilar e otimizar seletivamente
partes críticas do programa. A recompilação dinâmica pode alcançar otimizações superiores à
compilação estática porque o compilador dinâmico pode basear as otimizações no conhecimento
sobre o ambiente de tempo de execução e o conjunto de classes carregadas.
A portabilidade é uma meta tecnicamente difícil de atingir, e o sucesso do Java nessa meta foi
misto. Embora seja realmente possível escrever programas para a plataforma Java que se comportem
de forma consistente em muitas plataformas host, o grande número de plataformas disponíveis com
pequenos erros ou inconsistências levou alguns a parodiar o slogan "Grave uma vez, execute em
qualquer lugar" da Sun como "Grave uma vez, depure em todos os lugares".
Java independente de plataforma é, no entanto, muito bem-sucedida com aplicativos do lado
do servidor, como serviços da Web, servlets e Enterprise JavaBeans, bem como com sistemas
incorporados baseados em OSGi, usando ambientes Java incorporados.
Uma ideia por trás do modelo de gerenciamento automático de memória do Java é que os
programadores devem ser poupados do fardo de ter que executar o gerenciamento manual de
memória.
Em algumas linguagens, o programador aloca memória para criar qualquer objeto
armazenado no heap e é responsável por desalocar manualmente essa memória posteriormente
para excluir tais objetos. Se um programador se esquece de desalocar a memória ou escreve um
código que não o faz em tempo hábil, pode ocorrer um vazamento de memória: o programa
consumirá uma quantidade de memória potencialmente arbitrariamente grande. Além disso, se uma
região da memória for desalocada duas vezes, o programa pode se tornar instável e travar.
Finalmente, em ambientes sem coleta de lixo, há um certo grau de sobrecarga e complexidade do
código do usuário para rastrear e finalizar as alocações.
Em Java, esse problema potencial é evitado pela coleta de lixo automática. O programador
9
determina quando os objetos são criados, e o Java runtime é responsável por gerenciar o ciclo de
vida do objeto. O programa ou outros objetos podem fazer referência a um objeto mantendo uma
referência a ele (que, de um ponto de vista de baixo nível, é seu endereço no heap). Quando
nenhuma referência a um objeto permanece, o Garbage Colector Java exclui automaticamente o
objeto inacessível, liberando memória e evitando um vazamento de memória.
Vazamentos de memória ainda podem ocorrer se o código de um programador contém uma
referência a um objeto que não é mais necessário - em outras palavras, eles ainda podem ocorrer,
mas em níveis conceituais mais elevados.
O uso do Garbage Colector em uma linguagem também pode afetar os paradigmas de
programação. Se, por exemplo, o desenvolvedor assume que o custo de alocação / coleta de
memória é baixo, ele pode escolher construir objetos mais livremente em vez de pré inicializá-los,
mantê-los e reutilizá-los.
Com o pequeno custo de possíveis penalidades de desempenho (construção de loop interno
de objetos grandes / complexos), isso facilita o isolamento de thread (não há necessidade de
sincronizar, pois diferentes threads trabalham em diferentes instâncias de objeto) e ocultação de
dados. O uso de objetos de valor imutáveis transitórios minimiza a programação de efeitos colaterais.
Comparando Java e C ++, é possível em C ++ implementar funcionalidade semelhante (por exemplo,
um modelo de gerenciamento de memória para classes específicas pode ser projetado em C ++ para
melhorar a velocidade e reduzir consideravelmente a fragmentação de memória), com o possível
custo de tempo de desenvolvimento extra e alguns complexidade do aplicativo. Em Java, a coleta de
lixo é integrada e virtualmente invisível para o desenvolvedor. Ou seja, os desenvolvedores podem
não ter noção de quando a coleta de lixo ocorrerá, pois ela pode não se correlacionar
necessariamente com quaisquer ações sendo explicitamente executadas pelo código que eles
escrevem. Dependendo da aplicação pretendida, isso pode ser benéfico ou desvantajoso: o
programador fica livre de realizar tarefas de baixo nível, mas ao mesmo tempo perde a opção de
escrever código de baixo nível.
Sintaxe
Applet
Java applets são programas que estão embutidos em outros aplicativos, normalmente em
uma
página da Web exibido em um navegador da Web.
//Hello.java
import java.applet.Applet; import java.awt.Graphics;
10
INTRODUÇÃO E HISTÓRIA DO JAVA
public class Hello extends Applet { public void paint (Graphics gc) {
gc.drawString ("Olá, mundo!", 65, 95);
}
}
Este mini aplicativo irá simplesmente desenhar a string "Olá, mundo!" no retângulo dentro do
qual o mini aplicativo será executado. Este é um exemplo um pouco melhor do uso de recursos OO
do Java, pois a classe estende explicitamente a classe "Applet" básica, substitui o método "pintar" e
usa instruções de importação.
Este documento está usando o elemento HTML <applet>. A tag do mini aplicativo tem três
conjuntos de atributos: code = "Hello" especifica o nome da classe do mini aplicativo e largura =
"200" altura = "200" define a largura e altura em pixels do mini aplicativo. (Applets também podem
ser incorporados em HTML usando o elemento object ou embed, embora o suporte para esses
elementos por navegadores da Web seja inconsistente.
Servlet
Java servlets são componentes Java EE do lado do servidor que geram respostas a solicitações
de clientes.
11
pw.println("Hello, world!"); pw.close();
}
}
Aplicativo
Swing é a biblioteca de interface gráfica com o usuário avançada para a plataforma Java SE.
// Hello.java
import javax.swing. *;
12
INTRODUÇÃO E HISTÓRIA DO JAVA
O método main () é chamado pela JVM quando o programa é iniciado. Ele instancia um novo
quadro Hello e faz com que ele seja exibido chamando o método setVisible (booleano) herdado da
superclasse Component com o parâmetro boolean true. Observe que, uma vez que o quadro é
exibido, sair do método principal não faz com que o programa seja encerrado porque o
encadeamento de despacho de evento AWT permanece ativo até que todas as janelas de nível
superior do Swing tenham sido descartadas.
Aparência e comportamento
A aparência e comportamento padrão dos aplicativos GUI escritos em Java usando o kit de
ferramentas Swing é muito diferente dos aplicativos nativos. É possível especificar uma aparência e
sensação diferentes por meio do sistema plugável de aparência e toque do Swing. Clones do
Windows, GTK e Motif são fornecidos pela Sun.
A Apple também oferece uma aparência Aqua para o Mac OS X. Embora as implementações
anteriores dessa aparência tenham sido consideradas insuficientes, o Swing no Java SE 6 resolve esse
problema usando mais rotinas de desenho de widget nativas das plataformas subjacentes. Como
alternativa, kits de ferramentas de terceiros, como wx4j ou SWT, podem ser usados para aumentar a
integração com o sistema de janelas nativo.
Importância do JAVA
Atualmente, Java é uma das cinco linguagens de programação mais usadas do mundo. Alguns
desenvolvedores tendem a usar Java para o design de aplicativos GUI, enquanto outros usam Java
para construir uma variedade de aplicativos da web. Java também é amplamente utilizado na
fabricação de jogos móveis e Android, a plataforma móvel mais instalada.
13
Disponível em: <https://1000logos.net/java-logo/>. Acesso em 11 set. 2023.
Plataforma independente
As regras de sintaxe do Java são semelhantes à sintaxe C e C ++. Assim, é mais fácil para
iniciantes aprender e usar Java em menos tempo. Simultaneamente, Java é uma linguagem de
programação rival baseada em classe que é orientada a objetos.
Como o Java adota princípios populares de programação orientada a objetos, como herança,
polimorfismo, abstração e invólucro, os aplicativos são modulares, extensíveis e escaláveis, mais
facilmente acessíveis aos programadores. Os desenvolvedores também podem se beneficiar dessas
bibliotecas Java para incorporar de forma mais eficaz os conceitos de design orientado a objetos.
14
INTRODUÇÃO E HISTÓRIA DO JAVA
APIs ROBUSTAS
Hello World
15
linguagem JAVA (você pode executá-lo para testar em algum compilador online, como por exemplo,
clicando em Executar no link https://www.tutorialspoint.com/compile_java8_online.php ).
A versão mais recente do Java Standard Edition é o Java SE 8. Com o avanço do Java e sua
ampla popularidade, várias configurações foram criadas para se adequar a vários tipos de
plataformas. Por exemplo: J2EE para aplicativos corporativos, J2ME para aplicativos móveis.
As novas versões do J2 foram renomeadas como Java SE, Java EE e Java ME, respectivamente.
Java tem algumas características importantes:
● Multithreaded - Com o recurso multithread do Java, é possível escrever programas
que podem executar várias tarefas simultaneamente. Este recurso de design permite que os
desenvolvedores construam aplicativos interativos que podem ser executados sem problemas.
● Interpretado - o código de bytes Java é traduzido em tempo real para instruções da
máquina nativa e não é armazenado em nenhum lugar. O processo de desenvolvimento é mais rápido
e analítico, pois a ligação é um processo incremental e leve.
16
INTRODUÇÃO E HISTÓRIA DO JAVA
Ambiente de Desenvolvimento
Ele oferece aos desenvolvedores ferramentas para criar aplicativos desktop, Web,
corporativos e móveis. O NetBeans foi criado em 1996 por acadêmicos da Universidade de Charles,
em Praga, quando a linguagem de programação Java ainda não era tão abrangente no mundo. O
nome inicial do projeto era Xelfi, em alusão ao Delphi, pois queriam que as funcionalidades fossem
parecidas as IDE´s (ambiente de desenvolvimento integrado) desta linguagem, pois eram mais
atrativas e visuais, assim como, mais naturais ao uso, desenvolvida em Java.
Em 1999 evoluiu para uma IDE proprietária, chamada NetBeans DeveloperX2. Nessa época a
empresa Sun Microsystems havia desistido de sua IDE Java Workshop e procurando por novas
iniciativas adquiriu o projeto NetBeans DeveloperX2 incorporando-o a sua linha de softwares.
17
Hoje em dia, está sendo distribuída em diversos idiomas e a cada dia se torna mais popular,
facilitando o acesso a iniciantes em programação e possibilitado o desenvolvimento de aplicativos
multilíngue.
Os principais recursos do ambiente são:
● editor de código fonte integrado, rico em recursos para aplicações Web (Servlets e
JSP, JSTL, EJBs) e aplicações visuais com Swing que é uma API (Interface de Programação de
Aplicativos) Java para interfaces gráficas, a API Swing procura desenhar por contra própria todos os
componentes, ao invés de delegar essa tarefa ao sistema operacional, como a maioria das outras APIs
de interface gráfica trabalham;
● visualizador de classes integrado ao de interfaces, que gera automaticamente o
código dos componentes de forma bem organizada, facilitando assim o entendimento de
programadores iniciante;
● Suporte ao Java Enterprise Edition, plataforma de programação de computadores
que faz parte da plataforma Java voltada para aplicações multicamadas, baseadas em componentes
que são executados em um servidor de aplicações;
● plugins para UML, Unified Modeling Language, linguagem de modelagem não
proprietária de terceira geração, e desenvolvimento remoto em equipes; interface amigável com CVS
ou Concurrent Version System (Sistema de Versões Concorrentes) é um sistema de controle de versão
que permite que se trabalhe com diversas versões de arquivos organizados em um diretório e
localizados local ou remotamente, mantendo-se suas versões antigas e os logs de quem e quando
manipulou os arquivos;
● CSS, algumas funcionalidades para editar folhas de estilos como destaques, recursos
de auto- completar, análise de código;
● help local e on-line; debug apurado de aplicações e componentes;
● auto-completar avançado; total suporte ao ANT, ferramenta de automatização da
construção de programas e TOMCAT, servidor de aplicações Java para web;
● integração de módulos;
● suporte a Database (banco de dados), Data view e Connection wizard que são os
módulos embutidos na IDE; geração de Javadoc, a ferramente permite a geração automática de
arquivos javadoc em HTML a partir dos comentários inseridos no código, além de recursos que
facilitam a inclusão de comentários no código.
Download do ambiente
18
INTRODUÇÃO E HISTÓRIA DO JAVA
Instalação do ambiente
19
Fonte: Elaborado pelo autor (2023).
20
INTRODUÇÃO E HISTÓRIA DO JAVA
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package helloworldapp;
/**
*
* @author crish
*/
public class HelloWorldApp {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
}
21
}
Clique em salvar seu projeto e todas suas classes alteradas de uma só vez:
Fonte:
Elaborado pelo autor (2023).
O comando executar o projeto ou, igualmente F6, irá compilar e executar o código.
22
INTRODUÇÃO E HISTÓRIA DO JAVA
23
d) 1989
4- Qual das seguintes afirmações é verdadeira sobre a slogan "Write Once, Run Anywhere"
(Escreva uma vez, execute em qualquer lugar) relacionada ao Java?
a) É um termo de marketing sem significado real
b) Significa que o código Java não precisa ser escrito, apenas copiado
c) Refere-se à capacidade do código Java ser executado em diferentes plataformas sem modificações
d) Indica que o Java só pode ser executado em sistemas operacionais específicos
5- Qual é o componente central da plataforma Java que permite a execução de código Java
em diferentes ambientes?
a) JVM (Java Virtual Machine)
b) JRE (Java Runtime Environment)
c) JDK (Java Development Kit)
d) IDE (Integrated Development Environment)
7- Qual foi a versão inicial do Java que introduziu as classes e conceitos de orientação a
objetos?
a) Java 1.0
b) Java 1.1
c) Java 2.0
d) Java 1.5
9- Qual empresa foi responsável por adquirir a Sun Microsystems, a criadora original do Java?
a) Microsoft
b) IBM
24
INTRODUÇÃO E HISTÓRIA DO JAVA
c) Oracle
d) Apple
25
TEMA 02
Habilidades
Conceitos Básicos
Estrutura básica de um programa: Um programa em Java deve ser criado sempre em uma
classe. Dentro dessa classe, tem o método main, e é neste método que você deve escrever seu
código.
26
INTRODUÇÃO E HISTÓRIA DO JAVA
Introdução
Comentários:
// comentários em uma linha
/* comentários */ bloco de comentário
O objeto System.out é a saída padrão em Java, ou seja, a forma de mostrar na tela todos os
comandos definidos no console ou na Interface Gráfica (GUI), quando o código Java é executado.
Dentro deste objeto, os métodos de saídas de dados são: println, print e o printf.
27
System.out.println()
A instrução System.out.println() gera uma saída de texto entre aspas duplas, seguida da
execução de uma nova linha, em que posiciona o cursor na linha abaixo - instrução determinada pelo
“ln”.
Por exemplo:
System.out.print()
A instrução System.out.print(), sem o final “ln”, exibe uma String, definida entre aspas duplas,
sem criar uma linha, ou seja, o cursor ficará na mesma linha do texto.
Por exemplo:
Saída com System.out.print
public class Texto_print {
public static void main(String[] args) { System.out.print(“Crishna ”); System.out.print(“Irion”);
}
}
Caractere de escape
O caractere de escape permite inserir uma nova linha dentro dos métodos print e println do
objeto System.out.
public class Texto_sequencia_caractere { public static void main(String[] args) {
System.out.print(“ Sou \n uma \n boa \n aluna \n ”);
}
}
Neste exemplo, o \n não aparece na saída do console, porém irá quebrar as linhas para cada
palavra que segue sua sequência.
Existem vários caracteres de escape:
Caractere Descrição
de escape
28
INTRODUÇÃO E HISTÓRIA DO JAVA
Variáveis
A linguagem JAVA exige a declaração de tipos de dados para todas as suas variáveis.
Em Java, uma variável é declarada de maneira que é definido o tipo de dados que ela poderá
receber, assim como o seu nome (identificador).
Por exemplo:
int numero;
float numerodecimal; String nome;
No código exemplo, definimos a variável numero como sendo do tipo inteiro int e, portanto,
só poderá receber valores do tipo inteiro.
O mesmo ocorre com a variável numerodecimal, que somente receberá números decimais
(reais), definida como float.
A variável nome foi definida como do tipo String, que receberá dados alfanuméricos.
O tipo de dado pode ser definido como dado primitivo int, float, char ou boolean assim como
de classe nativa do Java ( String ou ArrayList) ou ainda desenvolvida manualmente por fontes
externas.
29
Disponível em: <https://tinyurl.com/47anxkkf>. Acesso em 11 set. 2023.
Identificadores de variáveis
1. Pode ser composta por letras, números e underline (_), porém não pode iniciar com
um número;
2. Existe uma técnica de organização de nomes de acordo com sua utilização(Camel
Case), por exemplo, Classes começam com maiúscula, métodos, atributos e variáveis com
minúsculas, seguidas da próxima palavra iniciada com maiúscula;
3. Java tem como característica ser case sensitive. Assim, um identificador nomeado
numeroUm não é o mesmo que numero um.
Exemplos de declaração de variáveis:
int numeroCasa; float _salario;
String 1variavel; // //Erro no nome dA IDEntificador, por iniciar com caractere numérico.
Variáveis de classe
30
INTRODUÇÃO E HISTÓRIA DO JAVA
Constantes
As constantes são declaradas quando é necessário trabalhar com dados que não podem ser
alterados durante a execução do programa. Elas são representadas com letras maiúsculas.
Em Java há uma palavra-chave , const, para este fim, mas pode-se usar final para o mesmo
fim. A diferença entre as formas de uso é que utilizando final a variável será inicializada uma só vez,
porém o valor pode ser definido após a sua declaração.
Por exemplo:
final float PI = 3.1416F;
final String NOME_PAGINA = “home”;
Operadores Aritméticos
31
Fonte: Elaborado pelo autor (2023).
Os operadores de incremento e decremento (++ e --) são operadores que podem ser
utilizados para incrementar, de um em um ou decrementar, também de um em um, uma variável
numérica.
Por exemplo:
int num = 2; num++;
num--; //a variável num continuará valendo 2.
Observação:
Quando utilizamos esse operador antes da variável, o incremento/decremento é realizado
antes do valor da variável ser processado, mas quando utilizado após, o valor da variável é primeiro
processado e só então o valor será incrementado/decrementado.
Por exemplo:
int num = 5; num++;
++num;
Operadores de igualdade
32
INTRODUÇÃO E HISTÓRIA DO JAVA
Operadores relacionais
Operadores lógicos
Os operadores lógicos são operadores que comparam expressões, sejam associadas ou não.
As operações lógicas possíveis de serem verificadas são: E (representada por &&) e OU (representada
por ||).
Por exemplo:
33
Precedência de operadores
Os operadores aritméticos reproduzem operações matemáticas no código, o que mantém as
regras de precedência, podendo ser manipuladas ao longo do código através do uso de
parênteses.Por exemplo, o cálculo da média de 2 notas, n1 e n2, deve ter em sua expressão o uso de
parênteses na soma das notas, antes da divisão.
Por exemplo:
float media, n1, n2; media = (n1 + n2)/2;
Classe Scanner
A classe Scanner tem como finalidade de executar o processo de entrada de dados no modo
Console. Antes da versão do Java 5 não havia essa alternativa de entrada de dados, o que dificultava
a interação do usuário com o código, principalmente nas primeiras interações de teste ao código.
A classe Scanner é uma classe do pacote java.util usada para obter a entrada dos tipos
primitivos como int, double, etc. e strings. É a maneira mais fácil de ler a entrada em um programa
Java.
Algumas características:
● Para criar um objeto da classe Scanner, normalmente passamos o objeto predefinido
System.in, que representa o fluxo de entrada padrão. Podemos passar um objeto da classe File se
quisermos ler a entrada de um arquivo (veremos no TEMA 08).
● Para ler valores numéricos de um determinado tipo de dados XYZ, a função a ser
usada é nextXYZ ().
● Para ler strings, usamos nextLine ().
● Para ler um único caractere, usamos next(). CharAt (0). A função next () retorna o
próximo token / palavra na entrada como uma string e a função charAt (0) retorna o primeiro
caractere nessa string.
Por exemplo:
// Programa Java para ler vários dados diferentes usando a Scanner.
import java.util.Scanner; public class ScannerDemo1
{
public static void main(String[] args)
{
// Declare o objeto da classe Scanner (sc) Scanner sc = new Scanner(System.in);
// entrada de uma String String nome = sc.nextLine();
// entrada de um Caracter
char genero = sc.next().charAt(0);
// entrada de um número byte, short ou float int idade = sc.nextInt();
long fone = sc.nextLong(); double cod = sc.nextDouble();
}
}
34
INTRODUÇÃO E HISTÓRIA DO JAVA
Entrada :
// Imprimindo os valores para checar as entradas: System.out.println("Nome: "+nome);
System.out.println("Gênero: "+genero); System.out.println(Idade: "+idade);
System.out.println("Número do celular: "+fone); System.out.println("COD: "+cod);
José M 40
9876543210
9.9
Resultado :
Nome: José Gênero: M Idade: 40
Número do celular: 9876543210 COD: 9.9Métodos da Classe
Na tabela estão apresentados os principais métodos da classe Scanner.
Método Descrição
nextXyz() Varre a próxima entrada a qual Xyz pode ser interceptado como
boolean, byte, short, int, long, float ou double.
nextLine() Mostra a linha atual do objeto Scanner e avança para a próxima linha.
35
remove() Essa operação não é suportada pela implementação de um Iterator.
Classe Math
A classe Java Math possui muitos métodos que permitem realizar tarefas matemáticas em
números.
Essa classe já está na package (pacote) java.lang. Ou seja, não é necessário fazer nenhuma
importação.Cada método da classe Math é fundamental para as operações matemáticas necessária
ao longo do código.
Para a compreensão geral da Classe Math é fundamental conhecer os principais métodos
utilizados por ela, entendendo seu funcionamento, seus parâmetros e retornos.
1. Math.abs(...);
Descrição: Retorna o valor absoluto (módulo) do numero passado por parâmetro.
Parâmetro: Pode ser um int, um double, um float ou um long Retorno: Mesmo tipo primitivo
do valor de entrada (parâmetro)
2. Math.acos(...);
Descrição: Retorna ao usuário o arco-cosseno do ângulo passado por parâmetro (retorno
entre 0 e PI [metade superior de uma circunferência trigonométrica)
Parâmetro: double Retorno: double
3. Math.asin(...);
Descrição: Retorna ao arco-seno do ângulo passado para o método (retorno entre -PI/2 [3/4
de circunferência trigonométrica) e PI/2 (1/4 da circunferência)
Parâmetro: double Retorno: double
4. Math.atan(...);
Descrição: Retorna o arco-tangente do ângulo que o usuário passou (mesmo "range"
(intervalo) do Math.asin(...)
Parâmetro: double Retorno: double
5. Math.ceil(...);
Descrição: Este método retorna o maior numero inteiro (menor que o passado como
parâmetro) - (ATENCAO PARA NUMEROS NEGATIVOS)
Parâmetro: double Retorno: double
6. Math.cos(...);Descrição: Retorna o cosseno do ângulo passado
Parâmetro: double Retorno: double
7. Math.exp(...);
Descrição: Retorna o valor da Constante de Euller "e" elevada ao numero passado
Parâmetro: double Retorno: double
8. Math.floor(...);
36
INTRODUÇÃO E HISTÓRIA DO JAVA
Descrição: Retorna o maior numero inteiro (não menor que o passado) - (ATENCAO PARA
NUMEROS NEGATIVOS)
Parâmetro: double Retorno: double
9. Math.log(...);
Descrição: Retorna o logaritmo natural do numero passado.
Parâmetro: double Retorno: double
10. Math.max(... , ...);
Descrição: Retorna o maior entre os números passados
Parâmetro: pode ser um par de int, de double, de float ou de long (desde que os 2
parâmetros sejam do mesmo tipo)
Retorno: depende do tipo de entrada
11. Math.min(... , ...);
Descrição: Retorna o menor entre os números passados
Parâmetro: pode ser um par de int, de double, de float ou de long (desde que os 2
parâmetros sejam do mesmo tipo)
Retorno: depende do tipo de entrada
12. Math.pow(... , ...);
Descrição: Para uma estrutura de potenciação a^b este método retorna o primeiro parâmetro
como 'a' e o segundo como 'b'Parâmetro: double Retorno: double
13. Math.random();
Descrição: um numero aleatório que vai de zero até 1 (0 incluído, 1 nunca será gerado)
Parâmetro: nenhum Retorno: double
14. Math.round(...);
Descrição: Retorna o long mais próximo do parâmetro passado
Parâmetro: double Retorno: long
15. Math.sin(...);
Descrição: Retorna o seno do parâmetro
Parâmetro: double Retorno: double
16. Math.tan(...);
Descrição: Retorna a tangente do ângulo
Parâmetro: double Retorno: double
17. Math.sqrt(...);
Descrição: Retorna a raiz quadrada do numero passado
Parâmetro: double Retorno: double
18. Math.toDregrees(...);
Descrição: Retorna o angula passado (em radianos) em graus
Parâmetro: double Retorno: double
19. Math.toRadians(...);
Descrição: Retorna o angula passado (em graus) em radianos
Parâmetro: double Retorno: double
Cada método aparece no exemplo abaixo, associado à uma saída no console:
class ClasseMath {
37
public static void main(String args[]) { System.out.println("Metodo abs(-30): " + Math.abs(-30)
); System.out.println("Metodo acos(0.5): " + Math.acos(0.5) ); System.out.println("Metodo asin(0.5):
" + Math.asin(0.5) ); System.out.println("Metodo atan(60): " + Math.atan(60) );
System.out.println("Metodo ceil(5.215): " + Math.ceil(5.215) );
System.out.println("Metodo ceil(-5.215): " + Math.ceil(-5.215) ); System.out.println("Metodo
cos(60): " + Math.cos(60) ); System.out.println("Metodo exp(10): " + Math.exp(10) );
System.out.println("Metodo floor(54.687): " + Math.floor(54.687) ); System.out.println("Metodo
floor(-54.687): " + Math.floor(-54.687) ); System.out.println("Metodo log(2): " + Math.log(2) );
System.out.println("Metodo max(5,7): " + Math.max(5,7) ); System.out.println("Metodo min(-3,2): " +
Math.min(-3,2) ); System.out.println("Metodo pow(2,3): " + Math.pow(2,3) );
System.out.println("Metodo random(): " + Math.random() ); System.out.println("Metodo
round(13.124): " + Math.round(13.124) ); System.out.println("Metodo sin(30): " + Math.sin(30) );
System.out.println("Metodo sqrt(16): " + Math.sqrt(16) ); System.out.println("Metodo tan(45): " +
Math.tan(45) ); System.out.println("Metodo toDregrees(2): " + Math.toDegrees(2) );
System.out.println("Metodo toRadians(90): " + Math.toRadians(90) );
}
}
O resultado na saída será:
Metodo abs(-30): 30
Metodo acos(0.5): 1.0471975511965979
Metodo asin(0.5): 0.5235987755982989
Metodo atan(60): 1.554131203080956
Metodo ceil(5.215): 6.0
Metodo ceil(-5.215): -5.0
Metodo cos(60): -0.9524129804151563
Metodo exp(10): 22026.465794806718
Metodo floor(54.687): 54.0
Metodo floor(-54.687): -55.0
Metodo log(2): 0.6931471805599453
Metodo max(5,7): 7
Metodo min(-3,2): -3Metodo pow(2,3): 8.0
Metodo random(): 0.6100207813062897
Metodo round(13.124): 13
Metodo sin(30): -0.9880316240928618
Metodo sqrt(16): 4.0
Metodo tan(45): 1.6197751905438615
Metodo toDregrees(2): 114.59155902616465
Metodo toRadians(90): 1.5707963267948966
A classe math possui, ainda, 2 campos finais estáticos (constantes), que podem ser usados ao
longo do código, apenas respeitando o tipo dos dados deles, são eles:
● Math.E -> que é a constante para bases naturais de logs
● Math.PI -> constante do valor PI
Por exemplo, o uso da constante em um cálculo dentro de um método:
38
INTRODUÇÃO E HISTÓRIA DO JAVA
39
a) Um valor numérico constante.
b) Um operador matemático.
c) Uma instrução que verifica uma situação específica.
d) Uma sequência de caracteres.
8- O que é um pseudocódigo?
a) Um código de programação altamente otimizado.
b) Um tipo de gráfico usado para representar algoritmos.
c) Uma linguagem de programação orientada a objetos.
d) Uma representação textual simplificada de um algoritmo.
40
INTRODUÇÃO E HISTÓRIA DO JAVA
TEMA 03
Habilidades
Disponível
em: <https://tinyurl.com/3cawa5yc>. Acesso em 11 set. 2023.
Introdução
As classes de strings em Java são fundamentais para o tratamento de texto. Elas permitem a
manipulação, concatenação e análise de cadeias de caracteres. As strings são imutáveis, ou seja, uma
vez criadas, não podem ser alteradas diretamente. Isso garante estabilidade e segurança na
manipulação de informações textuais. Por meio das classes de strings, os programadores podem
realizar tarefas como combinar palavras, buscar padrões e modificar conteúdo de maneira eficiente.
As operações com strings são essenciais em muitos aplicativos, desde processamento de dados até a
criação de interfaces de usuário.
41
A definição de String é: uma sequência organizada de caracteres.
Construtores
1. String (byte [] byte_arr) - Constrói uma nova String decodificando a matriz de bytes .
Ele usa o conjunto de caracteres padrão da plataforma para decodificação.
Exemplo:
byte [] b_arr = {71, 101, 101, 107, 115};
String s_byte = new String (b_arr);
2. String (byte [] byte_arr, Charset char_set) - Constrói uma nova String decodificando a
matriz de bytes . Ele usa o char_set para decodificação.
Exemplo:
byte [] b_arr = {71, 101, 101, 107, 115};
Charset cs = Charset.defaultCharset (); String s_byte_char = new String (b_arr, cs);
3. String (byte [] byte_arr, String char_set_name) - Construa uma nova String
decodificando a matriz de bytes . Ele usa o char_set_name para decodificação. É semelhante às
construções acima e elas aparecem antes de funções semelhantes, mas leva o String (que contém
char_set_name) como parâmetro enquanto o construtor acima leva CharSet.
Exemplo:
byte [] b = {1, 11, 21, 77, 15};
String s = new String (b, "US-ASCII");
4. String (byte [] byte_arr, int start_index, int length) - Constrói uma nova string a partir
da matriz de bytes dependendo do start_index (localização inicial) e comprimento (número de
caracteres da localização inicial).
Exemplo:
byte [] b = {1, 11, 21, 77, 15};
String s = nova String (b, 1, 3);
String (byte [] byte_arr, int start_index, int length, Charset char_set) - Constrói uma nova
string da matriz de bytes dependendo do start_index (localização inicial) e comprimento (número de
caracteres da localização inicial). Usa char_set para decodificação.
Exemplo:
byte [] b = {1, 11, 21, 77, 15};
Charset cs = Charset.defaultCharset (); String s = nova String (b, 1, 3, cs);
5. String (byte [] byte_arr, int start_index, int length, String char_set_name) - Constrói
42
INTRODUÇÃO E HISTÓRIA DO JAVA
uma nova string da matriz de bytes dependendo do start_index (localização inicial) e comprimento
(número de caracteres da localização inicial). Usa char_set_name para decodificação.
Exemplo: byte [] b = {1, 11, 21, 77, 15};
String s = new String (b, 1, 4, "US-ASCII");
6. String (char [] char_arr) - Aloca uma nova String da matriz de caracteres fornecida .
Exemplo:
char c [] = {'J', 'a', 'v', 'a'}; String s = new String (c);
Métodos de String
43
int out = s1.compareTo(s2); // s1 e s2 são strings a serem comparadas
Isso retorna a diferença s1-s2. Se :
out < 0 // s1 vem antes de s2 out = 0 // s1 e s2 são iguais. out > 0 // s1 vem depois de s2.
12. int compareToIgnoreCase (String anotherString): Compara duas strings
lexicograficamente, ignorando as considerações de maiúsculas e minúsculas.
int out = s1.compareToIgnoreCase(s2);
// onde s1 e s2 são strings a serem comparadas
Isso retorna a diferença s1-s2. Se:
out <0 // s1 vem antes de s2 out = 0 // s1 e s2 são iguais. out> 0 // s1 vem depois de s2.
Neste caso, não irá considerar maiúsculas e minúsculas (irá ignorar se é maiúscula ou
minúscula).
String toLowerCase () : Converte todos os caracteres da String em minúsculas.
String palavra1 = “OLÁ”;
String palavra3 = palavra1.toLowerCase(); // retorna “olá"
13. String toUpperCase () : Converte todos os caracteres da String em maiúsculas.
String palavra1 = “olá”;
String palavra2 = palavra1. toUpperCase(); // retorna “OLÁ”
14. String trim () : Retorna a cópia da String, removendo os espaços em branco em
ambas as extremidades. Não afeta os espaços em branco no meio.
String w1 = “ Aprenda, Compartilhe Aprenda “;
String w2 = w1.trim (); // retorna “Aprender, Compartilhar Aprender”
15. Substituição de string (char oldChar, char newChar) : Retorna uma nova string
substituindo todas as ocorrências de oldChar por newChar.
String s1 = “CursodeJBVB“;
String s2 = “CursodeJBVB”.replace ('B', 'A'); // retorna “CursodeJAVA”
Observação: - s1 ainda é CursodeJBVB e s2 é CursodeJAVA
Programa para ilustrar todos os métodos de string:
import java.io.*; import java.util.*; class Teste
{
public static void main (String[] args)
{
String s = "CursodeJAVA";
// ou String s = new String ("CursodeJAVA");
// Retora o número de caracteres na String System.out.println("Tamanho da String = " +
s.length());
// Returns the character at ith index. System.out.println("Caracter na 3ª posição = "
+ s.charAt(3));
// Retorna a substring no índice 3 System.out.println("Substring = " + s.substring(3));
// Retorna a substring do índice i até j-1 (2 a 5)
}
}
Resultado :
System.out.println("Substring = " + s.substring(2,5));
// Concatena a string2 no fim da string1. String s1 = "JAVA";
44
INTRODUÇÃO E HISTÓRIA DO JAVA
45
2- Qual característica das strings em Java as torna imutáveis?
a) Elas não podem ser declaradas como variáveis.
b) Uma vez criadas, seu conteúdo não pode ser alterado.
c) Elas só podem ser utilizadas em loops.
d) São apenas usadas para comentários em código.
5- Qual método é usado para transformar uma string em letras maiúsculas em Java?
a) toLowerCase()
b) uppercase()
c) toUpper()
d) upperCase()
7- Qual método é usado para extrair uma parte específica de uma string em Java?
a) substring()
b) extract()
c) section()
d) split()
46
INTRODUÇÃO E HISTÓRIA DO JAVA
9- Qual método é usado para encontrar a posição de uma subcadeia dentro de uma string em
Java?
a) find()
b) locate()
c) search()
d) indexOf()
47
TEMA 04
Habilidades
Introdução
Condicional If
48
INTRODUÇÃO E HISTÓRIA DO JAVA
O switch é uma estrutura de decisão que, de acordo com determinado valor, executa um
bloco de código específico. Ao contrário do if, ele lida com valores que não são booleanos.
O Switch permite executar uma entre várias opções de comandos. Assim, pode-se substituir
vários ifs encadeados por um código simples para criação, entendimento e manutenção.
Por exemplo, um algoritmo que proponha a escolha de um número qualquer entre 1 e 3 :
System.out.println("Digite um número entre 1 e 3:"); int n = entrada.nextInt();
switch (n) {
case 1:
System.out.println("Você escolheu 1"); break;
case 2:
System.out.println("Você escolheu 2"); break;
case 3:
System.out.println("Você escolheu 3"); break;
default:
49
System.out.println("Número inválido");
}
Exemplos de exercícios em JAVA:
1. Escreva um programa que, com base em uma temperatura em graus celsius (15º), a
converta e exiba em Kelvin (K), Réaumur (Re), Rankine (Ra) e Fahrenheit (F), seguindo as fórmulas:
F = C * 1.8 + 32; K = C + 273.15; Re = C * 0.8;
Ra = C * 1.8 + 32 + 459.67
2. Escreva um programa que entre com um número e o imprima caso seja maior do que
20.
3. Entrar com dois números e imprimir o menor número (suponha números diferentes).
50
INTRODUÇÃO E HISTÓRIA DO JAVA
51
Fonte: Elaborado pelo autor (2023).
E este outro?
Teste na sua IDE Netbeans esses códigos e verifique o que acontece a cada etapa do código.
Se necessário use alguns System.out.println ao longo do código, para verificar a saída de cada variável
e seu comportamento a cada condição.
52
INTRODUÇÃO E HISTÓRIA DO JAVA
7- Como você expressa uma comparação "se maior que" em uma estrutura condicional?
a) >
b) <
c) >=
d) <=
53
8- Qual é o resultado de uma expressão lógica que usa o operador "&&" (AND)?
a) Verdadeiro se pelo menos um dos operandos for verdadeiro.
b) Verdadeiro apenas se ambos os operandos forem verdadeiros.
c) Falso se pelo menos um dos operandos for falso.
d) Falso apenas se ambos os operandos forem falsos.
10- Qual das seguintes opções representa uma estrutura condicional aninhada?
a) switch
b) for
c) if-else
d) while
54
INTRODUÇÃO E HISTÓRIA DO JAVA
TEMA 05
Habilidades
Introdução
Estruturas de Repetição
As estruturas de repetição, também conhecidas como laços (loops), são utilizadas para
executar, repetidamente, um comando ou bloco de comandos atendendo a determinada condição.
Elas se classificam em dois tipos:
55
● Laços Contados: Sabe-se (ou o usuário sabe) exatamente quantas vezes o comando
no interior da construção será executado;
Exemplo: Comando for.
● Laços Condicionais: Inicialmente não se sabe o número de vezes que o conjunto de
comandos no interior do laço será repetido. Dependerá de uma condição sujeita à modificação pelas
instruções do interior do laço.
‘Exemplo: Comandos while e do while.
for ( ; ; ) {
// Bloco do laço for
}
Entre os parênteses do for, há 3 posições separadas por ponto e virgula.
A primeira posição é utilizada para inclusão de uma expressão para iniciar nossas iterações.
Por exemplo:
int i = 0;
Na segunda posição, coloca-se uma expressão que precisa retornar um valor booleano. É a
posição onde existe a relação entre o número de iterações e a quantidade de iterações desejadas.
Por exemplo:
i < 5;
56
INTRODUÇÃO E HISTÓRIA DO JAVA
Neste exemplo, enquanto a variável i for menor do que 5, a estrutura for irá repetir e, quando
i chegar ao valor 5, as iterações irão parar.
A terceira posição do laço terá a expressão de incremento (de quanto em quanto o i irá ser
incrementado). É chamada “expressão de iteração”. Em geral, a variável i aumenta de uma em uma
unidade.
Por exemplo:
i = i + 1;
57
repetição, em que o i = 2 Acompanhe a repetição, em que o i = 3 Acompanhe a repetição, em que o i
=4
Exercícios:
1. Escreva um programa em JAVA que receba o nome de um aluno com suas respectivas 2
notas, em seguida calcular a média do aluno e apresentar ao final a média calculada e a situação de
Aprovação do aluno. (aprovado com média >= 6).
Observações:
● A turma tem 30 alunos.
● Calcular e mostrar a média geral da turma
import java.util.*; public class MediaTurma{
public static void main(String[] args) { Scanner teclado = new Scanner(System.in); String
aluno;
float nota1, nota2, media, soma, mediaTurma; soma = 0;
for(int i=0; i<30; i++){ System.out.print("Nome do Aluno: "); aluno = teclado.nextLine();
System.out.print("Nota 1: "); nota1 = teclado.nextFloat();
System.out.print("Nota 2: "); nota2 = teclado.nextFloat(); teclado.nextLine();
media = (nota1+nota2)/2; soma = soma + media;
System.out.printf("Média do aluno é %.1f\n", media);
if (media >= 6)
System.out.println("Aluno Aprovado. Parabéns."); else
System.out.println("Em recuperação! Estude bastante.");
}
mediaTurma = soma/30;
System.out.printf("Média da Turma = %.1f\n", mediaTurma);
}
}
A estrutura de um laço while é definida por uma condição. Esta condição é uma expressão
que gera um valor booleano (true ou false).
Por exemplo:
while ( ) {
// Bloco do while
}
58
INTRODUÇÃO E HISTÓRIA DO JAVA
1;
}
Neste exemplo, são impressas as iterações de 0 até 5, da mesma forma feita com o for, porém
o incremento não está mais no escopo da estrutura, mas conta no bloco de comandos.
Exemplo de uma condição de parada em que o usuário decide quando quer parar:
Scanner scanner = new Scanner(System.in); int numero, op =1;
while (op == 1) {
System.out.print("Digite um número: "); numero = scanner.nextInt();
System.out.print("Digite 1 para continuar ou qualquer número para sair: ");
op = scanner.nextInt();
}
2- Qual estrutura de controle de repetição é mais adequada quando você sabe exatamente
quantas vezes deseja executar um bloco de código?
A) while loop
B) do-while loop
C) for loop
D) if statement
3- Em qual estrutura de repetição o bloco de código é executado pelo menos uma vez,
independentemente da condição?
59
A) while loop
B) do-while loop
C) for loop
D) if statement
10- Qual das seguintes estruturas de repetição é mais apropriada quando você não sabe
quantas vezes deseja executar um bloco de código?
60
INTRODUÇÃO E HISTÓRIA DO JAVA
A) while loop
B) do-while loop
C) for loop
D) if statement
61
TEMA 06
Habilidades
Introdução
62
INTRODUÇÃO E HISTÓRIA DO JAVA
Vantagens
Desvantagens
63
Existem dois tipos de array:
● Matriz unidimensional
● Matriz Multidimensional
; // inicialização
0] 0
;
1] 0
;
2] 0
;
3] 0
;
4] 0
// percorrendo a matriz
for (int i=0; i<a.length; i ++) // comprimento é a propriedade da matriz System.out.println
(a[i]);
}
}
Resultado:
10
20
70
40
50
Também podemos imprimir o array Java usando for-each loop . O loop for-each do Java
imprime os elementos do array um por um.
64
INTRODUÇÃO E HISTÓRIA DO JAVA
Ele mantém um elemento da matriz em uma variável e, em seguida, executa o corpo do loop.
A sintaxe da repetição for-each é:
for (tipo variável: array) {
// comandos
}
Programa Java para imprimir os elementos do array usando a repetição for-each
class TesteArray1 {
public static void main (String args []) { int arr[] = { 33 , 3 , 4 , 5 };
// imprimindo array usando for-each loop for (int i: arr)
System.out.println (i);
}
}
Resultado:
33
3
4
5
Podemos passar o array java para o método para que possamos reutilizar a mesma lógica em
qualquer array.
Programa Java para demonstrar a maneira de passar um array para o método.
class TesteArray2{
// criando um método que recebe um array como parâmetro static void min(int arr[]){
int min = arr[0];
for(int i=1;i<arr.length;i++) if(min>arr[i])
min=arr[i];
System.out.println(min);
}
public static void main(String args[]){
int a[]={33,3,4,5};//declarando e inicializando um array min(a);// passando array para método
}
}
Resultado:
3
Nesse caso, os dados são armazenados em um índice baseado em linha e coluna (também
conhecido como formato de matriz).
65
Sintaxe para declarar array multidimensional em Java:
tipo[ ][ ] array; (ou)
tipo [ ][ ]arrayr; (ou)
tipo array[ ][ ]; (ou)
tipo [ ]array[ ];
Exemplo para instanciar Array Bidimensional em Java
int [][]arr = new int[3][3]; // 3 linhas e 3 colunas
Em seguida o programa mostra como declarar, instanciar, inicializar e imprimir a array
Bidimensional.
Programa Java para ilustrar o uso de array multidimensional
class Testarray3 {
public static void main (String args []) {
// declarando e inicializando a array
int arr [] [] = {{ 1 , 2 , 3 }, { 2 , 4 , 5 }, { 4 , 4 , 5 }};
// imprimindo matriz 2D
for (int i = 0 ; i < 3 ; i ++) { for (int j = 0 ; j < 3 ; j ++) {
System.out.print (arr[i][j] + "");
}
System.out.println ();
}
}
}
Resultado:
123
245
445
66
INTRODUÇÃO E HISTÓRIA DO JAVA
a) Um vetor armazena elementos de tipos primitivos, enquanto uma matriz armazena objetos.
b) Um vetor é unidimensional, enquanto uma matriz é bidimensional ou multidimensional.
c) Um vetor pode armazenar mais elementos do que uma matriz.
d) Um vetor tem um tamanho fixo, enquanto uma matriz é dinamicamente ajustável.
9- Qual método é usado para acessar um elemento específico de uma matriz em Java?
a) get()
b) at()
c) getElement()
d) [linha][coluna]
67
TEMA 07
Habilidades
Introdução
68
INTRODUÇÃO E HISTÓRIA DO JAVA
O conceito básico de POO é criar objetos, reutilizá-los em todo o programa e manipular esses
objetos para obter resultados.
● Abstração: significa usar coisas simples para representar a complexidade. Todos nós
sabemos como ligar a TV, mas não precisamos saber como funciona para aproveitá-la. Em Java,
abstração significa coisas simples como objetos , classes e variáveis que representam códigos e dados
69
subjacentes mais complexos. Isso é importante porque permite evitar a repetição do mesmo trabalho
várias vezes.
● Encapsulamento: é a prática de manter os campos dentro de uma classe privada e,
em seguida, fornecer acesso a eles por meio de métodos públicos. É uma barreira protetora que
mantém os dados e o código seguros dentro da própria classe. Dessa forma, podemos reutilizar
objetos como componentes de código ou variáveis sem permitir acesso aberto aos dados de todo o
sistema.
● Herança: é um recurso especial da Programação Orientada a Objetos em Java. Ele
permite que os programadores criem novas classes que compartilham alguns dos atributos das
classes existentes. Isso nos permite desenvolver o trabalho anterior sem reinventar a roda.
● Polimorfismo: conceito Java POO permite que os programadores usem a mesma
palavra para significar coisas diferentes em contextos diferentes. Uma forma de polimorfismo em
Java é a sobrecarga de método. É quando significados diferentes estão implícitos no próprio código. A
outra forma é a substituição de métodos. É quando os diferentes significados estão implícitos nos
valores das variáveis fornecidas. Veja mais sobre isso abaixo.
Todos estes conceitos funcionam permitindo que os programadores criem componentes que
podem ser reutilizados de diferentes maneiras, mas ainda mantêm a segurança. Eles são aprendidos
a medida em que se evolui no conhecimento de JAVA. Neste curso aprenderemos o Encapsulamento
e Abstração.
70
INTRODUÇÃO E HISTÓRIA DO JAVA
Objeto
Objeto significa uma entidade do mundo real, como uma caneta, cadeira, mesa, computador,
relógio, etc. A Programação Orientada a Objetos é uma metodologia ou paradigma para projetar um
programa usando classes e objetos. É uma coisa Natural ou abstrata, percebida pelos sentidos e
descrita por suas características, comportamento e estado atual.
Um objeto é um conceito, uma abstração ou uma coisa com identidade que possui significado
para uma aplicação, que normalmente parecem como nomes próprios ou referências específicas nas
descrições de problemas e discussões com os usuários e clientes durante o processo de
desenvolvimento de sistemas de software. Todos os objetos possuem identidade e são distinguíveis.
71
Um objeto pode ser definido como uma instância de uma classe. Um objeto contém um
endereço e ocupa algum espaço na memória.
Os objetos podem se comunicar sem conhecer os detalhes dos dados ou código uns dos
outros. A única coisa necessária é o tipo de mensagem aceita e o tipo de resposta retornada pelos
objetos.
Exemplo de objetos concretos e abstratos: Smartphone (concreto)
● Características ( modelo, marca, capacidade);
● Comportamento (ligar, desligar, clicar, rolarTela);
● Estado (ligado, desligado, travado); Compromisso (abstrato)
● Características (horário, comQuem, local);
● Comportamento (Marcar, desmarcar, realocar);
● Estado (marcado, cancelado)
Nas figuras a seguir, você pode notar diferentes tipos de motocicletas que podem ser
utilizadas para diferentes propósitos. Algumas pessoas utilizam para trabalho, outras utilizam para
passeio. Mas todas são motocicletas e têm propriedades em comum.
Moto de Passeio
Moto de trabalho
72
INTRODUÇÃO E HISTÓRIA DO JAVA
Note que os diferentes tipos de motos têm diferentes características e propriedades e que
são distinguíveis entre si.
Coisas que tenho (TEM) modelo, marca, cor, nroPlaca, nroChassi ATRIBUTOS
Como estou agora (ESTADO ATUAL) nova, quebrada, velha, turbinada STATUS
Este exemplo nos leva às definições que envolvem a construção dos objetos, como suas
características, comportamento e estado.
Classe
Uma classe é um projeto ou protótipo definido pelo usuário a partir do qual os objetos são
criados. Ele representa o conjunto de propriedades ou métodos comuns a todos os objetos de um
tipo. A classe é o “Molde”, aquele que se encaixa em todos os objetos;
Por exemplo, todas as motos das figuras anteriores pertencem à classe Motocicleta e têm as
mesmas propriedades, que são: modelo, marca, número do chassi, placa, cor, número de cilindradas.
Essas são propriedades relevantes que descrevem as propriedades em comum dessas
diferentes motocicletas.
Todos esses diferentes objetos Motocicletas pertencem à mesma Classe Motocicleta, que
poderia ser representada como é apresentada na figura a seguir por meio da notação de classe e da
notação de objeto em UML:
73
Disponível em: <https://youtu.be/aBagKMTkWv8>. Acesso em 11 set. 2023.
Você pode perceber que os objeto da mesma classe também têm as mesmas operações que
são: licenciar e checarChassi.
Veja a figura a seguir.
74
INTRODUÇÃO E HISTÓRIA DO JAVA
Atributo
Atributo é um dado (informação de estado) para o qual cada Objeto em uma Classe tem seu
próprio valor.
Valor
Um valor é um elemento dos dados. Você pode achar valores por meio do exame da
documentação do problema.
Analogia: objeto está para classe assim como valor está para atributo.
Quando um objeto de uma classe é criado, diz-se que a classe está instanciada.
Todas as instâncias compartilham os atributos e o comportamento da classe. Mas os valores
desses atributos, ou seja, os estados são únicos para cada objeto.
Uma única classe pode ter qualquer número de instâncias, sendo devidamente diferenciadas
por seus nomes, conforme declaramos as variáveis. Isso notifica o compilador de que usaremos o
nome para referir aos dados da Classe a que esse objeto pertence (o seu tipo).
Assim como uma variável primitiva, a declaração na instância da Classe também reserva uma
quantidade adequada de memória para a variável.
Exemplo:
Motocicleta m1;//declaração da variável do tipo Motocicleta Motocicleta m2;
Método
75
Todo método tem como característica própria o uso de parênteses para parâmetros que
tenha ou não, mas sempre terá parênteses sempre em sua estrutura.
Note que as características criadas na classe Moto() são definidas nas instâncias, atribuindo
valores a elas. Já os métodos são invocados.
76
INTRODUÇÃO E HISTÓRIA DO JAVA
77
8- O que são métodos em POO?
a) Variáveis que armazenam valores específicos para um objeto.
b) Operações que podem ser realizadas em objetos, representadas como funções.
c) Atributos que armazenam informações sobre objetos.
d) Estruturas de controle usadas para tomada de decisões.
78
INTRODUÇÃO E HISTÓRIA DO JAVA
TEMA 08
CONSTRUTORES
Habilidades
Introdução
79
Disponível em: <freepix-https://tinyurl.com/2djs7pa3>. Acesso em 11 set. 2023.
Construtor
Um construtor determina as ações que podem ser executadas quando um objeto é criado em
JAVA. . Ele é definido como um método, que deve ter o mesmo nome da classe e sem definição do
tipo de retorno, nem mesmo void.
O construtor é unicamente invocado no momento da criação do objeto através do operador
new. O retorno do operador new é uma referência para o objeto recém-criado.
O construtor pode receber argumentos, como qualquer método. Usando o mecanismo de
sobrecarga, mais de um construtor pode ser definido para uma classe.
Um construtor é um método de grande importância dentro de uma classe Java. Ele possui
algumas características próprias:
● É um método que tem o mesmo nome que a classe
● O padrão (default) não possui um valor de retorno, nem mesmo void.
● Pode conter parâmetros (argumentos)
● Toda classe deve possuir ao menos um construtor
● Se nenhum construtor for definido em uma classe, a JVM irá prover um construtor
padrão, sem argumentos, conhecido como default.
Ao ser criada, uma classe inicializa seus atributos da seguinte maneira:
● Tipos primitivos numéricos (int, short, byte, long, float, double) são inicializados com
valor 0 (Zero)
● Tipos primitivos booleanos (boolean) são inicializados com valor false
● Tipos primitivos caracteres (char) são inicializar com valor ” (vazio)
● Objetos são inicializados como null.
Quando criamos a classe Moto e instanciamos o objeto m1, ele foi criado usando o
construtor default Moto( ).
Exemplo:
80
INTRODUÇÃO E HISTÓRIA DO JAVA
81
construtor default.
Não foi definida no programa principal a cor do círculo c1, porém ela aparece como amarela,
pois estava pré definida no construtor sobrecarregado, ao qual o objeto c1 foi instanciado. Já c2,
instanciado com o construtor default (que tinha como cor definida “Verde”) teve uma alteração com
o modificador SET, que será desenvolvido a seguir, sendo definida a cor no desenvolvimento do
código como azul.
A saída deste código será desta forma:
82
INTRODUÇÃO E HISTÓRIA DO JAVA
7- Em Java, qual é o modificador de acesso mais apropriado para um construtor que deve ser
acessível somente dentro da classe?
a) private
b) public
c) protected
d) static
83
a) A classe não pode ser instanciada.
b) O Java automaticamente cria um construtor padrão vazio.
c) O Java gera um erro de compilação.
d) A classe não pode ser usada como uma superclasse.
10- Ao criar uma subclasse, se o construtor da classe pai não for explicitamente chamado,
qual construtor da classe pai será chamado automaticamente?
a) O construtor padrão.
b) O construtor que aceita mais parâmetros.
c) O construtor que aceita menos parâmetros.
d) O construtor parametrizado com os mesmos parâmetros da subclasse.
84
INTRODUÇÃO E HISTÓRIA DO JAVA
TEMA 09
ENCAPSULAMENTO E OS MÉTODOS MODIFICADORES E
ACESSORES
Habilidades
Introdução
85
Disponível em: <DCStudio-https://tinyurl.com/2jm9ma94>. Acesso em 11 set. 2023.
Encapsulamento
86
INTRODUÇÃO E HISTÓRIA DO JAVA
87
Fonte: Elaborado pelo autor (2023).
Programa principal
Qual seria então a solução correta, já que encapsulamos a variável nome, de forma privada?
A saída será:
Joaozinho
Modificadores e Acessores
88
INTRODUÇÃO E HISTÓRIA DO JAVA
respectivamente.
Por convenção, getters começam com a palavra "get" e setters com a palavra "set", seguido
por um nome de variável. Em ambos os casos, a primeira letra do nome da variável é maiúscula, por
exemplo:
public class Veiculo { private String cor;
// Getter
public String getCor() { return cor;
}
// Setter
public void setCor(String c) { this.cor = c;
}
}
O método getter retorna o valor do atributo. O método setter pega um parâmetro e o atribui
ao atributo. Uma vez que getter e setter foram definidos, podemos usa-los no nosso programa
principal:
public static void main(String[] args) { Veiculo v1 = new Veiculo(); v1.setCor("Verde");
System.out.println(v1.getCor());
}
// A saída será "Verde"
Getters e setters permitem controle sobre os valores. Você pode validar o valor fornecido no
configurador antes de definir o valor.
Não, mas é uma boa prática. Os getters e setters permitem controlar como variáveis
importantes são acessadas e atualizadas no código. Por exemplo, considere este método setter:
public void setNum(int num) { if (num < 1 || num > 10) {
System.out.println(“Erro do valor numérico”);
}
this.num = num;
}
Ao usar o método setNum, você pode ter certeza de que o valor de num está sempre entre 1
e 10. Isso é muito melhor do que atualizar a variável num diretamente, como por exemplo:
obj.num = 13;
Se você atualizar num diretamente, é possível que cause efeitos colaterais indesejados em
algum outro lugar do seu código. Aqui, definir num como 13 viola a restrição de 1 a 10 que queremos
estabelecer. Criar num como uma variável privada e usar o rmétodo setNum evitaria que isso
acontecesse. Por outro lado, a única maneira de ler o valor de num é usando um método getter:
public int getNum() { return this.num;
}
Resumindo:
89
1. Se você definir apenas o método getter, ele pode se tornar somente leitura.
2. Se você definir apenas o método setter, ele pode ser feito somente para gravação.
3. Se você definir os métodos getter e setter, eles poderão ser utilizados para leitura e
gravação.
Voltando ao exemplo do Círculo, agora com a Classe completa:
90
INTRODUÇÃO E HISTÓRIA DO JAVA
91
9- Qual é o objetivo principal dos métodos modificadores e acessores?
a) Acelerar a execução do programa.
b) Facilitar a criação de objetos.
c) Controlar o acesso e a modificação dos atributos de uma classe.
d) Substituir atributos por métodos.
10- Em um exemplo de classe chamada "Pessoa", como um método modificador poderia ser
definido para alterar o nome da pessoa?
a) setNomePessoa(nome)
b) alterarNome(nome)
c) mudarNome(nome)
d) nome = novoNome(nome)
.
92
INTRODUÇÃO E HISTÓRIA DO JAVA
TEMA 10
Habilidades
Introdução
93
Disponível em: <http://www.mauda.com.br/?p=1433>. Acesso em 11 set. 2023.
Por outro lado, quando um atributo ou método é definido como public, ele se torna acessível
a partir de qualquer classe, possibilitando uma interação mais aberta e flexível. Isso pode ser útil
quando você deseja que determinadas funcionalidades da classe sejam utilizadas livremente por
outras partes do código.
Os modificadores de acesso em Java desempenham um papel crucial na organização interna
de uma classe, permitindo que você estabeleça barreiras de proteção quando necessário e torne
partes específicas da classe acessíveis quando apropriado. Ao fazer isso, eles contribuem para a
criação de um código mais seguro e compreensível, facilitando o desenvolvimento, a manutenção e a
colaboração em projetos de software. Portanto, compreender e aplicar adequadamente esses
modificadores é um passo essencial para qualquer programador Java que busca escrever código de
qualidade.
São 4 os modificadores de acesso básicos da linguagem Java:
private, padrão, protected e public
Eles servem para tornar componentes da sua aplicação mais ou menos acessíveis por outras
partes do seu programa.
Modificador Funcionalidade
public permite que qualquer outra parte da aplicação tenha acesso ao membro
Padrão membros que não foram marcados com nenhum modificador explicitamente. Só
(default) podem ser acessados por outras classes dentro do mesmo pacote
protected os membros são acessíveis por classes dentro do mesmo pacote e por classes
derivadas (mesmo em pacotes diferente)
94
INTRODUÇÃO E HISTÓRIA DO JAVA
public
O modificador de acesso public é o menos restritivo de todos. Ele permite que qualquer
outra parte da sua aplicação tenha acesso ao componente marcado como public.
Dentro do mesmo pacote
Classes Carro e Motor:
package garagem; public class Carro {
public String marca; public String cor; public Motor motor;
public void ligar()
{
this.motor.darPartida();
}
95
A classe Carro tem acesso a todos os membros marcados como public da classe Motor
mesmo que as duas classes estejam em pacotes distintos.
Dentro de pacotes diferentes
Vamos colocar a classe Motor no pacote garagemdovizinho e fazer a importação na classe
Carro:
package garagem;
import garagemdovizinho.Motor; public class Carro {
public String marca; public String cor; public Motor motor;
public void ligar()
{
this.motor.darPartida();
}
public String toString()
{
return marca + " " + cor + " " + motor.potencia;
}
}
Mesmo com a classe Motor dentro do um pacote diferente, a classe Carro continua
conseguindo acessar o método darPartida() e a propriedade potencia da classe Motor.
Classes derivadas
Os membros de uma classe que são explicitamente marcados com o modificador de acesso
96
INTRODUÇÃO E HISTÓRIA DO JAVA
"public" estão disponíveis e podem ser acessados por outras classes que derivam da mesma classe.
Para ilustrar essa ideia, consideremos as declarações das classes "Fusca" e "BrasiliaAmarela", que
estão localizadas em diferentes pacotes: "garagem" e "garagemdovizinho", respectivamente. Ambas
essas classes são subtipos da classe base chamada "Carro".
Isso significa que, mesmo estando em pacotes distintos, as classes "Fusca" e
"BrasiliaAmarela" podem acessar os membros públicos da classe "Carro". O modificador de acesso
"public" permite uma visibilidade ampla, garantindo que as classes derivadas tenham a capacidade
de utilizar esses membros sem restrições.
Essa abordagem é fundamental para promover a reutilização de código e a extensibilidade
das classes em Java. Ao herdar uma classe base, as classes derivadas podem herdar e usar os
membros públicos da classe base, simplificando o desenvolvimento e a manutenção do código,
mesmo quando as classes estão localizadas em diferentes pacotes. Essa flexibilidade é um dos
princípios fundamentais da programação orientada a objetos em Java e permite criar hierarquias de
classes eficientes e organizadas. Portanto, a capacidade de acesso aos membros públicos em classes
derivadas contribui significativamente para a modularidade e a flexibilidade do sistema de classes em
Java. Ambas as classes são derivadas da classe Carro:
package garagem;
public class Fusca extends Carro {
public Fusca()
{
this.cor = "Branco"; this.marca = "VW"; this.ligar();
this.toString();
}
}
package garagemdovizinho; import garagem.Carro;
public class BrasiliaAmarela extends Carro { public
BrasiliaAmarela() {
this.cor = "Amarelo"; this.marca = "VW"; this.ligar();
this.toString();
}
}
97
Fonte: Elaborado pelo autor (2023).
Protected
Os membros das classes marcados com o modificador de acesso protected serão acessíveis
por classes e interfaces dentro do mesmo pacote e por classes derivadas mesmo que estejam em
pacotes diferentes.
98
INTRODUÇÃO E HISTÓRIA DO JAVA
99
package garagemdovizinho; public class Motor {
public int potencia; protected void darPartida(){}
}
package garagem;
import garagemdovizinho.Motor; public class Carro {
protected String marca; protected String cor; public Motor motor;
A classe Carro não compila e recebemos a mensagem de que o método darPartida() do tipo
Motor não é visível. Um membro marcado com o modificador de acesso protected só é visível para
outras classes e interfaces localizadas dentro do mesmo pacote ou por seus herdeiros. Veremos como
as classes derivadas se comportam com o uso de membros protected a seguir.
Classes derivadas
As classes que herdam de outras classes têm a capacidade de acessar os membros que foram
declarados como "protected" na classe mãe, independentemente do pacote em que essas classes
100
INTRODUÇÃO E HISTÓRIA DO JAVA
estejam localizadas. Vamos examinar a declaração das classes Fusca e BrasiliaAmarela para entender
melhor esse conceito.
Primeiramente, é importante ressaltar que, no contexto das classes Fusca e BrasiliaAmarela,
o método darPartida() da classe Motor não está acessível diretamente pela classe Fusca. Isso significa
que a classe Fusca não pode chamar o método darPartida() diretamente, provavelmente devido a
restrições de acesso impostas pela classe Motor ou por razões de encapsulamento específicas.
No entanto, é fundamental observar que todos os membros das classes Carro e Motor são
acessíveis pela classe BrasiliaAmarela. Isso implica que a classe BrasiliaAmarela pode interagir com
todos os membros (variáveis e métodos) que foram declarados como "protected" nas classes Carro e
Motor, independentemente do pacote em que essas classes estejam localizadas. Esse acesso
ampliado proporciona à classe BrasiliaAmarela uma maior flexibilidade e capacidade de utilizar e
modificar os membros herdados dessas classes.
Em resumo, as classes derivadas, como a classe BrasiliaAmarela, têm o privilégio de acessar
os membros marcados como "protected" na classe mãe, permitindo uma extensão eficaz das
funcionalidades e o uso de recursos herdados. No entanto, é importante observar que restrições de
acesso específicas podem ser aplicadas, como no caso do método darPartida() da classe Motor, que
não é acessível diretamente pela classe Fusca.
101
package garagem;
public class Fusca extends Carro {
public Fusca()
{
this.cor = "Branco"; this.marca = "VW"; this.ligar();
this.motor.darPartida(); // O método darPartida() do tipo Motor não é visíve this.motor.potencia = 100;
this.toString();
}
}
Padrão
102
INTRODUÇÃO E HISTÓRIA DO JAVA
pacote só podem ser acessados por outras classes ou interfaces que também estão definidas no
mesmo pacote.
Em outras palavras, quando você cria uma classe e declara variáveis, métodos ou outros
membros nessa classe sem especificar um modificador de acesso como "public", "private" ou
"protected", esses membros herdam o modificador de acesso padrão, que é o acesso de pacote.
A principal característica desse modificador é que ele limita o acesso aos membros da classe
apenas ao escopo do mesmo pacote em que a classe está contida. Isso significa que outras classes
fora do pacote não podem acessar diretamente esses membros, a menos que herdem essa classe ou
tenham alguma relação de herança com ela.
Portanto, ao utilizar o modificador de acesso padrão ou "acessibilidade de pacote", você está
restrito a permitir que apenas as classes dentro do mesmo pacote acessem esses membros,
proporcionando um nível de encapsulamento e controle sobre a visibilidade e o uso desses
elementos dentro do contexto específico do pacote em questão.
A definição da classe Carro e Motor dentro do pacote garagem com alguns dos seus
elementos com a acessibilidade de pacote:
package garagem; public class Motor {
public int potencia; void darPartida(){}
}
103
Fonte: Elaborado pelo autor (2023).
Como as duas classes estão dentro do mesmo pacote, o método darPartida(), mesmo tendo a
acessibilidade de pacote, continua sendo acessível pela classe Carro.
Ao colocar a classe Motor dentro do pacote garagemdovizinho, a classe Carro não consegue
mais ter o acesso ao método darPartida() da classe Motor.
Por exemplo:
package garagemdovizinho;
public class Motor { public int potencia; void darPartida(){}
}
package garagem;
import garagemdovizinho.Motor; public class Carro {
String marca;
String cor;
public Motor motor;
void ligar()
{
this.motor.darPartida();
// O método darPartida() do tipo Motor não é visível.
}
public String toString()
{
return marca + " " + cor + " " + motor.potencia;
}
}
Perdemos o acesso ao método darPartida() da classe Motor.
104
INTRODUÇÃO E HISTÓRIA DO JAVA
Classes derivadas
Com classes derivadas a regra continua a mesma, só as classes derivadas declaradas dentro
do mesmo pacote têm acesso aos membros com acessibilidade de pacote da classe mãe.
Por exemplo:
package garagem;
public class Fusca extends Carro {
public Fusca()
{
this.cor = "Branco"; this.marca = "VW"; this.ligar();
this.motor.darPartida(); // O método darPartida() do tipo Motor não é visíve
this.motor.potencia = 100;
this.toString();
}
}
Apesar da variável de classe motor do tipo Motor estar visível, o método darPartida() não
está.
105
this.marca = "VW"; // O campo Carro.marca não é visível. this.ligar(); // O método ligar() do
tipo Carro não é visível. this.motor.darPartida();
this.motor.potencia = 100; this.toString();
}
}
Apesar das classes Fusca e BrasiliaAmarela terem acesso à classe Motor por herdarem da
classe Carro, a acessibilidade aos membros da classe Carro por essas duas classes filhas é diferente. A
classe Fusca só tem acesso à variável de classe potencia, enquanto a classe BrasiliaAmarela tem
acesso à variável de classe potencia e ao método darPartida().
O modificador de acesso padrão é mais restritivo do que o modificador public e protected,
mas ele é menos restritivo do que o modificador private.
106
INTRODUÇÃO E HISTÓRIA DO JAVA
Private
107
public String toString()
{
return marca + " " + cor + " " + motor.potencia;
}
}
package garagemdovizinho; public class Motor {
public int potencia; private void darPartida(){}
}
package garagem;
public class Fusca extends Carro { public Fusca()
{
this.cor = "Branco"; // O campo Carro.cor não é visível. this.marca = "VW"; // O campo
Carro.marca não é visível. this.ligar(); // O método ligar() do tipo Carro não é visível.
this.motor.darPartida();
// O método darPartida() do tipo Motor não é visível. this.motor.potencia = 100;
this.toString();
}
}
public BrasiliaAmarela() {
this.cor = "Branco"; // O campo Carro.cor não é visível. this.marca = "VW"; // O campo
Carro.marca não é visível. this.ligar(); // O método ligar() do tipo Carro não é visível.
this.motor.darPartida();
// O método darPartida() do tipo Motor não é visível. this.motor.potencia = 100;
this.toString();
}
}
Nota-se que todo elemento marcado com o modificador private não é acessível por outras
classes.
108
INTRODUÇÃO E HISTÓRIA DO JAVA
109
Disponível em: <https://tinyurl.com/24f2xbua>. Acesso em 11 set. 2023.
110
INTRODUÇÃO E HISTÓRIA DO JAVA
7- Em que cenário um atributo ou método pode ser acessado por qualquer classe em Java?
a) Quando declarado como public.
b) Quando declarado como private.
c) Quando declarado como protected.
d) Quando declarado como default.
10- O que acontece quando um membro de uma classe é declarado como private?
a) Ele só pode ser acessado por métodos da mesma classe.
b) Ele só pode ser acessado por classes do mesmo pacote.
111
c) Ele pode ser acessado por qualquer classe.
d) Ele pode ser acessado por classes filhas.
erro de forma controlada durante a execução.
D) Uma abordagem para evitar o uso de blocos try e catch no código.
10- Qual é o principal objetivo do uso de streams de caracteres ao trabalhar com leitura e
escrita de dados em Java?
A) Reduzir o tamanho dos arquivos.
B) Melhorar o desempenho das operações.
C) Manipular dados binários de forma eficiente.
D) Trabalhar com dados em formato de texto.
112
INTRODUÇÃO E HISTÓRIA DO JAVA
GUEDES. Gilleanes T. A. UML 2 – Uma abordagem prática. - 1. ed. – Rio de Janeiro: Luiz
Antônio de Moraes Pereira. p.31, p.32, p.33. p.37. 2011.
113