Palavras-chave Java com exemplos

Uma lista completa de palavras-chave Java é coberta com exemplos na esperança de que satisfaçam os requisitos educacionais.

Índice-

Lista de palavras-chave Java

Como resultado das palavras-chave Java , há um conjunto de palavras reservadas que não podem ser usadas como variáveis , métodos, classes ou quaisquer outros identificadores:

Palavras-chave Java Visão geral
abstrato Modificadores sem acesso são implementados para classes e métodos . Não é possível criar objetos a partir de classes abstratas (você precisa herdá-los de outra classe).

Métodos que são abstratos não podem ser usados ​​fora de classes abstratas e não possuem corpos. As subclasses (herdadas de) fornecem o corpo ao método.
afirmar Depurando.
boleano Somente valores verdadeiros e falsos podem ser armazenados neste tipo de dados.
quebrar Sai de um loop ou bloco de comutação.
byte Números inteiros entre -128 e 127 podem ser armazenados como um tipo de dados.
caso Blocos de código em instruções switch são marcados usando-o.
pegar As instruções try geram exceções que são capturadas por essa função.
Caracteres Tipo de dados para armazenar caracteres únicos.
aula As classes são definidas por esta função.
continuar Um loop é continuado para a próxima iteração.
const As constantes são definidas aqui. Inativo – use a função final em seu lugar.
padrão Quando uma instrução switch é usada, ela especifica o bloco de código padrão a ser executado.
fazer Os loops do-while são criados usando a palavra-chave do em conjunto com a palavra-chave while.
dobro Números inteiros entre 1,7e'308 e 1,7e+308 são armazenados como este tipo de dados.
outro As palavras-chave Java podem ser usadas em instruções condicionais.
enumerar Declara um tipo enumerado que não pode ser alterado.
exporta Um pacote com um módulo é exportado. Um dos novos recursos do Java 9.
estende Herda uma classe de outra classe (estende a classe).
final Modificadores sem acesso são usados ​​para evitar que classes, atributos e métodos sejam alterados (isto é, herdados ou substituídos).
finalmente Palavras-chave Java são usadas junto com exceções para definir um bloco de código que é executado independentemente de haver uma exceção ou não.
flutuador Este tipo de dados pode armazenar números inteiros de 3,4e-038 a 3,4e+038.
para Gera um loop for .
Vá para Não há nenhuma função para este item e ele não é usado.
se Declara uma condição If .
implementos Fornece uma interface para implementação.
importar Importa um pacote, classe ou interface usando a palavra-chave Java import
instancia de Especifica se um objeto é ou não uma instância de uma classe específica ou uma interface.
int Este é um tipo de dados capaz de armazenar números inteiros de -2147483648 a 2147483647.
interface O objetivo desse método é declarar um tipo especial de classe que consiste apenas em métodos abstratos.
longo Uma matriz de números inteiros variando de -9223372036854775808 a 9223372036854775808.
módulo Defina um módulo. O módulo de palavras-chave Java foi atualizado no Java 9.
nativo Especifica que um método não é implementado no mesmo arquivo de origem Java (mas é implementado em outro idioma).
novo Cria novos objetos.
pacote Cria um pacote.
privado Os modificadores de acesso são usados ​​para atributos, métodos e construtores, limitando sua acessibilidade apenas à classe declarada.
protegido Garante que atributos , métodos e construtores sejam acessíveis apenas dentro de um pacote e subclasse.
público Um modificador de acesso usado para classes , atributos , métodos e construtores , tornando-os acessíveis por qualquer outra classe.
requer Especifica as bibliotecas necessárias dentro de um módulo. Novidade no Java 9.
retornar Concluiu a execução de um método e pode ser usado para retornar um valor de um método em palavras-chave Java .
curto Um tipo de dados que pode armazenar números inteiros de -32768 a 32767.
estático Um modificador sem acesso usado para métodos e atributos. Métodos/atributos estáticos podem ser acessados ​​sem criar um objeto de uma classe.
strictfp Restrinja a precisão e o arredondamento dos cálculos de ponto flutuante.
super Refere-se a objetos da superclasse (pai).
trocar Seleciona um dos muitos blocos de código a serem executados.
sincronizado Um modificador de não acesso, que especifica que os métodos só podem ser acessados ​​por um thread por vez.
esse Refere-se ao objeto atual em um método ou construtor.
lançar Cria um erro personalizado nas palavras-chave Java .
lances Indica quais exceções podem ser lançadas por um método.
transitório Um modificador sem acesso , que especifica que um atributo não faz parte do estado persistente de um objeto.
tentar Cria uma instrução try-catch.
var Java 10 apresenta novos recursos – define uma variável .
vazio Isso declara que um método não deve ter um valor de retorno.
volátil Os atributos não são armazenados em cache localmente, mas são sempre lidos da memória principal.
enquanto Ele configura um loop while.

Palavra-chave abstrata em Java

Em palavras-chave Java , a palavra-chave abstrata atua como um modificador de não acesso para classes e métodos .

Classe abstrata: Classes abstratas não podem gerar objetos (devem herdar de outra classe para serem acessadas).
Método Abstrato: Métodos abstratos só podem ser usados ​​em classes abstratas. Esses métodos não contêm um corpo. O corpo é fornecido por subclasses (herdadas da classe Abstract).

Ao falar de palavras-chave abstratas em Java , esses métodos pertencem à classe abstrata e seus corpos estão vazios.

Em vez disso, as subclasses fornecem o corpo a ela.

O exemplo a seguir mostra o uso de Abstract Method e Abstract Class de forma mais eficiente:

Java Keyword Abstract Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// Code from filename: Main.java
// abstract class is initiated below
abstract class Main {
public String studnet_Name = "Mike";
public int student_Age = 21;
public abstract void admission_Eligibility_Check(); // abstract method is declared here
}
// Subclass (inherit from Main)
class Student_Detail extends Main {
public int Convocation_Year = 2005;
public void student_Character() { // the body of the abstract method is provided here
System.out.println("Mike as a student is passionate,hardworking and highly motivated. He has volunteered in many projects in the Last School he attended.");
}
public void admission_Eligibility_Check(){
System.out.println("Student is Eligible to be a part of this university ");
}
}
// End code from filename: Main.java
// Code from filename: First.java
public class First {
public static void main(String[] args) {
Student_Detail mrx=new Student_Detail();
System.out.println("Name of Student: " + mrx.studnet_Name);
System.out.println("Age of Student: " + mrx.student_Age);
System.out.println("Graduation Year: " + mrx.Convocation_Year);
mrx.admission_Eligibility_Check(); // An abstract is called here
mrx.student_Character();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma, para aprender sobre classes abstratas com mais clareza, consulte o exemplo fornecido:

Java Keyword Abstract Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// Code from filename: Main.java
// abstract class is initiated below
abstract class Main {
public int number1=67;
public int number2=12;
public abstract void product_Numbers(); // abstract method is declared here
}
// Subclass (inherit from Main)
class Mathematical_Operation extends Main {
public int mrx=20;
public int ample=50;
public void product_Numbers(){ // the body of the abstract method is provided here
System.out.println(number1+" x "+number2+" = "+(number1*number2));
}
public void add_Numbers() {
System.out.println(mrx+" + "+ample+" = "+(ample+mrx));
}
}
// End code from filename: Main.java
// Code from filename: First.java
public class First {
public static void main(String[] args) {
Mathematical_Operation mrx_obj=new Mathematical_Operation();
System.out.println("\nUsing Abstract Product method: \n");
System.out.println("Value of Number 1: "+mrx_obj.number1);
System.out.println("Value of Number 2: "+mrx_obj.number2);
mrx_obj.product_Numbers();
System.out.println("\nUsing Addition Method from the class Mathematical_Operations: \n");
System.out.println("Value of Number 1: "+mrx_obj.mrx);
System.out.println("Value of Number 2: "+mrx_obj.ample);
mrx_obj.add_Numbers();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave booleana em Java

A palavra-chave Java Boolean denota um tipo de dados que pode receber apenas 2 tipos de valores true ou false .

Normalmente, os valores booleanos são utilizados para condições de teste.

Tenha em mente que quando se trata de Java Keyword Boolean , o tipo de dados boolean tem valores true ou false.

O código fornecido mostra o uso de variáveis ​​booleanas :

Java Keyword Boolean Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Main {
public static void main(String[] args) {
boolean isItFunLearningJava=true;
boolean isJavaDifficultToUnderstand=false;
System.out.println("Is it Fun to Learn Java ? ");
System.out.println("Answer: "+isItFunLearningJava);
System.out.println("\nIs Java Difficult to Understand ? ");
System.out.println("Answer: "+isJavaDifficultToUnderstand);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O programa a seguir mostra as opiniões das pessoas sobre a América. As respostas para suas respostas são dadas, criando as variáveis ​​booleanas usando a palavra-chave boolean:

Java Keyword Boolean Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Main {
public static void main(String[] args) {
boolean isAmericaTheMostDesiredPlaceToLive=true;
boolean areAmericansArrogant=false;
System.out.println("Is American The Most Desired place to live in? ");
System.out.println("Answer: "+isAmericaTheMostDesiredPlaceToLive);
System.out.println("\nSome people term American citizens as arrogant. Is this true? ");
System.out.println("Answer: "+areAmericansArrogant);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Quebrar palavra-chave em Java

Como estamos falando sobre a palavra-chave Java break , estamos nos referindo à palavra-chave que é usada para sair de um loop como um loop for , while loop ou switch block.

Quando o valor de mrx for igual a 7, o loop deve ser encerrado da seguinte forma:

Java Keyword Break Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Main {
public static void main(String[] args) {
for(int mrx=1;mrx <=100;mrx++){
if(mrx==7){
break;
}
System.out.println(mrx);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Embora o loop receba 100 ciclos, mas por causa da palavra-chave break, ele interrompe a iteração quando mrx se torna 7.

Da mesma forma, a palavra-chave break também pode ser usada ao percorrer uma matriz de strings:

Java Keyword Break Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class Main {
public static void main(String[] args) {
String programming_Languages[]= {
"1. Javascript\n",
"2. Python\n",
"3. Go\n",
"4. Java\n",
"5. Kotlin\n" ,
"6. PHP\n" ,
"7. C#\n" ,
"8. Swift\n" ,
"9. R\n" ,
"10. Ruby\n" ,
"11. C and C,,\n" ,
"12. Matlab\n" ,
"13. TypeScript\n" ,
"14. Scala\n" ,
"15. SQL\n" ,
"16. HTML\n" ,
"17. CSS\n" ,
"18. NoSQL\n" ,
"19. Rust\n" ,
"20. Perl" };
for(int ample=0;ample<=19;ample++){
if (ample==8){
break;
}
System.out.println(programming_Languages[ample]);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

No exemplo acima, apesar do array conter 20 elementos, mas devido à existência da palavra-chave break, ele não imprimiu mais nada ao atingir o número de índice (8) do Array.

Também podemos usar a palavra-chave break em um loop while.

O loop while é encerrado quando o valor de mrx torna-se 9:

Java Keyword Break Example: 3 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
public static void main(String[] args) {
int mrx=1;
while(mrx <= 200){
System.out.println(mrx);
mrx++;
if(mrx==9){
break;
}
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma, a palavra-chave break em Java também pode ser usada ao percorrer uma matriz .

Como no exemplo dado de 10 times, apenas 4 nomes de times são impressos, pois a palavra-chave break quebra o loop while quando o índice (amplo) atinge 4 (quinto elemento da matriz american_Football_Club_Teams )

Java Keyword Break Example: 4 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Main {
public static void main(String[] args) {
String american_Football_Club_Teams[]={"Baltimore Ravens","Buffalo Bills","Cincinnati Bengals","Cleveland Browns","Denver Broncos","Houston Texans","Indianapolis Colts","Jacksonville Jaguars","Kansas City Chiefs","Las Vegas Raiders"};
int ample=0;
while(ample < american_Football_Club_Teams.length){
System.out.println(american_Football_Club_Teams[ample]);
ample++;
if(ample==4){
break;
}
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave de byte em Java

Com a palavra-chave byte, você pode armazenar números inteiros entre -128 e 127.

O exemplo fornecido mostra o uso do tipo de dados byte para armazenar um valor de 89 na variável chamada mrx_Number;

Java Keyword Byte Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
public class Main {
public static void main(String[] args) {
byte mrx_Number=89;
System.out.println("Byte Value: "+mrx_Number);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Java Keyword Byte Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
byte ample_Numbers=19;
byte mrx_Numbers=78;
System.out.println(ample_Numbers+ "+" +mrx_Numbers+" = "+(ample_Numbers+mrx_Numbers));
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave do caso em Java

Quando falamos sobre a palavra-chave Java Case , a palavra-chave case rastreia um bloco de código incluído em uma instrução switch .

Os exemplos a seguir mostram o uso da palavra-chave Case :

Case Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class Main {
public static void main(String[] args) {
int american_football_team=6;
switch (american_football_team){
case 1:
System.out.println("Arizona Cardinals");
break;
case 2:
System.out.println("Atlanta Falcons");
break;
case 3:
System.out.println("Baltimore Ravens");
break;
case 4:
System.out.println("Buffalo Bills");
break;
case 5:
System.out.println("Chicago Bears");
break;
case 6:
System.out.println("Carolina Panthers");
break;
case 7:
System.out.println("Cleveland Browns");
break;
case 8:
System.out.println("Cincinnati Bengals");
break;
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Case Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Main {
public static void main(String[] args) {
char mrx_vowels='I' ;
switch (mrx_vowels){
case 'A':
System.out.println("This is a vowel A");
break;
case 'E':
System.out.println("This is a vowel E");
break;
case 'I':
System.out.println("This is a vowel I");
break;
case 'O':
System.out.println("This is a vowel O");
break;
case 'U':
System.out.println("This is a vowel U");
break;
case 6:
System.out.println("Carolina Panthers");
break;
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Capturar palavras-chave em Java

No caso da palavra-chave Catch em Java, a palavra-chave catch captura as exceções produzidas pelas instruções try .

Em caso de erro no bloco try, a instrução catch executa um bloco de código.

Sempre que ocorrer um erro, você deve usar try-catch para capturar o erro e executar algum código para lidar com ele da seguinte maneira:

Catch Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Main {
public static void main(String[] args) {
try {
String [] billionaires = {"Elon Musk","Bernard Arnault","Jeff Bezos","Gautam Adani","Bill Gates"};
System.out.println(billionaires[5]);
} catch (Exception e) {
System.out.println("There is no such index number in the billionaires array, enter the correct index number");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Catch Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Main {
public static void main(String[] args) {
int [] prime={2,3,5,7,11,13,17,19,21,23,27};
try {
int mrx;
for(mrx=0;mrx<=13;mrx++){
System.out.println("Number "+mrx+" = "+prime[mrx]);
}
} catch (Exception e) {
System.out.println("All the elements of the array are printed successfully and the array does not any element at index number 11 or more ");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave Char em Java

Cada caractere é armazenado no tipo de dados char.

Você deve colocar os valores char entre aspas simples, como 'B' ou 'e'.

Char Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Main {
public static void main(String[] args) {
char mrx_alpha='K';
System.out.println("The given variable is : "+mrx_alpha);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Char Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class Main {
public static void main(String[] args) {
char mrx_alpha1='M';
char ample_alpha2='r';
char mrx_alpha3='E';
char ample_alpha4='x';
char mrx_alpha5='a';
char ample_alpha6='m';
char mrx_alpha7='p';
char ample_alpha8='l';
char mrx_alpha9='e';
char ample_alpha10='s';
System.out.println("\nYou are Learning Char Keyword from: \n");
System.out.println(mrx_alpha1);
System.out.println(ample_alpha2+"\n");
System.out.println(mrx_alpha3);
System.out.println(ample_alpha4);
System.out.println(mrx_alpha5);
System.out.println(ample_alpha6);
System.out.println(mrx_alpha7);
System.out.println(ample_alpha8);
System.out.println(mrx_alpha9);
System.out.println(ample_alpha10);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave de classe em Java

Quando se trata de Java Keyword Classes , a palavra-chave class gera uma classe.

Java requer que cada linha de código esteja dentro de uma classe.

Sempre deve haver uma primeira letra maiúscula no nome da classe e o nome do arquivo Java deve ser igual ao nome da classe.

O construtor de um objeto é análogo a uma classe.

Abaixo está um exemplo de como pode ser implementado para declarar um objeto:

Class Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
public class MyFirstClass {
public static void main(String[] args) {
System.out.println("Greetings ! We are learning here how to create a class in Java");
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma, é possível criar quantas classes quisermos, atribuindo-lhes nomes diferentes:

Class Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
public class MyAnotherClass {
public static void main(String[] args) {
System.out.println("In this way multiple classes can be created using distinct names");
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

No exemplo abaixo, declaramos um objeto da classe MyFirstClass e o nomeamos “ mrx_Obj ” que imprime o valor de ample ( String ):

Class Keyword Example: 3 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MyFirstClass {
String ample="Mr Examples";
public static void main(String[] args) {
MyFirstClass mrx_Obj=new MyFirstClass();
System.out.println("Hey ! You are currently on : "+mrx_Obj.ample);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Class Keyword Example: 4 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MyFirstClass {
String ample="Java";
String mrx="Class";
String txt="Keyword";
public static void main(String[] args) {
MyFirstClass mrx_Obj=new MyFirstClass();
System.out.println("You are learning about "+mrx_Obj.ample+" "+mrx_Obj.mrx+" "+mrx_Obj.txt);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Continuar palavra-chave em Java

No caso da palavra-chave continue , ao usar um loop for (ou um loop while ), a palavra-chave continue encerra a iteração atual e a próxima iteração continua.

No caso de mrx = 2, pule esta iteração e continue com a próxima:

Continue Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MyFirstClass {
public static void main(String[] args) {
for(int mrx=1;mrx<=20;mrx++){
if (mrx ==2){
continue;
}
System.out.println(mrx);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Continue Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class MyFirstClass {
// Currency Codes
// USD = United States Dollar
// EUR = Euro
// AUD = Australian Dollar
// CAD = Canadian Dollar
// DKK = Danish Krone
// MVR = Maldivian Ruffian
// CNY = Chinese Yen
public static void main(String[] args) {
String currency_Codes[]={"USD","EUR","AUD","CAD","DKK","MVR","CNY"};
for(int mrx=0;mrx<=6;mrx++){
if (mrx ==3){
continue;
}
System.out.println(currency_Codes[mrx]);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Usando um loop while, também podemos implementar a palavra-chave continue :

Continue Keyword Example: 3 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MyFirstClass {
public static void main(String[] args) {
int mrx=1;
while (mrx <= 15){
if (mrx==4){
mrx++;
continue;
}
System.out.println(mrx);
mrx++;
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Após a execução do loop while, você notará que todos os números são impressos, exceto 4, que satisfaz o funcionamento da palavra-chave continue.

Da mesma forma, também podemos usar a palavra-chave continue ao percorrer uma matriz chamada: popular_Destination_Of_America:

Continue Keyword Example: 4 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MyFirstClass {
public static void main(String[] args) {
String popular_Destinations_Of_America[]={"New York","Chicago","Los Angeles","Washington D.C","San Francisco"};
int ample=0;
while (ample <= 4){
if(ample==2){
ample++;
continue;
}
System.out.println(popular_Destinations_Of_America[ample]);
ample++;
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave padrão em Java

Quando se trata da palavra-chave default em Java, a palavra-chave default é o bloco de código padrão em uma instrução switch .

No caso de um switch não corresponder ao caso, a palavra-chave padrão especifica algum código a ser executado.

Além disso: No caso da palavra-chave padrão ser usada como a última instrução em um bloco switch , você não precisa colocar uma palavra-chave break nela.

Aqui usamos 5 casos da instrução switch, portanto, ao inserir 6 como o valor do caso, o código padrão é executado:

Default Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class MyFirstClass {
public static void main(String[] args) {
int america_Famous_Foods=6;
switch (america_Famous_Foods){
case 1:
System.out.println("Fajitas");
break;
case 2:
System.out.println("Jerky");
break;
case 3:
System.out.println("Twinkies");
break;
case 4:
System.out.println("Pot roast");
break;
case 5:
System.out.println("Cobb salad");
break;
default:
System.out.println("There is no dish name at "+america_Famous_Foods+" hence they default keyword statement is executed");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Correspondentemente, o exemplo dado indica se um número é par ou ímpar:

Default Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class MyFirstClass {
public static void main(String[] args) {
int case_Value=11;
int mrx_Result=case_Value%2;
switch (mrx_Result){
case 0:
System.out.println(case_Value+" is an Even Number");
break;
default:
System.out.println(case_Value+" is an Odd Number");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Como 11 % 2 = 1 (não 0), a instrução padrão é executada.

Fazer palavras-chave em Java

Quando se trata da palavra-chave Java Do , a palavra-chave do é usada junto com a palavra-chave while para gerar um loop do-while .

Em um loop while, um bloco de código é executado repetidamente até que uma condição especificada seja alcançada.

Um loop Do/while é uma extensão do loop while.

Neste loop, o bloco de código será executado uma vez, antes de verificar se a condição é verdadeira , e então o loop será repetido se a condição for verdadeira.

Lembre-se: Certifique-se de que a variável de condição seja aumentada, caso contrário, o loop nunca terminará.

Apesar da condição ser falsa, o loop a seguir sempre será executado pelo menos uma vez, pois o bloco de código é executado antes da avaliação da condição:

Do Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Main{
public static void main(String[] args) {
int ample=1;
do{
System.out.println(ample);
ample++;
}
while (ample<=4);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Isso imprime todos os números naturais de 1 a 4, pois a condição é verificada após a impressão do código.

O exemplo dado mostra o uso de Do While Loop ao percorrer os elementos da matriz:

Do Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Main{
public static void main(String[] args) {
String it_Companies_America[]={"Hyperlink InfoSystem","Apex Systems","Kin+Carta","Cognizant","Apexon"};
int mrx=0;
do{
System.out.println(it_Companies_America[mrx]);
mrx++;
}
while (mrx<=4);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Como resultado, todos os elementos da matriz são impressos devido à impressão anterior dos elementos do que a condição.

Palavra-chave dupla em Java

A palavra-chave double gera um tipo de dados double capaz de conter números decimais dentro de um intervalo de 1,7 x 10^-308 a 1,7 x 10^308.

É importante ter em mente que ao especificar um valor para o tipo de dado double , ele deve ser sufixado com a letra “d”.

O exemplo a seguir mostra como imprimir o valor de uma variável dupla (mrx):

Java Keyword Double Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
public class Main{
public static void main(String[] args) {
double mrx=52.3243245423412d;
System.out.println("Value of Double variable mrx= "+mrx);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Aqui obtemos o produto de duas variáveis ​​de tipo de dados double (mrx e ample):

Java Keyword Double Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Main{
public static void main(String[] args) {
double mrx=16.35423452523525423d;
double ample=76.233212312312321d;
System.out.println("Product of two double values (Ample and mrx)= "+mrx+" x "+ample);
System.out.println("Result: "+(mrx*ample));
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Outra palavra-chave em Java

A palavra-chave else em Java é usada em conjunto com uma instrução if para especificar um bloco de código a ser executado se a condição especificada na instrução if for falsa .

Além da instrução else, Java também oferece outras instruções condicionais, como:

  1. A instrução if , que é usada para especificar um bloco de código a ser executado se uma condição especificada for verdadeira.
  2. A instrução else em Java é usada para especificar um bloco de código a ser executado se a condição especificada na instrução if correspondente for falsa. Ele permite a execução de um bloco de código alternativo caso a condição avaliada na instrução if não seja atendida.
  3. A instrução else if , que é usada para especificar uma nova condição para testar se a primeira condição é falsa.
  4. A instrução switch , que é usada para especificar vários blocos alternativos de código a serem executados com base no valor de uma expressão.

Podemos usar a instrução else if e atribuí-la a uma nova condição de teste caso a condição if seja falsa .

Usando instruções if else , podemos projetar um programa para calcular valores específicos de descontos em diferentes faixas de fatura, conforme mostrado no exemplo abaixo:

Else Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Main{
public static void main(String[] args) {
float total_Bill_In_Dollars=76;
float discount;
float new_Bill;
if (total_Bill_In_Dollars >= 100) {
discount = (float) (total_Bill_In_Dollars * 10 / 100);
System.out.println("New Bill after 10% Discount: " + total_Bill_In_Dollars+" $" + " – " + discount+" $" + " = " + (total_Bill_In_Dollars – discount)+"$");
}
else if (total_Bill_In_Dollars>= 50) {
discount=(float)(total_Bill_In_Dollars*5/100);
System.out.println("New Bill after 5% Discount: "+total_Bill_In_Dollars+" $"+" – "+discount+" $"+" = "+(total_Bill_In_Dollars-discount)+" $");
}
else {
System.out.println("No Discount is Available Total Bill is: "+total_Bill_In_Dollars+" $");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma, o programa a seguir considera o intervalo de tempo como uma string de entrada e exibe uma mensagem correspondente:

Else Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Main{
public static void main(String[] args) {
// Time ranges
// 1) Morning
// 2) AfterNoon
// 3) Evening
// 4) Night
String time_Range="Evening";
if(time_Range=="Morning"){
System.out.println("Good Morning Dear User !! Have a good day ");
}
else if(time_Range=="AfterNoon"){
System.out.println("Hello Dear! Its time to eat something for lunch");
}
else if(time_Range=="Evening"){
System.out.println("The cold winds and the pleasant weather !! how good could these evening be !");
}
else{
System.out.println("GoodNight Dear User ! Its time to sleep ! Have good dreams");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave Enum em Java

Ao discutir a palavra-chave enum do Java , a palavra-chave enum declara um tipo enum (imutável).

Um enum é uma “classe” distinta que simboliza uma coleção de constantes (variáveis ​​imutáveis, semelhantes às variáveis ​​finais).

Use a palavra-chave enum para criar grupos de constantes, separe-os com vírgulas e certifique-se de que estejam todos em letras maiúsculas .

O exemplo fornecido mostra a criação de uma enumeração chamada genders com valores não modificáveis:

Enum Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Main {
public static void main(String[] args) {
enum mrx_genders{
MALE,
FEMALE,
TRANSGENDER
}
mrx_genders ample=mrx_genders.MALE;
System.out.println(ample);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Podemos também criar a enumeração das posições do campo de futebol conforme abaixo:

Enum Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
public static void main(String[] args) {
enum mrx_Football_Positions{
FORWARD,
MID_FIELD,
DEFENSE,
GOAL_KEEPING
}
mrx_Football_Positions ample=mrx_Football_Positions.DEFENSE;
System.out.println("Position: "+ample);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Enum vs Classes

Enums podem ter atributos e métodos assim como as classes. As constantes de enumeração são static , public e final (ou seja, não podem ser alteradas e não podem ser substituídas), esta é a única propriedade que as torna exclusivas das classes.

Como os enums são incapazes de se estender de outras classes, portanto, a criação de objetos é impossível nelas, pelo contrário, eles podem implementar interfaces para executar as respectivas operações.

Você pode implementar enums enquanto declara valores que permanecerão os mesmos para sempre, como dias do mês, dias, cores, baralho de cartas, etc.

Estende a palavra-chave em Java

Quando se trata de Ref Extends, a palavra-chave extends expande uma classe (que indica que uma classe é herdada de outra classe).

Um atributo ou método pode ser herdado de uma classe para outra em Java. Como resultado, podemos classificar o “conceito de herança” em dois tipos:

Uma subclasse (também conhecida como classe filha) – uma classe que foi herdada de outra classe

Uma superclasse (também conhecida como classe pai) – esta é a classe da qual estamos herdando

A palavra-chave extends é usada quando você deseja herdar de uma classe.

O exemplo dado mostra como herdar métodos e atributos para uma classe filha de uma classe pai:

Extends Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Parent_Ample{
int parent_mrx1=2;
int parent_mrx2=6;
int product_mrx=(parent_mrx1*parent_mrx2);
void parent_method(){
System.out.println("This is a (Parent Class / Super Class / Base class) method");
}
}
class Child_Mrx extends Parent_Ample{
public static void main(String[] args) {
Child_Mrx new_object=new Child_Mrx();
System.out.println("The Product of "+new_object.parent_mrx1+" and "+new_object.parent_mrx2+" is = "+new_object.parent_mrx1+" x "+ new_object.parent_mrx2+" = "+(new_object.product_mrx));
new_object.parent_method();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O exemplo a seguir mostra o uso de atributos e métodos da classe base usando o objeto da classe derivada:

Extends Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class BloodGroups{
String type1="A";
String type2="B";
String type3="O";
String type4="AB";
void blood_groups_bio(){
System.out.println("Blood types (also known as blood groups) are a classification system for blood,\nbased on the presence or absence of antibodies and antigenic substances\ninherited from an individual and present on the surface of red blood cells (RBCs) on the surface of the cells.");
}
}
class BloodGroup_types extends BloodGroups{
void types_of_blood_groups(){
System.out.println("\nGenerally speaking, there are four main blood types (blood types) – A, B, AB, and O.\nThe genes that your parents pass on to you are responsible for determining your blood group.");
}
public static void main(String[] args) {
BloodGroup_types obj=new BloodGroup_types();
obj.blood_groups_bio();
obj.types_of_blood_groups();
System.out.println("\nType 1: "+obj.type1);
System.out.println("Type 2: "+obj.type2);
System.out.println("Type 3: "+obj.type4);
System.out.println("Type 4: "+obj.type3);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave final em Java

Quando se trata de palavra-chave final em Java , não é possível herdar ou substituir uma classe , atributo ou método usando esse modificador sem acesso.

Uma variável que sempre armazena o mesmo valor deve ser declarada com a palavra-chave final , como a variável PI (3.14159).

A palavra-chave final também é chamada de “modificador”.

Para evitar que uma variável seja substituída ou modificada, defina-a para o estado final :

Java Keyword Final Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
public static void main(String[] args) {
final String united_States_President ="Joe Biden";
System.out.println(united_States_President+" is the president of United States Since January 20, 2021");
united_States_President="Donald J. Trump";
System.out.println("New President of United States is: "+united_States_President);
// Hence the value of the final keyword can not be modified hence this code generates as error
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

exemplo final de palavra-chave java

O programa abaixo mostra a modificação de uma variável que foi tornada constante usando a palavra-chave final, portanto, ao executar, será gerado um erro:

Java Keyword Final Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
public static void main(String[] args) {
final int hours_a_day=24;
System.out.println("There are "+hours_a_day+" hours a day");
hours_a_day=25;
System.out.println("We changed the fixed number of hours from 24 to "+hours_a_day);
// In this case, it is not able to modify the value of the final keyword, which leads to this code generating an error.
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Finalmente palavra-chave em Java

A palavra-chave finalmente executa o código independentemente de haver uma exceção (usada em instruções try-catch).

Independentemente do resultado, eles são responsáveis ​​por executar o código após o try-catch.

Java Keyword Finally Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.io.IOException;
public class Main {
public static void main(String[] args) {
String united_States_Landmarks[]={"Statue of Liberty","Golden Gate Bridge","Mount Rushmore National Memorial","Empire State Building","Lincoln Memorial","The Gateway Arch","Space Needle"};
try {
System.out.println("Famous Landmarks of United States: \n");
for (String mrx : united_States_Landmarks) {
System.out.println(mrx);
}
}
catch (Exception e){
System.out.println("An error Occurred during code execution");
}
finally {
System.out.println("\nThe try-catch is executed and the rest of the code can be executed from the next line");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O try-catch é executado e o restante do código pode ser executado a partir da próxima linha

O exemplo fornecido mostra a execução do bloco final mesmo se o código gerar um erro na instrução try catch :

Java Keyword Finally Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.io.IOException;
public class Main {
public static void main(String[] args) {
String united_States_Innovations[]={"Transistors","Internet","The hearing aid","Chocolate chip cookies","Kevlar"};
try {
System.out.println("Innovations of United States: \n");
for(int mrx=0;mrx<6;mrx++){
System.out.println(united_States_Innovations[mrx]);
}
}
catch (Exception e){
System.out.println("\nAll indexes upto 4 from the Array are executed, and traversing array further generates an error");
}
finally {
System.out.println("\nAfter executing the try-catch, we can continue with the rest of the code from here.");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Todos os índices até 4 do Array são executados, e percorrer o array gera ainda mais um erro

Depois de executar o try-catch, podemos continuar com o restante do código a partir daqui.

Palavra-chave flutuante em Java

A palavra-chave float usada com uma variável ativa um tipo de dados especial chamado float , que pode armazenar números fracionários que se enquadram no intervalo de 3,4e'038 a 3,4e+038.

É importante observar que você deve terminar o valor com um “f” ou “F”:

Float Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
float java_compiler_version=17.0F;
System.out.println("The Compiler on which you are executing the codes is java "+java_compiler_version);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O seguinte programa mostra a conversão de temperatura de graus centígrados para Fahrenheit :

Float Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("Enter Temperature in Celsius: ");
float celsius=input.nextFloat();
float fahrenheit= ((celsius*9)/5)+32;
System.out.println("Temperature in Fahrenheit is: "+fahrenheit);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Para palavras-chave em Java

Usando a palavra-chave Java For , podemos inicializar um loop for que pode iterar quantas vezes a condição for declarada.

O exemplo a seguir mostra o funcionamento do loop for .

Aqui imprimimos todos os alfabetos da língua inglesa usando seus códigos ASCII :

For Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
for (char ample=65;ample<=90;ample++){
System.out.println(ample);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma , todos os números pares até o limite do usuário podem ser impressos usando o loop for conforme mostrado abaixo:

For Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner mrx_obj=new Scanner(System.in);
System.out.println("Enter Limit of Even Numbers here: ");
int user_Input=mrx_obj.nextInt();
for (int ample=0;ample<=user_Input;ample++){
if(ample % 2==0){
System.out.println(ample);
}
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Do exemplo acima:

  • A primeira instrução define uma variável antes do início do loop (int ample = 0).
  • A condição na instrução 2 é que ample deve ser menor que user_Input para que o loop seja executado. O loop será reiniciado se a condição for verdadeira e terminará se for falsa .
  • A condição if verifica o módulo do número em relação a 2 se mostrar 0, então imprime caso contrário pula a iteração.
  • A instrução 3 aumenta um valor ( ample++ ) cada vez que o bloco de código no loop é executado.

Um loop “ for-each ” também está disponível, que é usado principalmente para percorrer os elementos de uma matriz um por um.

O exemplo a seguir mostra o método de impressão dos nomes das 6 principais marcas dos estados unidos:

For Keyword Example: 3 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Main {
public static void main(String[] args) {
String united_States_Top_6_Brands[]={"Google", "Walmart", "Coca-Cola", "Apple", "Microsoft", "McDonald's"};
System.out.println("The following are 6 Top brands of United States: \n");
for(String mrx:united_States_Top_6_Brands){
System.out.println(mrx);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O exemplo abaixo mostra o método de pegar 5 nomes como uma entrada do usuário e imprimi-los de volta com a ajuda de cada loop:

For Keyword Example: 4 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String names_5[]=new String[5];
System.out.println("\nEnter Names here: ");
for (int mrx = 0; mrx < 5; mrx++) {
names_5[mrx]=input.next();
}
System.out.println("\nNames You entered :\n");
for(String name:names_5){
System.out.println(name);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Se palavra-chave em Java

Quando se trata da palavra-chave Java If , a instrução if indica que um bloco de código Java será executado se uma determinada condição for atendida.

As seguintes instruções condicionais estão disponíveis em Java:

  1. Se uma condição for atendida, use if para executar um bloco de código.
  2. No caso de uma condição falsa , else é usado para especificar um bloco de código a ser executado.
  3. Quando a primeira condição não for true , especifique uma condição else if para testar.
  4. Os switches podem ser usados ​​para especificar muitos blocos de execução alternativos.

Aqui usamos o método string .equals() para comparar se duas strings são exatamente semelhantes entre si ou não:

Java Keyword If Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("Enter Word1: ");
String mrx_text1=input.next();
System.out.println("Enter Word2: ");
String mrx_text2=input.next();
if( mrx_text1.equals(mrx_text2)){
System.out.println("\n Exact Match");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Correspondentemente , o seguinte programa recebe uma frase e uma palavra como entrada do usuário e mostra se a palavra faz parte da frase ou não:

Java Keyword If Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("Enter Sentence here: ");
String mrx_sentence=input.nextLine();
System.out.println("Enter Word to match: ");
String mrx_text2=input.next();
if (mrx_sentence.contains(mrx_text2)){
System.out.println("The Sentence contains the word: "+mrx_text2);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Variáveis ​​de teste com a instrução if :

O programa a seguir mostra a saída somente se o mrx for maior que o amplo :

Java Keyword If Example: 3 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Scanner;
import java.math.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter Number 1 here: ");
int mrx = input.nextInt();
System.out.println("Enter Number 2 here: ");
int ample = input.nextInt();
if (Math.max(mrx, ample) == mrx) {
System.out.println("Mrx: " + mrx + " is greater than Ample: " + ample);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma , se ample for maior que mrx, obtemos a saída, caso contrário, nada será impresso:

Java Keyword If Example: 4 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.Scanner;
import java.math.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter Number 1 here: ");
int mrx = input.nextInt();
System.out.println("Enter Number 2 here: ");
int ample = input.nextInt();
if (Math.max(mrx, ample) == ample) {
System.out.println("Ample: " + ample+ " is greater than mrx: " +mrx);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Quando a condição é false , uma instrução else é usada para especificar um bloco de código que deve ser executado.

Considerando o exemplo que criamos acima, aqui usamos a instrução else junto com if para obter saídas em ambas as condições (qualquer condição é atendida ou não):

Java Keyword If Example: 5 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.Scanner;
import java.math.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter Number 1 here: ");
int mrx = input.nextInt();
System.out.println("Enter Number 2 here: ");
int ample = input.nextInt();
if (Math.max(mrx, ample) == mrx) {
System.out.println("Mrx: " + mrx + " is greater than Ample: " + ample);
}
else{
System.out.println("ample: " + ample+ " is greater than mrx: " + mrx);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Java Keyword If Example: 6 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.Scanner;
import java.math.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter Number 1 here: ");
int mrx = input.nextInt();
System.out.println("Enter Number 2 here: ");
int ample = input.nextInt();
if (Math.max(mrx, ample) == ample) {
System.out.println("Ample: " + ample+ " is greater than mrx: " +mrx);
}
else {
System.out.println("mrx: " +mrx+ " is greater than ample: " +ample);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

else if declarações podem ser utilizadas para gerar uma nova condição podem ser especificadas se a primeira condição não for verdadeira .

Aqui usamos a condição else if para verificar se os números usados ​​nos exemplos acima são iguais:

Java Keyword If Example: 7 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util.Scanner;
import java.math.*;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter Number 1 here: ");
int mrx = input.nextInt();
System.out.println("Enter Number 2 here: ");
int ample = input.nextInt();
if (ample>mrx) {
System.out.println("Ample: " + ample+ " is greater than mrx: " +mrx);
}
else if(ample==mrx){
System.out.println("Both Numbers "+ample+" and "+mrx+" are equal to each other");
}
else{ System.out.println("Number 1: " +mrx+ " is greater than Number 2: " +ample);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O programa a seguir mostra o mecanismo de funcionamento de uma máquina Atm usando as condições java e o loop while :

Java Keyword If Example: 8 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
final String password="1225";
System.out.println("Enter Password to match: ");
String enter_code=input.next();
if(enter_code.length()==4){
while(enter_code.equals(password)==false) {
System.out.println("Enter Password Again to match: ");
enter_code = input.next();
if(enter_code.equals(password)){
System.out.println("Exact Password Match !!");
break;
}
}
}
else if(enter_code.equals(password)){
System.out.println("Exact Password Match !!");
}
else{
System.out.println("Wrong Input of Digits !!");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave da interface em Java

Ao falar sobre a interface de palavra-chave Java , a palavra-chave interface é usada para definir um tipo especial de classe abstrata que compreende apenas métodos abstratos.

Ao usar uma interface , seus métodos devem ser implementados por uma classe através da palavra-chave ' implementa ', ao invés de ' extends '.

Essa classe é responsável por fornecer o corpo do método fornecido.

O exemplo a seguir mostra o funcionamento da palavra-chave interface :

Interface Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
interface First_Interface{
void method();
}
class First_Interface_Subclass implements First_Interface{
public void method(){
System.out.println("This method is declared in the First_Interface interface");
}
}
public class Main {
public static void main(String[] args) {
First_Interface_Subclass mrx_obj=new First_Interface_Subclass();
mrx_obj.method();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma , seguindo o exemplo abaixo criamos outra interface chamada My_Second_Interface :

Interface Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
interface My_Second_Interface{
void addition();
}
class My_Second_Interface_Subclass implements My_Second_Interface{
public void addition(){
System.out.println("Result : "+(91+412));
}
}
public class Main {
public static void main(String[] args) {
My_Second_Interface_Subclass mrx=new My_Second_Interface_Subclass();
mrx.addition();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma , também podemos criar várias interfaces em java:

Interface Keyword Example: 3 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
interface My_First_Interface{
void method1();
}
interface My_Second_Interface {
void method2();
}
class Interfaces implements My_First_Interface,My_Second_Interface{
public void method1(){
System.out.println("This method is taken from the Interface 1");
}
public void method2() {
System.out.println("This method is taken from the Interface 2");
}
}
public class Main {
public static void main(String[] args) {
Interfaces mrx=new Interfaces();
mrx.method1();
mrx.method2();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Pontos-chave da interface:

  • Não pode ser usado para criar objetos (no exemplo acima não é possível criar um objeto “Mr_Examples” na classe Facts_and_Figures).
  • Um método de interface não contém um corpo – seu corpo é definido na classe “implement”.
  • Você deve substituir todos os métodos de uma interface durante a implementação.
  • Em geral, os métodos de interface são abstratos e públicos por padrão.
  • Por padrão, os atributos de uma interface são public, static e final.
  • Quando se trata de implementações de palavra-chave Java , não há construtor em uma interface (já que uma interface não pode criar objetos).

Usos de interfaces – por que e quando?

Para garantir a segurança , alguns detalhes devem ser ocultados ou exibidos apenas quando forem relevantes para o funcionamento do objeto ( interface ).

Não é possível herdar de mais de uma superclasse em Java (cada classe filha pode ter apenas uma classe pai).

No entanto, com interfaces , isso é possível, pois uma classe pode implementar várias interfaces ao usar a palavra-chave Java Implements.

Observação: ao implementar várias interfaces, coloque uma vírgula entre elas (veja o exemplo acima).

Múltiplas Interfaces:

Interface Keyword Example: 4 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// interface
interface Mr_Examples_1{
public void method1();
}
interface Mr_Examples_2{
public void method2();
}
class Mr_Examples_Main implements Mr_Examples_1,Mr_Examples_2{
public void method1(){
System.out.println("This is body of the method 1 from Interface named Mr_Examples_1");
}
public void method2(){
System.out.println("This is body of the method 2 from Interface named Mr_Examples_2");
}
}
class Mr_Examples{
public static void main(String[] args) {
Mr_Examples_Main obj=new Mr_Examples_Main();
obj.method1();
obj.method2();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Outro exemplo mostra o fenômeno de funcionamento de múltiplas interfaces:

Interface Keyword Example: 5 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// interface
interface Addition{
public void addition(int mrx,int ample);
}
interface Subtraction{
public void subtraction(int mrx,int ample);
}
interface Multiplication{
public void multiplication(int mrx,int ample);
}
interface Division{
public void division(int mrx,int ample);
}
class Mathematical_Operations implements Addition,Subtraction,Multiplication,Division{
public void addition(int mrx,int ample){
System.out.println(mrx+" + "+ample+" = "+(mrx+ample));
}
public void subtraction(int mrx,int ample){
System.out.println(mrx+" – "+ample+" = "+(mrx-ample));
}
public void multiplication(int mrx,int ample){
System.out.println(mrx+" x "+ample+" = "+(mrx*ample));
}
public void division(int mrx,int ample){
float result=(float)mrx/ample;
System.out.println(mrx+" / "+ample+" = "+result);
}
}
class Mr_Examples{
public static void main(String[] args) {
Mathematical_Operations mrx_obj=new Mathematical_Operations();
mrx_obj.addition(2,5);
mrx_obj.subtraction(8,3);
mrx_obj.multiplication(7,2);
mrx_obj.division(6,4);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Importar palavra-chave em Java

Pacotes , classes e interfaces podem ser importados usando a palavra-chave import.

A API Java fornece uma classe ArrayList , que pode ser importada da seguinte forma:

Import Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList in_Demand_Programming_Languages=new ArrayList();
in_Demand_Programming_Languages.add("Java Script");
in_Demand_Programming_Languages.add("Python");
in_Demand_Programming_Languages.add("Css");
in_Demand_Programming_Languages.add("Java");
in_Demand_Programming_Languages.add("Html");
for(String mrx:in_Demand_Programming_Languages){
System.out.println(mrx);
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma , também podemos utilizar a classe Scanner do pacote java.util conforme mostrado abaixo:

Import Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner mrx=new Scanner(System.in);
System.out.println("Enter First word here:");
String word1=mrx.next();
System.out.println("Enter Second word here:");
String word2=mrx.next();
if(word1.equals(word2)){
System.out.println("Exact Match");
}
else{
System.out.println("Not Matched");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Instância da palavra-chave em Java

Ao discutir a palavra-chave Java Instanceof , a instância de permite que você verifique se um objeto pertence a uma determinada classe ou interface.

Ao usar a palavra-chave “ instanceof ”, um valor booleano true ou false é fornecido em troca da comparação da instância com seu tipo específico.

O exemplo abaixo mostra seu funcionamento:

Instanceof Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
Main mrx_obj=new Main();
boolean result=mrx_obj instanceof Main;
System.out.println("Result= "+result);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma , mostra os resultados como true quando vários objetos são uma instância da classe Main , conforme mostrado abaixo:

Instanceof Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Main {
public static void main(String[] args) {
Main mrx_obj=new Main();
Main mrx_obj1=new Main();
boolean result1=mrx_obj instanceof Main;
boolean result2=mrx_obj1 instanceof Main;
System.out.println("Result 1= "+result1);
System.out.println("Result 2= "+result1);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave Int em Java

O tipo de dados int pode conter inteiros variando de -2147483648 a 2147483647.

Int Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Main {
public static void main(String[] args) {
int mrx_Int_Limit= 2147483647;
System.out.println("The maximum positive limit of the integer data type is:"+mrx_Int_Limit);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma , podemos obter duas entradas int do usuário e encontrar o operador de módulo delas. Para maiores esclarecimentos siga o exemplo abaixo:

Int Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("Enter Number 1 here: ");
int mrx=input.nextInt();
System.out.println("Enter Number 2 here: ");
int ample=input.nextInt();
int result=mrx%ample;
System.out.println(mrx+" % "+ample+" = "+result);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave longa em Java

O tipo de dados long é capaz de armazenar números inteiros entre -9223372036854775808 e 9223372036854775808.

Lembre-se de terminar o valor com um “L” maiúsculo ou minúsculo.

Long Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
public class Main {
public static void main(String[] args) {
long mrx_Long=-9223372036854775808l;
System.out.println("The last Negative value an Long data type can hold is: "+mrx_Long);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Long Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Main {
public static void main(String[] args) {
Long mrx=1234322312333123123l;
Long ample=2354242423423423431l;
System.out.println("The product of two long data type variables is: "+(mrx*ample));
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Nova palavra-chave em Java

A criação de novos objetos é realizada usando a palavra-chave new.

O exemplo a seguir mostra a criação de um objeto usando a palavra-chave new:

New Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Main {
String topic="New keyword";
public static void main(String[] args) {
Main mrx=new Main();
System.out.println("Today the topic of our discussion is: "+mrx.topic);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

New Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Main {
String mrx="Mr";
String ample="Examples";
public static void main(String[] args) {
Main mrx_obj=new Main();
System.out.println("Greetings ! You are learning Java Programming Language from : "+mrx_obj.mrx+". "+mrx_obj.ample);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave do pacote em Java

Os pacotes são criados usando a palavra-chave package.

Primeiramente, criamos um pacote chamado “ myfirstpackage ” usando a palavra-chave package:

Package Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
package myfirstpackage;
public class Main {
public static void main(String[] args) {
System.out.println("We have successfully created our first package");
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma , podemos criar outro pacote usando a palavra-chave package:

Package Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
package mysecondpackage;
public class Main {
public static void main(String[] args) {
System.out.println("We have successfully created our Second package");
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave privada em Java

Um atributo, método ou construtor declarado como privado só pode ser acessado dentro da classe declarada usando a palavra-chave private .

O exemplo a seguir mostra o uso da palavra-chave private dentro de uma classe:

Private Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
private String user_Name ="Mr.Example";
private String user_Email ="https://mrexamples.com";
private int user_Age = 26;
public static void main(String[] args) {
Main myObj = new Main();
System.out.println("( User Information )");
System.out.println("\nUser Name: "+myObj.user_Name);
System.out.println("\nUser Email: "+myObj.user_Email);
System.out.println("\nUser Age: "+myObj.user_Age);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Aqui, criamos o método private e o acessamos dentro da classe usando o objeto:

Private Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Main {
private void mrx_method(){
System.out.println("This is a private method of the Main class");
}
public static void main(String[] args) {
Main obj=new Main();
obj.mrx_method();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave protegida em Java

Modificadores de acesso, como atributos de make protegidos , métodos e construtores acessíveis dentro de pacotes ou subclasses .

Quando se trata de Java Keyword Protected , aqui a subclasse User_Details é capaz de acessar os atributos protegidos de uma classe User, como:

Protected Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class User{
protected String user_Name ="Mr. Example";
protected String site_Name ="https://mrexamples.com";
protected int user_Age = 26;
}
class User_Details extends User{
public static void main(String[] args) {
User_Details ample_object=new User_Details();
System.out.println("( User Information )");
System.out.println("\nUser Name: "+ample_object.user_Name);
System.out.println("\nWebsite Address: "+ample_object.site_Name);
System.out.println("\nUser Age: "+ample_object.user_Age);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Protected Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class User{
protected void method(){
System.out.println("We are learning about Ref Keyword Protected in Java.");
}
}
class User_Details extends User{
public static void main(String[] args) {
User_Details ample_object=new User_Details();
ample_object.method();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave pública em Java

Quando se trata da palavra-chave Public , a palavra-chave public especifica um modificador de acesso para classes , atributos , métodos e construtores , que os torna acessíveis por qualquer outra classe.

Aqui acessamos vários atributos públicos de uma classe para outra sem estender a classe:

Public Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class User{
public String user_Name ="Mr. Example";
public String site_Name ="https://mrexamples.com";
public int user_Age = 26;
}
class User_Details {
public static void main(String[] args) {
User mrx_obj=new User();
System.out.println("( User Information )");
System.out.println("\nUser Name: "+mrx_obj.user_Name);
System.out.println("\nWebsite Address: "+mrx_obj.site_Name);
System.out.println("\nUser Age: "+mrx_obj.user_Age);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Maneira semelhante pode ser utilizada para acessar um método:

Public Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class User{
public void method(){
System.out.println("The topic of Discussion is Ref Keyword Public.");
}
}
class User_Details {
public static void main(String[] args) {
User mrx_obj=new User();
mrx_obj.method();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Retornar palavra-chave em Java

Return representa o fim da execução de um método e pode ser usado para retornar um valor de um método após a conclusão da execução.

O seguinte método retorna o produto de 2 números:

Return Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
int product(int mrx,int ample){
return mrx*ample;
}
public static void main(String[] args) {
Main obj=new Main();
int result=obj.product(5,7);
System.out.println("The Result is given as follow: "+result);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O programa fornecido recebe a entrada do usuário como um número inteiro e calcula o fatorial dele:

Tais como: fatorial de 5 é: 5 * 4 * 3 * 2 * 1

Return Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.Scanner;
public class Main {
public static int calculate_Factorial(int n) {
int factorial = 1;
for (int i = 1; i <= n; i++) {
factorial *= i;
}
return factorial;
}
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("Enter Number here: ");
int number=input.nextInt();
int result = calculate_Factorial(number);
System.out.println("The factorial of " + number + " is: " + result);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Nota: Quando void é usado, o método não tem valor de retorno.

O exemplo fornecido mostra métodos void, o que significa que eles não têm um tipo de retorno:

Return Keyword Example: 3 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Main {
static void my_Void_Method() {
System.out.println("Greetings ! We are learning about void methods (No return type)");
}
public static void main(String[] args) {
my_Void_Method();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Aqui está outro exemplo de uso do método void para dividir o valor variável mrx pelo valor amplo:

Return Keyword Example: 4 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.Scanner;
public class Main {
static void divide_Values(int mrx, int ample) {
float result=(float) mrx/ample;
System.out.println(mrx+" / "+ample+" = "+result);
}
public static void main(String[] args) {
Main obj=new Main();
Scanner input=new Scanner(System.in);
System.out.println("Enter value of mrx here: ");
int mrx=input.nextInt();
System.out.println("Enter value of ample here: ");
int ample=input.nextInt();
divide_Values(mrx,ample);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave curta em Java

Em Java , a palavra-chave curta é o tipo de tipo de dado que pode armazenar números inteiros variando de -32768 a 32767.

Podemos usar uma variável curta se quisermos armazenar inteiros entre -32768 a 32767:

Short Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
short lower_Range=-32768;
short upper_Range=32767;
System.out.println("The short data type has an uppermost value as : "+upper_Range+" where are it can store "+lower_Range+" as the lowest storing element");
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Correspondentemente , também podemos encontrar a soma de duas variáveis ​​de tipos de dados curtos:

Short Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Main {
public static void main(String[] args) {
short mrx=2324;
short ample=1514;
System.out.println("Sum of mrx and ample is: "+(mrx+ample));
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave estática em Java

Métodos e atributos estáticos possuem um modificador de não acesso chamado static.

Ao usar a palavra-chave Java static , os métodos/atributos estáticos podem ser acessados ​​sem criar um objeto da classe.

No exemplo abaixo utilizamos os atributos estáticos e os acessamos sem utilizar o objeto:

Static Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Main {
static String user_Name ="Mr. Example";
static String site_Name ="https://mrexamples.com";
static int user_Age = 26;
public static void main(String[] args) {
System.out.println("( User Information )");
System.out.println("\nUser Name: "+user_Name);
System.out.println("\nWebsite Address: "+site_Name);
System.out.println("\nUser Age: "+user_Age);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma, podemos acessar os métodos com modificador estático sem instanciá-lo com nenhum objeto:

Static Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Main {
static void method_static(){
System.out.println("This is a static method which can be accessed without an object");
}
public void method_public(){
System.out.println("This is a public method which requires an object to call itself");
}
public static void main(String[] args) {
// Here we called the static method without an instance with an object
method_static();
Main obj=new Main(); // Object of Main class is created here
obj.method_public(); // the public method is accessible now
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Super palavra-chave em Java

No caso da palavra-chave Java Super , super refere-se a objetos de superclasse (classe pai/classe base).

Além de acessar o construtor da superclasse , também se destina a chamar métodos da superclasse.

É comumente usado para evitar confusão entre subclasses e superclasses que possuem os mesmos nomes de método.

Um entendimento básico de herança e polimorfismo é necessário para entender a palavra-chave super.

O programa a seguir mostra o uso de super palavra-chave() para acessar os métodos da classe pai no método da classe filho chamado information() :

Super Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Marts{ // Superclass (parent)
public void information() {
System.out.println("There are approximately 67,167 marts in United States");
}
}
class Walmart extends Marts { // Subclass (child)
public void information() {
super.information(); // Call the superclass method
System.out.println("Among all the marts, Walmart is the largest supermarket chain in america having more than 10,500 stores and an expected revenue of $ 385.73 Billions");
}
}
public class Main {
public static void main(String args[]) {
Marts marts = new Walmart(); // Create an object of Walmart class
marts.information();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Também podemos usar uma palavra-chave super() para acessar um construtor de classe pai dentro de um construtor de classe filha:

Super Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Parent{ // Superclass (parent)
Parent(){
System.out.println("This is a Base / Parent class constructor used in child class constructor");
}
}
class Child extends Parent { // Subclass (child)
Child(){
super();
System.out.println("This is a child class constructor");
}
}
public class Main {
public static void main(String args[]) {
Parent obj = new Child(); // Create an object of parent class
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Alternar palavra-chave em Java

Quando se trata de Java Keyword Switch , a palavra-chave switch decide qual dentre vários blocos de código executar.

No exemplo abaixo, funciona da seguinte forma:

  • As expressões switch são avaliadas uma vez.
  • O valor de cada caso é comparado com o valor da expressão .
  • Quando uma correspondência é encontrada, o bloco de código associado é executado.
  • Assim que uma correspondência é encontrada, a palavra-chave break é usada para encerrar o bloco switch

Podemos aprender como usar a instrução switch seguindo o exemplo abaixo:

Switch Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
System.out.println("\n \t\t( Menu )");
System.out.println("1) Hot Chocolate 8$ ");
System.out.println("2) Cappuccino 6$");
System.out.println("3) Tea 4$");
System.out.println("4) Frappuccino 9$");
System.out.println("5) Latte 5$");
Scanner input=new Scanner(System.in);
System.out.println("\nEnter the Correct Item Number from the menu list to place an order: ");
int choice=input.nextInt();
switch (choice){
case 1:
System.out.println("\nHot Chocolate Selected");
System.out.println("Total Bill= 8$");
System.out.println("The order will take 20 minutes. Thank you for the patience !!");
break;
case 2:
System.out.println("\nCappuccino Selected");
System.out.println("Total Bill= 6$");
System.out.println("The order will take 20 minutes. Thank you for the patience !!");
break;
case 3:
System.out.println("\nTea Selected");
System.out.println("Total Bill= 4$");
System.out.println("The order will take 20 minutes. Thank you for the patience !!");
break;
case 4:
System.out.println("\nFrappuccino Selected");
System.out.println("Total Bill= 9$");
System.out.println("The order will take 20 minutes. Thank you for your patience !!");
break;
case 5:
System.out.println("\nLatte Selected");
System.out.println("Total Bill= 5$");
System.out.println("The order will take 20 minutes. Thank you for your patience !!");
break;
default:
System.out.println("Wrong input !! Try again");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Aqui podemos criar uma calculadora em Java usando switch case:

Switch Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
System.out.println("\n \t\t( ———————- C A L C U L A T O R ————————– )");
System.out.println("\n\n1) Addition");
System.out.println("2) Subtraction");
System.out.println("3) Multiplication");
System.out.println("4) Division");
System.out.println("5) Modulus");
Scanner input=new Scanner(System.in);
System.out.println("\n\nEnter Number 1: ");
int mrx=input.nextInt();
System.out.println("\nEnter Number 2: ");
int ample=input.nextInt();
System.out.println("\nEnter Choice Number as per list given above: ");
int choice=input.nextInt();
switch (choice){
case 1:
System.out.println("\n\nOutput: ");
System.out.println("\n"+mrx+" + "+ample+" = "+(mrx+ample));
System.out.println("Addition Operation Successfully executed !! Thank you for using the calculator!!");
break;
case 2:
System.out.println("\n\nOutput: ");
System.out.println("\n"+mrx+" – "+ample+" = "+(mrx-ample));
System.out.println("Subtraction Operation Successfully executed !! Thank you for using the calculator!!");
break;
case 3:
System.out.println("\n\nOutput: ");
System.out.println("\n"+mrx+" x "+ample+" = "+(mrx*ample));
System.out.println("Multiplication Operation Successfully executed !! Thank you for using the calculator!!");
break;
case 4:
System.out.println("\n\nOutput: ");
float result=(float)mrx/ample;
System.out.println("\n"+mrx+" / "+ample+" = "+result);
System.out.println("Division Operation Successfully executed !! Thank you for using the calculator!!");
break;
case 5:
System.out.println("\n\nOutput: ");
System.out.println("\n"+mrx+" % "+ample+" = "+(mrx%ample));
System.out.println("Modulus Operation Successfully executed !! Thank you for using the calculator!!");
break;
default:
System.out.println("Wrong input !! Try again");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Esta palavra-chave em Java

Quando se trata da palavra-chave Java This , refere-se ao objeto em um método ou construtor.

Essa palavra-chave é mais comumente usada para distinguir atributos de classe de parâmetros com o mesmo nome (devido ao efeito de sombreamento de um método ou parâmetro de construtor em um atributo de classe).

No exemplo abaixo, sem essa palavra-chave, a saída seria “0” em vez de “Java This keyword “.

Além disso, também pode ser usado para:

  • Chame o construtor da classe atual.
  • O método da classe atual é invocado.
  • Obtenha o objeto da classe atual.
  • Ao chamar um método, passe um argumento.
  • Chame o construtor com um argumento.

Acessando um atributo de classe mrx com esta palavra-chave:

This Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
String mrx;
// Here we create a constructor with an argument
public Main(String mrx) {
this.mrx = mrx;
}
// Here we call the constructor of the main class:
public static void main(String[] args) {
Main myObj = new Main("Java This Keyword");
System.out.println("Topic = " + myObj.mrx);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

This Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
float ample;
// Here we create a constructor with an argument
public Main(float ample) {
this.ample = ample;
}
// Here we call the constructor of the main class:
public static void main(String[] args) {
Main myObj = new Main(5.32f);
System.out.println("Float Value = " + myObj.ample);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Lançar palavra-chave em Java

Quando se trata de Ref Keyword Throw, a palavra-chave throw gera um erro personalizado.

Um tipo de exceção é usado com a instrução throw. ArithmeticException, ClassNotFoundException, ArrayIndexOutOfBoundsException, SecurityException e assim por diante são todos tipos de exceção disponíveis em Java.

Como no exemplo abaixo, os tipos de exceção geralmente são associados a métodos personalizados.

Arremesso contra arremessos

Lançar:

  • As exceções de método são lançadas usando este método.
  • Exceções só podem ser lançadas uma vez.

Lances:

  • Indica o tipo de exceção que pode ser lançada por um método.
  • É possível listar várias exceções em Java Keyword Throw .

O programa a seguir corresponde ao número de dígitos conforme o número PIN do ATM inserido pelo usuário e mostra uma exceção se o comprimento dos dígitos inseridos for maior ou menor que 4:

Throw Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.Scanner;
public class Main {
static void atm_pin_Security() {
Scanner input=new Scanner(System.in);
System.out.println("Enter Your Atm Pin here: ");
String atm_pin=input.next();
if (atm_pin.length() != 4) {
throw new ArithmeticException("Access denied – The ATM pin should contain exactly 4 digits");
}
else {
System.out.println("Pin Limit Successfully Achieved ");
}
}
public static void main(String[] args) {
atm_pin_Security();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

E o exemplo a seguir mostra o programa que recebe duas entradas do usuário, as compara e mostra uma exceção se não forem iguais:

Throw Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.util.Scanner;
public class Main {
static void match_2_Numbers() {
Scanner input=new Scanner(System.in);
System.out.println("Enter Your First Number here: ");
int mrx=input.nextInt();
System.out.println("Enter Your Second Number here: ");
int ample=input.nextInt();
if (mrx!=ample) {
throw new ArithmeticException(mrx+" and "+ample+" are two different numbers !!");
}
else {
System.out.println(mrx+" and "+ample+" are the same numbers !!");
}
}
public static void main(String[] args) {
match_2_Numbers();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Lança palavras-chave em Java

A palavra-chave throws especifica quais tipos de exceção podem ser lançados por um método.

As exceções lançadas durante esse processo são as mesmas que discutimos na palavra-chave throw .

A partir do exemplo dado acima, podemos entender claramente o funcionamento da palavra-chave throws:

Throws Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.util.Scanner;
public class Main {
static void match_2_Numbers() throws ArithmeticException {
Scanner input=new Scanner(System.in);
System.out.println("Enter Your First Number here: ");
int mrx=input.nextInt();
System.out.println("Enter Your Second Number here: ");
int ample=input.nextInt();
if (mrx!=ample) {
throw new ArithmeticException(mrx+" and "+ample+" are two different numbers !!");
}
else {
System.out.println(mrx+" and "+ample+" are the same numbers !!");
}
}
public static void main(String[] args) {
match_2_Numbers();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma , considere uma matriz que contém 5 marcas de roupas famosas dos Estados Unidos. Se imprimirmos mais do que o número de marcas determinado, gerará uma exceção “ ArrayIndexOutOfBoundsException ” conforme mostrado abaixo:

Throws Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Main {
static void united_States_Clothing_Brands() throws ArrayIndexOutOfBoundsException {
String clothing_Brands[]={"Patagonia","BODE","Carhartt","Alpha Industries","Rick Owens"};
for(int mrx=0;mrx <=7;mrx++){
if (mrx > clothing_Brands.length) {
throw new ArrayIndexOutOfBoundsException("The array does not contain elements more than 5");
}
else {
System.out.println(clothing_Brands[mrx]);
}
}
System.out.println("All the elements are printed upto the limit of the Array ");
}
public static void main(String[] args) {
united_States_Clothing_Brands();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Experimente palavras-chave em Java

Com referência à palavra-chave Java try , a instrução try-catch é produzida.

Você pode usar a instrução try para testar erros em um bloco de código enquanto ele está sendo executado.

As instruções catch permitem que você defina um bloco de código que será processado se o bloco try falhar.

Try-catch é usado para detectar erros e, em seguida, executar um trecho de código para lidar com eles. Percorra os exemplos abaixo para entender seu funcionamento com mais clareza:

Try Keyword Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Main {
public static void main(String[] args) {
try {
int[] prime_Numbers = {2,3,5,7,11,13,17};
System.out.println(prime_Numbers[11]);
} catch (Exception e) {
System.out.println("Array of Prime Numbers Do not have any element at such index ");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O exemplo fornecido mostra a exceção se o usuário inserir dados de outros tipos de dados além de int :

Try Keyword Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
try {
System.out.println("Enter Number here: ");
int mrx_num=input.nextInt();
System.out.println("Integer Entered: "+mrx_num);
} catch (Exception e) {
System.out.println("User Entered data is of another data type than int !!");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Palavra-chave vazia em Java

Quando falamos sobre a palavra-chave Void do Java , ela especifica que um método com a palavra-chave void não deve retornar nada.

Da mesma forma, o método do exemplo abaixo não retorna nada:

Java Keyword Void Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Main {
static void topic_under_Discussion(){
System.out.println("The topic under Discussion is Java Keyword Void");
}
public static void main(String[] args) {
topic_under_Discussion();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Correspondentemente , o seguinte mostra o funcionamento de um método void que pega a altura do usuário em pés e a converte em pés :

Java Keyword Void Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.Scanner;
public class Main {
static void feet_To_Centimeter_height_convertor(){
Scanner input=new Scanner(System.in);
System.out.println("Enter Height in Feet here: ");
float mrx=input.nextFloat();
System.out.println("————- Feet To Centimeter Height Converter ——————-");
System.out.println("\nHeight in Feet: "+mrx);
float height_centimeters=mrx*30.48f;
System.out.println("\nHeight in Centimeters: "+height_centimeters+" cm");
}
public static void main(String[] args) {
feet_To_Centimeter_height_convertor();
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Dica: é possível fazer um método retornar um valor usando um tipo de dado primitivo (como int , char , etc.) em vez de void. Para fazer isso, use a palavra-chave return da seguinte maneira. O programa a seguir mostra o método de avaliação de uma string, para ver se ela termina com “a”.

Java Keyword Void Example: 3 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import java.util.Scanner;
public class Main {
public static int Strings_Compare_Method() {
Scanner input = new Scanner(System.in);
System.out.println("Enter String 1 here: ");
String mrx = input.next();
boolean result=mrx.endsWith("s");
if(result==true){
return 0;
}
else{
return 1;
}
}
public static void main(String[] args) {
Main obj=new Main();
int ample_result2=Strings_Compare_Method();
if(ample_result2 == 0){
System.out.println("\nThe user given String ends with s");
}
else{
System.out.println("\nUser given String Do not Ends with s");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O programa a seguir retorna 0 se o caractere for uma vogal e 1 se for uma consoante e mostra os resultados de acordo:

Java Keyword Void Example: 4 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import java.util.Scanner;
public class Main {
public static char vowel_checker() {
Scanner input = new Scanner(System.in);
System.out.println("Enter an Alphabet here: ");
char ample=input.next().charAt(0);
if(ample=='a'||ample=='e'||ample=='i'||ample=='o'||ample=='u'){
return 0;
}
else{
return 1;
}
}
public static void main(String[] args) {
int ample_result=vowel_checker();
if(ample_result==0){
System.out.println("Character is a Vowel ");
}
else{
System.out.println("Character is a Consonant");
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Enquanto palavra-chave em Java

Quando se trata da palavra-chave Java While , o loop while fará um loop através de um bloco de código, desde que uma determinada condição seja verdadeira .

Certifique-se de aumentar a variável atribuída na condição, caso contrário, o loop nunca terminará.

Os exemplos dados mostram todos os números pares começando de 0 até o limite do usuário:

Java Keyword While Example: 1 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("Enter Range here: ");
int mrx=input.nextInt();
int ample=0;
System.out.println("\nEven Numbers upto the limit "+mrx+" are: \n");
while(ample <= mrx){
if(ample % 2==0){
System.out.println(ample);
}
ample++;
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Correspondentemente , os quadrados dos números até o limite do usuário podem ser calculados da seguinte maneira:

Java Keyword While Example: 2 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("Enter Limit here: ");
int mrx=input.nextInt();
System.out.println("\nThe squares of numbers till the limit "+mrx+" are : \n");
int ample=1;
int result;
while(ample <= mrx){
{
result=ample*ample;
}
System.out.println("The square of "+ample+" is: "+result);
ample++;
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Existe uma variação do loop while que pode ser chamada de loop do/while . Durante a execução deste loop, o bloco de código será executado uma vez, antes de verificar se a condição é verdadeira , e então repetirá o loop enquanto a condição for verdadeira:

O exemplo dado mostra a soma dos números até o limite do usuário usando o loop do/while:

Java Keyword While Example: 3 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter Limit here: ");
int mrx = input.nextInt();
System.out.println("\nThe squares of numbers till the limit " + mrx + " are : \n");
int ample = 0;
int sum = 0;
do {
sum = sum + ample;
System.out.println("The Sum of Numbers upto "+ample+" the limit is: " + sum);
ample++;
}
while (ample <= mrx);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Da mesma forma , um loop while pode ser usado para imprimir os números naturais até o limite do usuário:

Java Keyword While Example: 3 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter Limit here: ");
int mrx = input.nextInt();
System.out.println("\nThe squares of numbers till the limit " + mrx + " are : \n");
int ample = 1;
do {
System.out.println(ample);
ample++;
}
while (ample <= mrx);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

 

Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone
Ao assinar, você concorda com nossa política de privacidade e nossos termos de serviço.