Java - Guia Rápido

A linguagem de programação Java foi originalmente desenvolvida pela Sun Microsystems, iniciada por James Gosling e lançada em 1995 como componente principal da plataforma Java da Sun Microsystems (Java 1.0 [J2SE]).

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 construídas para atender 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 a garantia de serWrite Once, Run Anywhere.

Java é -

• Object Oriented- Em Java, tudo é um objeto. Java pode ser facilmente estendido, pois é baseado no modelo de objeto.

• Platform Independent- Ao contrário de muitas outras linguagens de programação, incluindo C e C ++, quando o Java é compilado, ele não é compilado em uma máquina específica da plataforma, mas sim em um código de bytes independente da plataforma. Esse código de byte é distribuído pela web e interpretado pela Máquina Virtual (JVM) em qualquer plataforma em que esteja sendo executado.

• Simple- Java foi projetado para ser fácil de aprender. Se você entender o conceito básico de OOP Java, será fácil de dominar.

• Secure- Com o recurso seguro do Java, ele permite desenvolver sistemas livres de vírus e adulteração. As técnicas de autenticação são baseadas na criptografia de chave pública.

• Architecture-neutral - O compilador Java gera um formato de arquivo de objeto de arquitetura neutra, que torna o código compilado executável em muitos processadores, com a presença do sistema Java runtime.

• Portable- Ser neutro em termos de arquitetura e não ter aspectos dependentes da implementação da especificação torna o Java portátil. O compilador em Java é escrito em ANSI C com um limite de portabilidade limpo, que é um subconjunto POSIX.

• Robust - Java se esforça para eliminar situações sujeitas a erros, enfatizando principalmente a verificação de erros em tempo de compilação e a verificação em tempo de execução.

• Multithreaded- Com o recurso multithread do Java, é possível escrever programas que podem realizar várias tarefas simultaneamente. Este recurso de design permite que os desenvolvedores construam aplicativos interativos que podem ser executados sem problemas.

• Interpreted- O código de bytes Java é traduzido em tempo real para as 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.

• High Performance - Com o uso de compiladores Just-In-Time, Java permite alto desempenho.

• Distributed - Java é projetado para o ambiente distribuído da Internet.

• Dynamic- Java é considerado mais dinâmico do que C ou C ++, pois é projetado para se adaptar a um ambiente em evolução. Os programas Java podem transportar uma grande quantidade de informações de tempo de execução que podem ser usadas para verificar e resolver acessos a objetos em tempo de execução.

História de Java

James Gosling iniciou o projeto da linguagem Java em junho de 1991 para uso em um de seus muitos projetos de decodificadores. A linguagem, inicialmente chamada de 'Oak' em homenagem a um carvalho que ficava do lado de fora do escritório de Gosling, também era conhecida pelo nome de 'Green' e acabou sendo renomeada para Java, a partir de uma lista de palavras aleatórias.

A Sun lançou a primeira implementação pública como Java 1.0 em 1995. Ela prometeu Write Once, Run Anywhere (WORA), fornecendo tempos de execução gratuitos em plataformas populares.

Em 13 de novembro de 2006, a Sun lançou grande parte do Java como software livre e de código aberto sob os termos da GNU General Public License (GPL).

Em 8 de maio de 2007, a Sun concluiu o processo, tornando todo o código principal do Java gratuito e de código aberto, exceto uma pequena parte do código do qual a Sun não detinha os direitos autorais.

Ferramentas que você vai precisar

Para executar os exemplos discutidos neste tutorial, você precisará de um computador Pentium 200 MHz com no mínimo 64 MB de RAM (128 MB de RAM recomendados).

Você também precisará dos seguintes softwares -

• Sistema operacional Linux 7.1 ou Windows xp / 7/8
• Java JDK 8
• Bloco de notas da Microsoft ou qualquer outro editor de texto

Este tutorial fornecerá as habilidades necessárias para criar GUI, rede e aplicativos da Web usando Java.

O que vem a seguir?

O próximo capítulo irá guiá-lo sobre como obter o Java e sua documentação. Por fim, ele instrui você sobre como instalar o Java e preparar um ambiente para desenvolver aplicativos Java.

Neste capítulo, discutiremos os diferentes aspectos da configuração de um ambiente adequado para Java.

Configuração de ambiente local

Se você ainda deseja configurar seu ambiente para a linguagem de programação Java, esta seção o orienta sobre como fazer download e configurar o Java em sua máquina. A seguir estão as etapas para configurar o ambiente.

Java SE está disponível gratuitamente no link Download Java . Você pode baixar uma versão com base em seu sistema operacional.

Siga as instruções para baixar o Java e executar o .exepara instalar o Java em sua máquina. Depois de instalar o Java em sua máquina, você precisará definir as variáveis ​​de ambiente para apontar para os diretórios de instalação corretos -

Configurando o caminho para o Windows

Supondo que você tenha instalado o Java no diretório c: \ Arquivos de programas \ java \ jdk -

• Clique com o botão direito em 'Meu Computador' e selecione 'Propriedades'.

• Clique no botão 'Variáveis ​​de ambiente' na guia 'Avançado'.

• Agora, altere a variável 'Path' para que também contenha o caminho para o executável Java. Exemplo, se o caminho está definido atualmente para 'C: \ WINDOWS \ SYSTEM32', altere seu caminho para 'C: \ WINDOWS \ SYSTEM32; c: \ Arquivos de programas \ java \ jdk \ bin'.

Configurando o caminho para Linux, UNIX, Solaris, FreeBSD

A variável de ambiente PATH deve ser definida para apontar para onde os binários Java foram instalados. Consulte a documentação do shell, se tiver problemas para fazer isso.

Por exemplo, se você usar bash como seu shell, você adicionaria a seguinte linha ao final de seu '.bashrc: export PATH = / path / to / java: $ PATH'

Editores Java populares

Para escrever seus programas Java, você precisará de um editor de texto. Existem IDEs ainda mais sofisticados disponíveis no mercado. Mas, por agora, você pode considerar um dos seguintes -

• Notepad - Na máquina Windows, você pode usar qualquer editor de texto simples como o Notepad (recomendado para este tutorial), TextPad.

• Netbeans - Um IDE Java que é de código aberto e gratuito que pode ser baixado de https://www.netbeans.org/index.html.

• Eclipse - Um IDE Java desenvolvido pela comunidade de código aberto eclipse e pode ser baixado de https://www.eclipse.org/.

O que vem a seguir?

O próximo capítulo ensinará como escrever e executar seu primeiro programa Java e algumas das importantes sintaxes básicas em Java necessárias para o desenvolvimento de aplicativos.

Quando consideramos um programa Java, ele pode ser definido como uma coleção de objetos que se comunicam por meio da chamada dos métodos uns dos outros. Vamos agora dar uma olhada rápida no que significam as variáveis ​​de classe, objeto, métodos e instância.

• Object- Os objetos têm estados e comportamentos. Exemplo: um cão tem estados - cor, nome, raça e também comportamento, como abanar o rabo, latir, comer. Um objeto é uma instância de uma classe.

• Class - Uma classe pode ser definida como um template / blueprint que descreve o comportamento / estado que o objeto de seu tipo suporta.

• Methods- Um método é basicamente um comportamento. Uma classe pode conter muitos métodos. É nos métodos onde as lógicas são escritas, os dados são manipulados e todas as ações são executadas.

• Instance Variables- Cada objeto tem seu conjunto único de variáveis ​​de instância. O estado de um objeto é criado pelos valores atribuídos a essas variáveis ​​de instância.

Primeiro Programa Java

Vejamos um código simples que imprimirá as palavras Hello World.

Exemplo

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    */

   public static void main(String []args) {
      System.out.println("Hello World"); // prints Hello World
   }
}

Vejamos como salvar o arquivo, compilar e executar o programa. Siga as etapas subsequentes -

• Abra o bloco de notas e adicione o código como acima.

• Salve o arquivo como: MyFirstJavaProgram.java.

• Abra uma janela de prompt de comando e vá para o diretório onde você salvou a classe. Suponha que seja C: \.

• Digite 'javac MyFirstJavaProgram.java' e pressione Enter para compilar seu código. Se não houver erros em seu código, o prompt de comando o levará para a próxima linha (Suposição: A variável de caminho está definida).

• Agora, digite 'java MyFirstJavaProgram' para executar seu programa.

• Você poderá ver 'Hello World' impresso na janela.

Resultado

C:\> javac MyFirstJavaProgram.java
C:\> java MyFirstJavaProgram 
Hello World

Sintaxe Básica

Sobre os programas Java, é muito importante ter em mente os seguintes pontos.

• Case Sensitivity - Java diferencia maiúsculas de minúsculas, o que significa identificador Hello e hello teria um significado diferente em Java.

• Class Names- Para todos os nomes de classes, a primeira letra deve estar em maiúsculas. Se várias palavras forem usadas para formar o nome da classe, a primeira letra de cada palavra interna deve estar em maiúsculas.

  Example: classe MyFirstJavaClass

• Method Names- Todos os nomes de métodos devem começar com uma letra minúscula. Se várias palavras forem usadas para formar o nome do método, a primeira letra de cada palavra interna deve estar em maiúscula.

  Example: public void myMethodName ()

• Program File Name - O nome do arquivo do programa deve corresponder exatamente ao nome da classe.

  Ao salvar o arquivo, você deve salvá-lo usando o nome da classe (Lembre-se de que o Java diferencia maiúsculas de minúsculas) e acrescentar '.java' ao final do nome (se o nome do arquivo e o nome da classe não corresponderem, seu programa não irá compilar )

  Example:Suponha que 'MyFirstJavaProgram' seja o nome da classe. Então, o arquivo deve ser salvo como 'MyFirstJavaProgram.java'

• public static void main(String args[]) - O processamento do programa Java começa a partir do método main (), que é uma parte obrigatória de todo programa Java.

Identificadores Java

Todos os componentes Java requerem nomes. Os nomes usados ​​para classes, variáveis ​​e métodos são chamadosidentifiers.

Em Java, há vários pontos a serem lembrados sobre identificadores. Eles são os seguintes -

• Todos os identificadores devem começar com uma letra (A a Z ou a a z), caractere de moeda ($) ou um sublinhado (_).

• Após o primeiro caractere, os identificadores podem ter qualquer combinação de caracteres.

• Uma palavra-chave não pode ser usada como identificador.

• Mais importante ainda, os identificadores diferenciam maiúsculas de minúsculas.

• Exemplos de identificadores legais: idade, $ salary, _value, __1_value.

• Exemplos de identificadores ilegais: 123abc, -salary.

Modificadores Java

Como outras linguagens, é possível modificar classes, métodos, etc., usando modificadores. Existem duas categorias de modificadores -

• Access Modifiers - padrão, público, protegido, privado

• Non-access Modifiers - final, abstrato, strictfp

Veremos mais detalhes sobre modificadores na próxima seção.

Variáveis ​​Java

A seguir estão os tipos de variáveis ​​em Java -

• Variáveis ​​Locais
• Variáveis ​​de classe (variáveis ​​estáticas)
• Variáveis ​​de instância (variáveis ​​não estáticas)

Arrays Java

Arrays são objetos que armazenam várias variáveis ​​do mesmo tipo. No entanto, uma matriz em si é um objeto na pilha. Veremos como declarar, construir e inicializar nos próximos capítulos.

Java Enums

Enums foram introduzidos no Java 5.0. Enums restringem uma variável para ter apenas alguns valores predefinidos. Os valores nesta lista enumerada são chamados de enums.

Com o uso de enums, é possível reduzir o número de bugs em seu código.

Por exemplo, se considerarmos um aplicativo para uma loja de sucos naturais, seria possível restringir o tamanho do vidro para pequeno, médio e grande. Isso garantiria que ninguém pudesse fazer pedidos de qualquer tamanho que não fosse pequeno, médio ou grande.

Exemplo

class FreshJuice {
   enum FreshJuiceSize{ SMALL, MEDIUM, LARGE }
   FreshJuiceSize size;
}

public class FreshJuiceTest {

   public static void main(String args[]) {
      FreshJuice juice = new FreshJuice();
      juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
      System.out.println("Size: " + juice.size);
   }
}

O exemplo acima produzirá o seguinte resultado -

Resultado

Size: MEDIUM

Note- Enums podem ser declarados como próprios ou dentro de uma classe. Métodos, variáveis ​​e construtores também podem ser definidos dentro de enums.

Palavras-chave Java

A lista a seguir mostra as palavras reservadas em Java. Essas palavras reservadas não podem ser usadas como constantes ou variáveis ​​ou quaisquer outros nomes de identificador.

abstrato	afirmar	boleano	pausa
byte	caso	pegar	Caracteres
classe	const	continuar	padrão
Faz	em dobro	outro	enum
estende	final	finalmente	flutuador
para	vamos para	E se	implementos
importar	instancia de	int	interface
grandes	nativo	Novo	pacote
privado	protegido	público	Retorna
baixo	estático	strictfp	super
interruptor	sincronizado	esta	lançar
lança	transitório	experimentar	vazio
volátil	enquanto

Comentários em Java

Java oferece suporte a comentários de uma e de várias linhas muito semelhantes a C e C ++. Todos os caracteres disponíveis em qualquer comentário são ignorados pelo compilador Java.

Exemplo

public class MyFirstJavaProgram {

   /* This is my first java program.
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */

   public static void main(String []args) {
      // This is an example of single line comment
      /* This is also an example of single line comment. */
      System.out.println("Hello World");
   }
}

Resultado

Hello World

Usando linhas em branco

Uma linha contendo apenas espaço em branco, possivelmente com um comentário, é conhecida como linha em branco e o Java a ignora totalmente.

Herança

Em Java, as classes podem ser derivadas de classes. Basicamente, se você precisar criar uma nova classe e já houver uma classe que tenha parte do código de que você precisa, é possível derivar sua nova classe do código já existente.

Este conceito permite que você reutilize os campos e métodos da classe existente sem ter que reescrever o código em uma nova classe. Neste cenário, a classe existente é chamada desuperclass e a classe derivada é chamada de subclass.

Interfaces

Na linguagem Java, uma interface pode ser definida como um contrato entre objetos sobre como se comunicarem entre si. As interfaces desempenham um papel vital quando se trata do conceito de herança.

Uma interface define os métodos que uma classe derivada (subclasse) deve usar. Mas a implementação dos métodos depende totalmente da subclasse.

O que vem a seguir?

A próxima seção explica sobre objetos e classes na programação Java. Ao final da sessão, você terá uma visão clara do que são objetos e o que são classes em Java.

Java é uma linguagem orientada a objetos. Como uma linguagem que possui o recurso Orientado a Objetos, Java oferece suporte aos seguintes conceitos fundamentais -

• Polymorphism
• Inheritance
• Encapsulation
• Abstraction
• Classes
• Objects
• Instance
• Method
• Passagem de mensagens

Neste capítulo, examinaremos os conceitos - Classes e Objetos.

• Object- Os objetos têm estados e comportamentos. Exemplo: Um cão tem estados - cor, nome, raça e também comportamentos - abanar o rabo, latir, comer. Um objeto é uma instância de uma classe.

• Class - Uma classe pode ser definida como um template / blueprint que descreve o comportamento / estado que o objeto de seu tipo suporta.

Objetos em Java

Vamos agora examinar profundamente o que são objetos. Se considerarmos o mundo real, podemos encontrar muitos objetos ao nosso redor, carros, cães, humanos, etc. Todos esses objetos têm um estado e um comportamento.

Se considerarmos um cão, então seu estado é - nome, raça, cor e o comportamento é - latir, abanar o rabo, correr.

Se você comparar o objeto de software com um objeto do mundo real, eles têm características muito semelhantes.

Os objetos de software também têm um estado e um comportamento. O estado de um objeto de software é armazenado em campos e o comportamento é mostrado por meio de métodos.

Portanto, no desenvolvimento de software, os métodos operam no estado interno de um objeto e a comunicação objeto a objeto é feita por meio de métodos.

Aulas em Java

Uma classe é um projeto a partir do qual objetos individuais são criados.

A seguir está um exemplo de uma classe.

Exemplo

public class Dog {
   String breed;
   int age;
   String color;

   void barking() {
   }

   void hungry() {
   }

   void sleeping() {
   }
}

Uma classe pode conter qualquer um dos seguintes tipos de variáveis.

• Local variables- Variáveis ​​definidas dentro de métodos, construtores ou blocos são chamadas de variáveis ​​locais. A variável será declarada e inicializada dentro do método e a variável será destruída quando o método for concluído.

• Instance variables- Variáveis ​​de instância são variáveis ​​dentro de uma classe, mas fora de qualquer método. Essas variáveis ​​são inicializadas quando a classe é instanciada. Variáveis ​​de instância podem ser acessadas de dentro de qualquer método, construtor ou blocos daquela classe particular.

• Class variables - Variáveis ​​de classe são variáveis ​​declaradas dentro de uma classe, fora de qualquer método, com a palavra-chave estática.

Uma classe pode ter vários métodos para acessar o valor de vários tipos de métodos. No exemplo acima, latindo (), com fome () e dormindo () são métodos.

A seguir estão alguns dos tópicos importantes que precisam ser discutidos ao examinar as classes da linguagem Java.

Construtores

Ao discutir sobre as classes, um dos subtópicos mais importantes seriam os construtores. Cada classe possui um construtor. Se não escrevermos explicitamente um construtor para uma classe, o compilador Java construirá um construtor padrão para essa classe.

Cada vez que um novo objeto é criado, pelo menos um construtor será chamado. A regra principal dos construtores é que eles devem ter o mesmo nome da classe. Uma classe pode ter mais de um construtor.

A seguir está um exemplo de um construtor -

Exemplo

public class Puppy {
   public Puppy() {
   }

   public Puppy(String name) {
      // This constructor has one parameter, name.
   }
}

Java também oferece suporte a classes singleton, nas quais você poderia criar apenas uma instância de uma classe.

Note- Temos dois tipos diferentes de construtores. Discutiremos os construtores em detalhes nos capítulos subsequentes.

Criação de um objeto

Conforme mencionado anteriormente, uma classe fornece os projetos para objetos. Então, basicamente, um objeto é criado a partir de uma classe. Em Java, a nova palavra-chave é usada para criar novos objetos.

Existem três etapas ao criar um objeto de uma classe -

• Declaration - Uma declaração de variável com um nome de variável com um tipo de objeto.

• Instantiation - A palavra-chave 'novo' é usada para criar o objeto.

• Initialization- A palavra-chave 'novo' é seguida por uma chamada para um construtor. Esta chamada inicializa o novo objeto.

A seguir está um exemplo de criação de um objeto -

Exemplo

public class Puppy {
   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Passed Name is :" + name );
   }

   public static void main(String []args) {
      // Following statement would create an object myPuppy
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

Se compilarmos e executarmos o programa acima, ele produzirá o seguinte resultado -

Resultado

Passed Name is :tommy

Acessando variáveis ​​e métodos de instância

Variáveis ​​de instância e métodos são acessados ​​por meio de objetos criados. Para acessar uma variável de instância, a seguir está o caminho totalmente qualificado -

/* First create an object */
ObjectReference = new Constructor();

/* Now call a variable as follows */
ObjectReference.variableName;

/* Now you can call a class method as follows */
ObjectReference.MethodName();

Exemplo

Este exemplo explica como acessar variáveis ​​de instância e métodos de uma classe.

public class Puppy {
   int puppyAge;

   public Puppy(String name) {
      // This constructor has one parameter, name.
      System.out.println("Name chosen is :" + name );
   }

   public void setAge( int age ) {
      puppyAge = age;
   }

   public int getAge( ) {
      System.out.println("Puppy's age is :" + puppyAge );
      return puppyAge;
   }

   public static void main(String []args) {
      /* Object creation */
      Puppy myPuppy = new Puppy( "tommy" );

      /* Call class method to set puppy's age */
      myPuppy.setAge( 2 );

      /* Call another class method to get puppy's age */
      myPuppy.getAge( );

      /* You can access instance variable as follows as well */
      System.out.println("Variable Value :" + myPuppy.puppyAge );
   }
}

Se compilarmos e executarmos o programa acima, ele produzirá o seguinte resultado -

Resultado

Name chosen is :tommy
Puppy's age is :2
Variable Value :2

Regras de declaração do arquivo fonte

Como a última parte desta seção, vamos examinar as regras de declaração do arquivo de origem. Essas regras são essenciais ao declarar classes, instruções de importação e instruções de pacote em um arquivo de origem.

• Só pode haver uma classe pública por arquivo de origem.

• Um arquivo de origem pode ter várias classes não públicas.

• O nome da classe pública deve ser o nome do arquivo de origem também, que deve ser anexado por .javano fim. Por exemplo: o nome da classe é public class Employee {} então o arquivo de origem deve ser como Employee.java.

• Se a classe for definida dentro de um pacote, a instrução do pacote deve ser a primeira instrução no arquivo de origem.

• Se houver instruções de importação, elas deverão ser escritas entre a instrução do pacote e a declaração da classe. Se não houver instruções de pacote, a instrução de importação deve ser a primeira linha no arquivo de origem.

• As instruções de importação e pacote implicarão em todas as classes presentes no arquivo de origem. Não é possível declarar instruções de importação e / ou pacote diferentes para classes diferentes no arquivo de origem.

As classes têm vários níveis de acesso e existem diferentes tipos de classes; classes abstratas, classes finais, etc. Explicaremos sobre tudo isso no capítulo sobre modificadores de acesso.

Além dos tipos de classes mencionados acima, Java também possui algumas classes especiais chamadas classes internas e classes anônimas.

Pacote Java

Em palavras simples, é uma forma de categorizar as classes e interfaces. Ao desenvolver aplicativos em Java, centenas de classes e interfaces serão escritas, portanto, categorizar essas classes é uma obrigação, além de tornar a vida muito mais fácil.

Declarações de importação

Em Java, se um nome totalmente qualificado, que inclui o pacote e o nome da classe, for fornecido, o compilador pode localizar facilmente o código-fonte ou as classes. A instrução de importação é uma forma de fornecer a localização adequada para o compilador encontrar essa classe específica.

Por exemplo, a linha a seguir pediria ao compilador para carregar todas as classes disponíveis no diretório java_installation / java / io -

import java.io.*;

Um estudo de caso simples

Para nosso estudo de caso, criaremos duas classes. Eles são Employee e EmployeeTest.

Primeiro abra o bloco de notas e adicione o seguinte código. Lembre-se de que esta é a classe Employee e a classe é uma classe pública. Agora, salve este arquivo de origem com o nome Employee.java.

A classe Employee tem quatro variáveis ​​de instância - nome, idade, designação e salário. A classe tem um construtor definido explicitamente, que recebe um parâmetro.

Exemplo

import java.io.*;
public class Employee {

   String name;
   int age;
   String designation;
   double salary;

   // This is the constructor of the class Employee
   public Employee(String name) {
      this.name = name;
   }

   // Assign the age of the Employee  to the variable age.
   public void empAge(int empAge) {
      age = empAge;
   }

   /* Assign the designation to the variable designation.*/
   public void empDesignation(String empDesig) {
      designation = empDesig;
   }

   /* Assign the salary to the variable	salary.*/
   public void empSalary(double empSalary) {
      salary = empSalary;
   }

   /* Print the Employee details */
   public void printEmployee() {
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

Conforme mencionado anteriormente neste tutorial, o processamento começa a partir do método principal. Portanto, para que possamos executar essa classe Employee, deve haver um método principal e os objetos devem ser criados. Estaremos criando uma classe separada para essas tarefas.

A seguir está a classe EmployeeTest , que cria duas instâncias da classe Employee e invoca os métodos de cada objeto para atribuir valores a cada variável.

Salve o código a seguir no arquivo EmployeeTest.java.

import java.io.*;
public class EmployeeTest {

   public static void main(String args[]) {
      /* Create two objects using constructor */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // Invoking methods for each object created
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

Agora, compile ambas as classes e execute EmployeeTest para ver o resultado da seguinte maneira -

Resultado

C:\> javac Employee.java
C:\> javac EmployeeTest.java
C:\> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0

O que vem a seguir?

Na próxima sessão, discutiremos os tipos de dados básicos em Java e como eles podem ser usados ​​ao desenvolver aplicativos Java.

Um construtor inicializa um objeto quando ele é criado. Ele tem o mesmo nome de sua classe e é sintaticamente semelhante a um método. No entanto, os construtores não têm um tipo de retorno explícito.

Normalmente, você usará um construtor para fornecer valores iniciais às variáveis ​​de instância definidas pela classe ou para realizar qualquer outro procedimento de inicialização necessário para criar um objeto totalmente formado.

Todas as classes têm construtores, quer você defina um ou não, porque Java fornece automaticamente um construtor padrão que inicializa todas as variáveis ​​de membro para zero. No entanto, depois de definir seu próprio construtor, o construtor padrão não é mais usado.

Sintaxe

A seguir está a sintaxe de um construtor -

class ClassName {
   ClassName() {
   }
}

Java permite dois tipos de construtores, a saber -

• Sem argumento Construtores
• Construtores parametrizados

Sem argumento Construtores

Como o nome especifica que os construtores sem argumento de Java não aceitam quaisquer parâmetros em vez disso, usando esses construtores, as variáveis ​​de instância de um método serão inicializadas com valores fixos para todos os objetos.

Exemplo

Public class MyClass {
   Int num;
   MyClass() {
      num = 100;
   }
}

Você chamaria construtor para inicializar objetos da seguinte maneira

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.num + " " + t2.num);
   }
}

Isso produziria o seguinte resultado

100 100

Construtores parametrizados

Na maioria das vezes, você precisará de um construtor que aceite um ou mais parâmetros. Os parâmetros são adicionados a um construtor da mesma forma que são adicionados a um método, bastando declará-los dentro dos parênteses após o nome do construtor.

Exemplo

Aqui está um exemplo simples que usa um construtor -

// A simple constructor.
class MyClass {
   int x;
   
   // Following is the constructor
   MyClass(int i ) {
      x = i;
   }
}

Você chamaria construtor para inicializar objetos da seguinte maneira -

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass( 10 );
      MyClass t2 = new MyClass( 20 );
      System.out.println(t1.x + " " + t2.x);
   }
}

Isso produziria o seguinte resultado -

10 20

As variáveis ​​nada mais são do que locais de memória reservados para armazenar valores. Isso significa que, ao criar uma variável, você reserva algum espaço na memória.

Com base no tipo de dados de uma variável, o sistema operacional aloca memória e decide o que pode ser armazenado na memória reservada. Portanto, ao atribuir diferentes tipos de dados a variáveis, você pode armazenar números inteiros, decimais ou caracteres nessas variáveis.

Existem dois tipos de dados disponíveis em Java -

• Tipos de dados primitivos
• Tipos de dados de referência / objeto

Tipos de dados primitivos

Existem oito tipos de dados primitivos suportados por Java. Tipos de dados primitivos são predefinidos pela linguagem e nomeados por uma palavra-chave. Vamos agora examinar detalhadamente os oito tipos de dados primitivos.

byte

• O tipo de dado byte é um número inteiro de complemento de dois com sinal de 8 bits

• O valor mínimo é -128 (-2 ^ 7)

• O valor máximo é 127 (inclusive) (2 ^ 7 -1)

• O valor padrão é 0

• O tipo de dados byte é usado para economizar espaço em grandes arrays, principalmente no lugar de inteiros, já que um byte é quatro vezes menor que um inteiro.

• Exemplo: byte a = 100, byte b = -50

baixo

• O tipo de dados curto é um inteiro complementar de dois com sinal de 16 bits

• O valor mínimo é -32.768 (-2 ^ 15)

• O valor máximo é 32.767 (inclusive) (2 ^ 15 -1)

• O tipo de dados curto também pode ser usado para economizar memória como tipo de dados de byte. Um curto é 2 vezes menor que um inteiro

• O valor padrão é 0.

• Exemplo: s curto = 10000, r curto = -20000

int

• O tipo de dados Int é um inteiro complemento de dois com sinal de 32 bits.

• O valor mínimo é - 2.147.483.648 (-2 ^ 31)

• O valor máximo é 2.147.483.647 (inclusive) (2 ^ 31 -1)

• Inteiro é geralmente usado como o tipo de dados padrão para valores integrais, a menos que haja uma preocupação com a memória.

• O valor padrão é 0

• Exemplo: int a = 100000, int b = -200000

grandes

• O tipo de dados longo é um inteiro complementar de dois com sinal de 64 bits
• O valor mínimo é -9.223.372.036.854.775.808 (-2 ^ 63)
• O valor máximo é 9.223.372.036.854.775.807 (inclusive) (2 ^ 63 -1)
• Este tipo é usado quando um intervalo mais amplo do que o int é necessário
• O valor padrão é 0L
• Exemplo: long a = 100000L, long b = -200000L

flutuador

• O tipo de dados flutuante é um ponto flutuante IEEE 754 de 32 bits de precisão única

• Floaté usado principalmente para economizar memória em grandes matrizes de números de ponto flutuante

• O valor padrão é 0.0f

• O tipo de dados flutuante nunca é usado para valores precisos, como moeda

• Exemplo: float f1 = 234,5f

em dobro

• tipo de dados duplo é um ponto flutuante IEEE 754 de 64 bits de precisão dupla

• Este tipo de dados é geralmente usado como o tipo de dados padrão para valores decimais, geralmente a escolha padrão

• O tipo de dados duplo nunca deve ser usado para valores precisos, como moeda

• O valor padrão é 0,0d

• Exemplo: double d1 = 123,4

boleano

• tipo de dado booleano representa um bit de informação
• Existem apenas dois valores possíveis: verdadeiro e falso
• Este tipo de dados é usado para sinalizadores simples que rastreiam condições verdadeiras / falsas
• O valor padrão é falso
• Exemplo: boolean one = true

Caracteres

• tipo de dados char é um único caractere Unicode de 16 bits
• O valor mínimo é '\ u0000' (ou 0)
• O valor máximo é '\ uffff' (ou 65.535 inclusive)
• O tipo de dados char é usado para armazenar qualquer caractere
• Exemplo: char letterA = 'A'

Tipos de dados de referência

• Variáveis ​​de referência são criadas usando construtores definidos das classes. Eles são usados ​​para acessar objetos. Essas variáveis ​​são declaradas de um tipo específico que não pode ser alterado. Por exemplo, Funcionário, Cachorro, etc.

• Objetos de classe e vários tipos de variáveis ​​de matriz vêm sob o tipo de dados de referência.

• O valor padrão de qualquer variável de referência é nulo.

• Uma variável de referência pode ser usada para referir-se a qualquer objeto do tipo declarado ou qualquer tipo compatível.

• Exemplo: Animal animal = novo Animal ("girafa");

Literais Java

Um literal é uma representação do código-fonte de um valor fixo. Eles são representados diretamente no código, sem qualquer cálculo.

Literais podem ser atribuídos a qualquer variável de tipo primitivo. Por exemplo -

byte a = 68;
char a = 'A';

byte, int, long e short podem ser expressos em sistemas numéricos decimais (base 10), hexadecimais (base 16) ou octais (base 8).

O prefixo 0 é usado para indicar octal e o prefixo 0x indica hexadecimal ao usar esses sistemas numéricos para literais. Por exemplo -

int decimal = 100;
int octal = 0144;
int hexa =  0x64;

Literais de string em Java são especificados como na maioria das outras linguagens, colocando uma sequência de caracteres entre um par de aspas duplas. Exemplos de literais de string são -

Exemplo

"Hello World"
"two\nlines"
"\"This is in quotes\""

Os tipos de literal de string e char podem conter qualquer caractere Unicode. Por exemplo -

char a = '\u0001';
String a = "\u0001";

A linguagem Java também oferece suporte a algumas sequências de escape especiais para literais String e char. Eles são -

Notação	Personagem representado
\ n	Nova linha (0x0a)
\ r	Retorno de carro (0x0d)
\ f	Formfeed (0x0c)
\ b	Backspace (0x08)
\ s	Espaço (0x20)
\ t	aba
\ "	Citação dupla
\ '	Citação única
\\	barra invertida
\ ddd	Caráter octal (ddd)
\ uxxxx	Caráter UNICODE hexadecimal (xxxx)

O que vem a seguir?

Este capítulo explicou os vários tipos de dados. O próximo tópico explica os diferentes tipos de variáveis ​​e seu uso. Isso lhe dará um bom entendimento de como eles podem ser usados ​​nas classes Java, interfaces, etc.

Uma variável nos fornece armazenamento nomeado que nossos programas podem manipular. Cada variável em Java possui um tipo específico, que determina o tamanho e o layout da memória da variável; a faixa de valores que podem ser armazenados nessa memória; e o conjunto de operações que podem ser aplicadas à variável.

Você deve declarar todas as variáveis ​​antes que elas possam ser usadas. A seguir está a forma básica de uma declaração de variável -

data type variable [ = value][, variable [ = value] ...] ;

Aqui, tipo de dados é um dos tipos de dados Java e variável é o nome da variável. Para declarar mais de uma variável do tipo especificado, você pode usar uma lista separada por vírgulas.

A seguir estão exemplos válidos de declaração de variável e inicialização em Java -

Exemplo

int a, b, c;         // Declares three ints, a, b, and c.
int a = 10, b = 10;  // Example of initialization
byte B = 22;         // initializes a byte type variable B.
double pi = 3.14159; // declares and assigns a value of PI.
char a = 'A';        // the char variable a iis initialized with value 'a'

Este capítulo irá explicar vários tipos de variáveis ​​disponíveis na linguagem Java. Existem três tipos de variáveis ​​em Java -

• Variáveis ​​locais
• Variáveis ​​de instância
• Variáveis ​​de classe / estáticas

Variáveis ​​Locais

• Variáveis ​​locais são declaradas em métodos, construtores ou blocos.

• Variáveis ​​locais são criadas quando o método, construtor ou bloco é inserido e a variável será destruída assim que sair do método, construtor ou bloco.

• Os modificadores de acesso não podem ser usados ​​para variáveis ​​locais.

• Variáveis ​​locais são visíveis apenas dentro do método declarado, construtor ou bloco.

• Variáveis ​​locais são implementadas internamente no nível da pilha.

• Não há valor padrão para variáveis ​​locais, então as variáveis ​​locais devem ser declaradas e um valor inicial deve ser atribuído antes do primeiro uso.

Exemplo

Aqui, a idade é uma variável local. Isso é definido dentro do método pupAge () e seu escopo é limitado apenas a este método.

public class Test {
   public void pupAge() {
      int age = 0;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

Isso produzirá o seguinte resultado -

Resultado

Puppy age is: 7

Exemplo

O exemplo a seguir usa o age sem inicializá-lo, portanto, haveria um erro no momento da compilação.

public class Test {
   public void pupAge() {
      int age;
      age = age + 7;
      System.out.println("Puppy age is : " + age);
   }

   public static void main(String args[]) {
      Test test = new Test();
      test.pupAge();
   }
}

Isso produzirá o seguinte erro ao compilá-lo -

Resultado

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

Variáveis ​​de instância

• Variáveis ​​de instância são declaradas em uma classe, mas fora de um método, construtor ou qualquer bloco.

• Quando um espaço é alocado para um objeto no heap, um slot para cada valor de variável de instância é criado.

• Variáveis ​​de instância são criadas quando um objeto é criado com o uso da palavra-chave 'novo' e destruídas quando o objeto é destruído.

• Variáveis ​​de instância contêm valores que devem ser referenciados por mais de um método, construtor ou bloco, ou partes essenciais do estado de um objeto que devem estar presentes em toda a classe.

• Variáveis ​​de instância podem ser declaradas em nível de classe antes ou depois do uso.

• Modificadores de acesso podem ser fornecidos para variáveis ​​de instância.

• As variáveis ​​de instância são visíveis para todos os métodos, construtores e bloco da classe. Normalmente, é recomendável tornar essas variáveis ​​privadas (nível de acesso). No entanto, a visibilidade para subclasses pode ser dada para essas variáveis ​​com o uso de modificadores de acesso.

• Variáveis ​​de instância têm valores padrão. Para números, o valor padrão é 0, para booleanos é falso e para referências de objetos é nulo. Os valores podem ser atribuídos durante a declaração ou no construtor.

• Variáveis ​​de instância podem ser acessadas diretamente chamando o nome da variável dentro da classe. No entanto, em métodos estáticos (quando as variáveis ​​de instância são acessadas), eles devem ser chamados usando o nome totalmente qualificado. ObjectReference.VariableName .

Exemplo

import java.io.*;
public class Employee {

   // this instance variable is visible for any child class.
   public String name;

   // salary  variable is visible in Employee class only.
   private double salary;

   // The name variable is assigned in the constructor.
   public Employee (String empName) {
      name = empName;
   }

   // The salary variable is assigned a value.
   public void setSalary(double empSal) {
      salary = empSal;
   }

   // This method prints the employee details.
   public void printEmp() {
      System.out.println("name  : " + name );
      System.out.println("salary :" + salary);
   }

   public static void main(String args[]) {
      Employee empOne = new Employee("Ransika");
      empOne.setSalary(1000);
      empOne.printEmp();
   }
}

Isso produzirá o seguinte resultado -

Resultado

name  : Ransika
salary :1000.0

Variáveis ​​de classe / estáticas

• Variáveis ​​de classe também conhecidas como variáveis ​​estáticas são declaradas com a palavra-chave static em uma classe, mas fora de um método, construtor ou bloco.

• Haveria apenas uma cópia de cada variável de classe por classe, independentemente de quantos objetos são criados a partir dela.

• Variáveis ​​estáticas raramente são usadas além de serem declaradas como constantes. Constantes são variáveis ​​declaradas como públicas / privadas, finais e estáticas. Variáveis ​​constantes nunca mudam de seu valor inicial.

• Variáveis ​​estáticas são armazenadas na memória estática. É raro usar variáveis ​​estáticas diferentes das declaradas finais e usadas como constantes públicas ou privadas.

• Variáveis ​​estáticas são criadas quando o programa é iniciado e destruídas quando o programa é interrompido.

• A visibilidade é semelhante às variáveis ​​de instância. No entanto, a maioria das variáveis ​​estáticas são declaradas públicas, pois devem estar disponíveis para os usuários da classe.

• Os valores padrão são iguais às variáveis ​​de instância. Para números, o valor padrão é 0; para os booleanos, é falso; e para referências de objeto, é nulo. Os valores podem ser atribuídos durante a declaração ou no construtor. Além disso, os valores podem ser atribuídos em blocos inicializadores estáticos especiais.

• Variáveis ​​estáticas podem ser acessadas chamando com o nome de classe ClassName.VariableName .

• Ao declarar as variáveis ​​de classe como public static final, os nomes das variáveis ​​(constantes) estão todos em maiúsculas. Se as variáveis ​​estáticas não forem públicas e finais, a sintaxe de nomenclatura será a mesma que as variáveis ​​de instância e locais.

Exemplo

import java.io.*;
public class Employee {

   // salary  variable is a private static variable
   private static double salary;

   // DEPARTMENT is a constant
   public static final String DEPARTMENT = "Development ";

   public static void main(String args[]) {
      salary = 1000;
      System.out.println(DEPARTMENT + "average salary:" + salary);
   }
}

Isso produzirá o seguinte resultado -

Resultado

Development average salary:1000

Note - Se as variáveis ​​forem acessadas de uma classe externa, a constante deve ser acessada como Employee.DEPARTMENT

O que vem a seguir?

Você já usou modificadores de acesso (público e privado) neste capítulo. O próximo capítulo explicará os modificadores de acesso e modificadores de não acesso em detalhes.

Modificadores são palavras-chave que você adiciona a essas definições para alterar seus significados. A linguagem Java tem uma grande variedade de modificadores, incluindo o seguinte -

• Modificadores de acesso Java

• Modificadores sem acesso

Para usar um modificador, você inclui sua palavra-chave na definição de uma classe, método ou variável. O modificador precede o resto da instrução, como no exemplo a seguir.

Exemplo

public class className {
   // ...
}

private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;

public static void main(String[] arguments) {
   // body of method
}

Modificadores de controle de acesso

Java fornece vários modificadores de acesso para definir níveis de acesso para classes, variáveis, métodos e construtores. Os quatro níveis de acesso são -

• Visível para o pacote, o padrão. Nenhum modificador é necessário.
• Visível apenas para a classe (particular).
• Visível para o mundo (público).
• Visível para o pacote e todas as subclasses (protegidas).

Modificadores sem acesso

Java fornece vários modificadores sem acesso para alcançar muitas outras funcionalidades.

• O modificador estático para criar métodos e variáveis ​​de classe.

• O modificador final para finalizar as implementações de classes, métodos e variáveis.

• O modificador abstrato para criar classes e métodos abstratos.

• Os modificadores sincronizados e voláteis , usados ​​para threads.

O que vem a seguir?

Na próxima seção, discutiremos sobre Operadores básicos usados ​​na linguagem Java. O capítulo fornecerá uma visão geral de como esses operadores podem ser usados ​​durante o desenvolvimento de aplicativos.

Java fornece um rico conjunto de operadores para manipular variáveis. Podemos dividir todos os operadores Java nos seguintes grupos -

• Operadores aritméticos
• Operadores Relacionais
• Operadores bit a bit
• Operadores lógicos
• Operadores de atribuição
• Operadores diversos

Os operadores aritméticos

Operadores aritméticos são usados ​​em expressões matemáticas da mesma forma que são usados ​​em álgebra. A tabela a seguir lista os operadores aritméticos -

Assuma que a variável inteira A contém 10 e a variável B contém 20, então -

Mostrar exemplos

Operador	Descrição	Exemplo
+ (Adição)	Adiciona valores em qualquer lado do operador.	A + B dará 30
- (Subtração)	Subtrai o operando direito do operando esquerdo.	A - B dará -10
* (Multiplicação)	Multiplica os valores em cada lado do operador.	A * B dará 200
/ (Divisão)	Divide operando à esquerda pelo operando à direita.	B / A dará 2
% (Módulo)	Divide o operando esquerdo pelo operando direito e retorna o resto.	B% A dará 0
++ (incremento)	Aumenta o valor do operando em 1.	B ++ dá 21
- (diminuir)	Diminui o valor do operando em 1.	B-- dá 19

Os operadores relacionais

Existem os seguintes operadores relacionais suportados pela linguagem Java.

Suponha que a variável A tenha 10 e a variável B tenha 20, então -

Mostrar exemplos

Operador	Descrição	Exemplo
== (igual a)	Verifica se os valores dos dois operandos são iguais ou não, se sim a condição torna-se verdadeira.	(A == B) não é verdade.
! = (diferente de)	Verifica se os valores de dois operandos são iguais ou não, se os valores não são iguais, a condição se torna verdadeira.	(A! = B) é verdade.
> (maior que)	Verifica se o valor do operando esquerdo é maior que o valor do operando direito, se sim então a condição torna-se verdadeira.	(A> B) não é verdade.
<(menos que)	Verifica se o valor do operando esquerdo é menor que o valor do operando direito; se sim, a condição torna-se verdadeira.	(A <B) é verdade.
> = (maior ou igual a)	Verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se sim a condição torna-se verdadeira.	(A> = B) não é verdade.
<= (menor ou igual a)	Verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito; em caso afirmativo, a condição torna-se verdadeira.	(A <= B) é verdadeiro.

Os operadores bit a bit

Java define vários operadores bit a bit, que podem ser aplicados aos tipos inteiros, long, int, short, char e byte.

O operador bit a bit funciona em bits e executa a operação bit a bit. Suponha que a = 60 e b = 13; agora em formato binário serão os seguintes -

a = 0011 1100

b = 0000 1101

-----------------

a & b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~ a = 1100 0011

A tabela a seguir lista os operadores bit a bit -

Assuma que a variável inteira A contém 60 e a variável B contém 13, então -

Mostrar exemplos

Operador	Descrição	Exemplo
& (bit a bit e)	O operador Binário AND copia um bit para o resultado se ele existir em ambos os operandos.	(A e B) dará 12, que é 0000 1100
| (bit a bit ou)	O operador binário OR copia um bit se ele existir em qualquer operando.	(A | B) dará 61, que é 0011 1101
^ (XOR bit a bit)	O operador binário XOR copia o bit se estiver definido em um operando, mas não em ambos.	(A ^ B) dará 49, que é 0011 0001
~ (elogio bit a bit)	O operador de complemento binários é unário e tem o efeito de 'inverter' bits.	(~ A) dará -61 que é 1100 0011 na forma de complemento de 2 devido a um número binário com sinal.
<< (deslocamento para a esquerda)	Operador binário de deslocamento à esquerda. O valor dos operandos à esquerda é movido para a esquerda pelo número de bits especificado pelo operando à direita.	Um << 2 dará 240, que é 1111 0000
>> (deslocamento para a direita)	Operador binário de deslocamento à direita. O valor dos operandos à esquerda é movido para a direita pelo número de bits especificado pelo operando à direita.	Um >> 2 dará 15 que é 1111
>>> (preenchimento zero deslocamento à direita)	Desloque o operador de preenchimento de zero para a direita. O valor dos operandos à esquerda é movido para a direita pelo número de bits especificado pelo operando à direita e os valores deslocados são preenchidos com zeros.	Um >>> 2 dará 15, que é 0000 1111

Os operadores lógicos

A tabela a seguir lista os operadores lógicos -

Suponha que as variáveis ​​booleanas A sejam verdadeiras e a variável B sejam falsas, então -

Mostrar exemplos

Operador	Descrição	Exemplo
&& (lógico e)	Operador lógico chamado AND. Se ambos os operandos forem diferentes de zero, a condição se torna verdadeira.	(A && B) é falso
|| (lógico ou)	Operador lógico ou chamado. Se qualquer um dos dois operandos for diferente de zero, a condição se torna verdadeira.	(A || B) é verdade
! (lógico não)	Operador lógico chamado NOT. Use para reverter o estado lógico de seu operando. Se uma condição for verdadeira, o operador NOT lógico tornará falso.	! (A && B) é verdade

Os operadores de atribuição

A seguir estão os operadores de atribuição suportados pela linguagem Java -

Mostrar exemplos

Operador	Descrição	Exemplo
=	Operador de atribuição simples. Atribui valores de operandos do lado direito para operando do lado esquerdo.	C = A + B irá atribuir o valor de A + B em C
+ =	Adicionar operador de atribuição AND. Ele adiciona o operando direito ao operando esquerdo e atribui o resultado ao operando esquerdo.	C + = A é equivalente a C = C + A
- =	Subtraia o operador de atribuição. Ele subtrai o operando direito do operando esquerdo e atribui o resultado ao operando esquerdo.	C - = A é equivalente a C = C - A
* =	Operador de atribuição Multiply AND. Ele multiplica o operando direito pelo operando esquerdo e atribui o resultado ao operando esquerdo.	C * = A é equivalente a C = C * A
/ =	Operador de divisão AND atribuição. Ele divide o operando esquerdo com o operando direito e atribui o resultado ao operando esquerdo.	C / = A é equivalente a C = C / A
% =	Módulo E operador de atribuição. Leva o módulo usando dois operandos e atribui o resultado ao operando esquerdo.	C% = A é equivalente a C = C% A
<< =	Deslocamento à esquerda E operador de atribuição.	C << = 2 é igual a C = C << 2
>> =	Deslocamento à direita E operador de atribuição.	C >> = 2 é igual a C = C >> 2
& =	Operador de atribuição AND bit a bit.	C & = 2 é igual a C = C & 2
^ =	OR exclusivo bit a bit e operador de atribuição.	C ^ = 2 é igual a C = C ^ 2
| =	OR inclusivo bit a bit e operador de atribuição.	C | = 2 é igual a C = C | 2

Operadores diversos

Existem alguns outros operadores suportados pela linguagem Java.

Operador condicional (?:)

O operador condicional também é conhecido como o ternary operator. Este operador consiste em três operandos e é usado para avaliar expressões booleanas. O objetivo do operador é decidir qual valor deve ser atribuído à variável. O operador é escrito como -

variable x = (expression) ? value if true : value if false

A seguir está um exemplo -

Example

public class Test {

   public static void main(String args[]) {
      int a, b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );
   }
}

Isso produzirá o seguinte resultado -

Output

Value of b is : 30
Value of b is : 20

instanceof Operator

Este operador é usado apenas para variáveis ​​de referência de objeto. O operador verifica se o objeto é de um tipo específico (tipo de classe ou tipo de interface). operador instanceof é escrito como -

( Object reference variable ) instanceof  (class/interface type)

Se o objeto referido pela variável no lado esquerdo do operador passar na verificação IS-A para o tipo de classe / interface no lado direito, o resultado será verdadeiro. A seguir está um exemplo -

Example

public class Test {

   public static void main(String args[]) {

      String name = "James";

      // following will return true since name is type of String
      boolean result = name instanceof String;
      System.out.println( result );
   }
}

Isso produzirá o seguinte resultado -

Output

true

Este operador ainda retornará verdadeiro, se o objeto que está sendo comparado for a atribuição compatível com o tipo à direita. A seguir está mais um exemplo -

Example

class Vehicle {}

public class Car extends Vehicle {

   public static void main(String args[]) {

      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );
   }
}

Isso produzirá o seguinte resultado -

Output

true

Precedência de operadores Java

A precedência do operador determina o agrupamento de termos em uma expressão. Isso afeta como uma expressão é avaliada. Certos operadores têm precedência mais alta do que outros; por exemplo, o operador de multiplicação tem precedência mais alta do que o operador de adição -

Por exemplo, x = 7 + 3 * 2; aqui, x é atribuído a 13, não 20, porque o operador * tem precedência mais alta que +, então ele primeiro é multiplicado por 3 * 2 e, em seguida, é adicionado por 7.

Aqui, os operadores com a precedência mais alta aparecem na parte superior da tabela, aqueles com a mais baixa aparecem na parte inferior. Em uma expressão, os operadores de precedência superior serão avaliados primeiro.

Categoria	Operador	Associatividade
Postfix	expressão ++ expressão--	Da esquerda para direita
Unário	++ expressão –- expressão + expressão –expressão ~!	Direita para esquerda
Multiplicativo	* /%	Da esquerda para direita
Aditivo	+ -	Da esquerda para direita
Mudança	<< >> >>>	Da esquerda para direita
Relacional	<> <=> = instância	Da esquerda para direita
Igualdade	==! =	Da esquerda para direita
E bit a bit	E	Da esquerda para direita
XOR bit a bit	^	Da esquerda para direita
OR bit a bit	|	Da esquerda para direita
E lógico	&&	Da esquerda para direita
OR lógico	||	Da esquerda para direita
Condicional	?:	Direita para esquerda
Tarefa	= + = - = * = / =% = ^ = | = << = >> = >>> =	Direita para esquerda

O que vem a seguir?

O próximo capítulo explicará sobre o controle de loop na programação Java. O capítulo descreverá vários tipos de loops e como esses loops podem ser usados ​​no desenvolvimento de programas Java e para quais propósitos eles estão sendo usados.

Pode haver uma situação em que você precise executar um bloco de código várias vezes. Em geral, as instruções são executadas sequencialmente: a primeira instrução em uma função é executada primeiro, seguida pela segunda e assim por diante.

As linguagens de programação fornecem várias estruturas de controle que permitem caminhos de execução mais complicados.

UMA loop declaração nos permite executar uma declaração ou grupo de declarações várias vezes e a seguir está a forma geral de uma declaração de loop na maioria das linguagens de programação -

A linguagem de programação Java fornece os seguintes tipos de loop para lidar com os requisitos de loop. Clique nos links a seguir para verificar seus detalhes.

Sr. Não.	Loop e descrição
1	loop while Repete uma declaração ou grupo de declarações enquanto uma determinada condição for verdadeira. Ele testa a condição antes de executar o corpo do loop.
2	para loop Execute uma sequência de instruções várias vezes e abrevia o código que gerencia a variável de loop.
3	fazer ... loop while Como uma instrução while, exceto que testa a condição no final do corpo do loop.

Declarações de controle de loop

As instruções de controle de loop alteram a execução de sua sequência normal. Quando a execução deixa um escopo, todos os objetos automáticos que foram criados nesse escopo são destruídos.

Java oferece suporte às seguintes instruções de controle. Clique nos links a seguir para verificar seus detalhes.

Sr. Não.	Declaração de controle e descrição
1	declaração de quebra Termina o loop ou switch instrução e transfere a execução para a instrução imediatamente após o loop ou switch.
2	continuar declaração Faz com que o loop pule o restante de seu corpo e teste novamente sua condição imediatamente antes de reiterar.

Aprimorado para loop em Java

A partir do Java 5, o loop for aprimorado foi introduzido. Isso é usado principalmente para percorrer a coleção de elementos, incluindo matrizes.

Sintaxe

A seguir está a sintaxe de loop for aprimorado -

for(declaration : expression) {
   // Statements
}

• Declaration- A variável de bloco recém-declarada é de um tipo compatível com os elementos do array que você está acessando. A variável estará disponível dentro do bloco for e seu valor seria o mesmo que o elemento atual do array.

• Expression- Isso avalia a matriz pela qual você precisa fazer o loop. A expressão pode ser uma variável de matriz ou chamada de método que retorna uma matriz.

Exemplo

public class Test {

   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names = {"James", "Larry", "Tom", "Lacy"};

      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

Isso produzirá o seguinte resultado -

Resultado

10, 20, 30, 40, 50,
James, Larry, Tom, Lacy,

O que vem a seguir?

No capítulo seguinte, aprenderemos sobre as declarações de tomada de decisão na programação Java.

As estruturas de tomada de decisão têm uma ou mais condições a serem avaliadas ou testadas pelo programa, junto com uma declaração ou declarações que devem ser executadas se a condição for determinada como verdadeira e, opcionalmente, outras declarações a serem executadas se a condição for determinada para ser falso.

A seguir está a forma geral de uma estrutura típica de tomada de decisão encontrada na maioria das linguagens de programação -

A linguagem de programação Java fornece os seguintes tipos de declarações de tomada de decisão. Clique nos links a seguir para verificar seus detalhes.

Sr. Não.	Declaração e descrição
1	declaração if A if statement consiste em uma expressão booleana seguida por uma ou mais instruções.
2	declaração if ... else A if statement pode ser seguido por um opcional else statement, que é executado quando a expressão booleana é falsa.
3	declaração if aninhada Você pode usar um if ou else if declaração dentro de outra if ou else if afirmações).
4	declaração switch UMA switch instrução permite que uma variável seja testada quanto à igualdade em relação a uma lista de valores.

O ? : Operador

Nós cobrimos conditional operator ? : no capítulo anterior, que pode ser usado para substituir if...elseafirmações. Tem a seguinte forma geral -

Exp1 ? Exp2 : Exp3;

Onde Exp1, Exp2 e Exp3 são expressões. Observe o uso e a localização do cólon.

Para determinar o valor de toda a expressão, inicialmente exp1 é avaliado.

• Se o valor de exp1 for verdadeiro, o valor de Exp2 será o valor de toda a expressão.

• Se o valor de exp1 for falso, então Exp3 será avaliado e seu valor se tornará o valor de toda a expressão.

O que vem a seguir?

No próximo capítulo, discutiremos sobre a classe Number (no pacote java.lang) e suas subclasses na linguagem Java.

Estaremos examinando algumas das situações em que você usará instanciações dessas classes em vez dos tipos de dados primitivos, bem como classes como formatação, funções matemáticas que você precisa saber ao trabalhar com o Numbers.

Normalmente, quando trabalhamos com Numbers, usamos tipos de dados primitivos, como byte, int, long, double, etc.

Exemplo

int i = 5000;
float gpa = 13.65f;
double mask = 125;

No entanto, no desenvolvimento, encontramos situações em que precisamos usar objetos em vez de tipos de dados primitivos. Para conseguir isso, Java fornecewrapper classes.

Todas as classes de wrapper (Inteiro, Longo, Byte, Duplo, Flutuante, Curto) são subclasses da classe abstrata Número.

O objeto da classe wrapper contém ou envolve seu respectivo tipo de dados primitivo. A conversão de tipos de dados primitivos em objetos é chamadaboxing, e isso é cuidado pelo compilador. Portanto, ao usar uma classe Wrapper, você só precisa passar o valor do tipo de dados primitivo para o construtor da classe Wrapper.

E o objeto Wrapper será convertido de volta em um tipo de dados primitivo, e esse processo é chamado de unboxing. oNumber classe faz parte do pacote java.lang.

A seguir está um exemplo de boxing e unboxing -

Exemplo

public class Test {

   public static void main(String args[]) {
      Integer x = 5; // boxes int to an Integer object
      x =  x + 10;   // unboxes the Integer to a int
      System.out.println(x); 
   }
}

Isso produzirá o seguinte resultado -

Resultado

15

Quando x é atribuído a um valor inteiro, o compilador encaixota o inteiro porque x é um objeto inteiro. Posteriormente, x é desempacotado para que possam ser adicionados como um inteiro.

Métodos Numéricos

A seguir está a lista dos métodos de instância que todas as subclasses da classe Number implementam -

Sr. Não.	Método e Descrição
1	xxxValue () Converte o valor deste objeto Number no tipo de dados xxx e o retorna.
2	comparado a() Compara este objeto Number com o argumento.
3	é igual a() Determina se este objeto de número é igual ao argumento.
4	valor de() Retorna um objeto Integer contendo o valor da primitiva especificada.
5	para sequenciar() Retorna um objeto String que representa o valor de um int ou Integer especificado.
6	parseInt () Este método é usado para obter o tipo de dados primitivo de uma determinada String.
7	abdômen() Retorna o valor absoluto do argumento.
8	ceil () Retorna o menor inteiro maior ou igual ao argumento. Retornado em dobro.
9	chão() Retorna o maior número inteiro menor ou igual ao argumento. Retornado em dobro.
10	rint () Retorna o número inteiro mais próximo em valor ao argumento. Retornado em dobro.
11	volta() Retorna o long ou int mais próximo, conforme indicado pelo tipo de retorno do método para o argumento.
12	min () Retorna o menor dos dois argumentos.
13	max () Retorna o maior dos dois argumentos.
14	exp () Retorna a base dos logaritmos naturais, e, para a potência do argumento.
15	registro() Retorna o logaritmo natural do argumento.
16	Pancada() Retorna o valor do primeiro argumento elevado à potência do segundo argumento.
17	sqrt () Retorna a raiz quadrada do argumento.
18	pecado() Retorna o seno do valor duplo especificado.
19	cos () Retorna o cosseno do valor duplo especificado.
20	bronzeado() Retorna a tangente do valor duplo especificado.
21	como em() Retorna o arco seno do valor duplo especificado.
22	acos () Retorna o arco cosseno do valor duplo especificado.
23	numa() Retorna o arco tangente do valor duplo especificado.
24	atan2 () Converte coordenadas retangulares (x, y) em coordenadas polares (r, theta) e retorna theta.
25	toDegrees () Converte o argumento em graus.
26	toRadians () Converte o argumento em radianos.
27	aleatória() Retorna um número aleatório.

O que vem a seguir?

Na próxima seção, veremos a classe Character em Java. Você aprenderá como usar caracteres de objeto e tipo de dados primitivo char em Java.

Normalmente, quando trabalhamos com caracteres, usamos tipos de dados primitivos char.

Exemplo

char ch = 'a';

// Unicode for uppercase Greek omega character
char uniChar = '\u039A'; 

// an array of chars
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

No entanto, no desenvolvimento, encontramos situações em que precisamos usar objetos em vez de tipos de dados primitivos. Para conseguir isso, o Java fornece uma classe de wrapperCharacter para o tipo de dados primitivo char.

A classe Character oferece vários métodos de classe úteis (isto é, estáticos) para manipular caracteres. Você pode criar um objeto Character com o construtor Character -

Character ch = new Character('a');

O compilador Java também criará um objeto Character para você em algumas circunstâncias. Por exemplo, se você passar um char primitivo para um método que espera um objeto, o compilador converte automaticamente o char em um Character para você. Esse recurso é chamado de autoboxing ou unboxing, se a conversão ocorrer de outra forma.

Exemplo

// Here following primitive char 'a'
// is boxed into the Character object ch
Character ch = 'a';

// Here primitive 'x' is boxed for method test,
// return is unboxed to char 'c'
char c = test('x');

Sequências de Escape

Um caractere precedido por uma barra invertida (\) é uma sequência de escape e tem um significado especial para o compilador.

O caractere de nova linha (\ n) foi usado com frequência neste tutorial em instruções System.out.println () para avançar para a próxima linha após a impressão da string.

A tabela a seguir mostra as sequências de escape Java -

Sequência de fuga	Descrição
\ t	Insere uma guia no texto neste ponto.
\ b	Insere um backspace no texto neste ponto.
\ n	Insere uma nova linha no texto neste ponto.
\ r	Insere um retorno de carro no texto neste ponto.
\ f	Insere um avanço de formulário no texto neste ponto.
\ '	Insere um caractere de aspas simples no texto neste ponto.
\ "	Insere um caractere de aspas duplas no texto neste ponto.
\\	Insere um caractere de barra invertida no texto neste ponto.

Quando uma seqüência de escape é encontrada em uma instrução de impressão, o compilador a interpreta de acordo.

Exemplo

Se você quiser colocar aspas entre aspas, você deve usar a sequência de escape, \ ", nas aspas interiores -

public class Test {

   public static void main(String args[]) {
      System.out.println("She said \"Hello!\" to me.");
   }
}

Isso produzirá o seguinte resultado -

Resultado

She said "Hello!" to me.

Métodos de personagem

A seguir está a lista dos métodos de instância importantes que todas as subclasses da classe Character implementam -

Sr. Não.	Método e Descrição
1	isLetter () Determina se o valor char especificado é uma letra.
2	isDigit () Determina se o valor de char especificado é um dígito.
3	isWhitespace () Determina se o valor de char especificado é um espaço em branco.
4	isUpperCase () Determina se o valor de char especificado é maiúsculo.
5	isLowerCase () Determina se o valor de char especificado está em minúsculas.
6	toUpperCase () Retorna a forma em maiúsculas do valor char especificado.
7	toLowerCase () Retorna a forma em minúsculas do valor char especificado.
8	para sequenciar() Retorna um objeto String que representa o valor do caractere especificado, ou seja, uma string de um caractere.

Para obter uma lista completa de métodos, consulte a especificação da API java.lang.Character.

O que vem a seguir?

Na próxima seção, examinaremos a classe String em Java. Você aprenderá como declarar e usar Strings com eficiência, bem como alguns dos métodos importantes na classe String.

Strings, amplamente utilizadas na programação Java, são uma sequência de caracteres. Na linguagem de programação Java, as strings são tratadas como objetos.

A plataforma Java fornece a classe String para criar e manipular strings.

Criando Strings

A maneira mais direta de criar uma string é escrever -

String greeting = "Hello world!";

Sempre que encontra um literal de string em seu código, o compilador cria um objeto String com seu valor neste caso, "Olá, mundo! '.

Como com qualquer outro objeto, você pode criar objetos String usando a nova palavra-chave e um construtor. A classe String tem 11 construtores que permitem fornecer o valor inicial da string usando fontes diferentes, como uma matriz de caracteres.

Exemplo

public class StringDemo {

   public static void main(String args[]) {
      char[] helloArray = { 'h', 'e', 'l', 'l', 'o', '.' };
      String helloString = new String(helloArray);  
      System.out.println( helloString );
   }
}

Isso produzirá o seguinte resultado -

Resultado

hello.

Note- A classe String é imutável, de modo que, uma vez criada, um objeto String não pode ser alterado. Se houver necessidade de fazer muitas modificações em Strings de caracteres, você deve usar String Buffer e String Builder Classes.

Comprimento da corda

Os métodos usados ​​para obter informações sobre um objeto são conhecidos como accessor methods. Um método de acesso que você pode usar com strings é o método length (), que retorna o número de caracteres contidos no objeto string.

O programa a seguir é um exemplo de length(), método da classe String.

Exemplo

public class StringDemo {

   public static void main(String args[]) {
      String palindrome = "Dot saw I was Tod";
      int len = palindrome.length();
      System.out.println( "String Length is : " + len );
   }
}

Isso produzirá o seguinte resultado -

Resultado

String Length is : 17

Strings de concatenação

A classe String inclui um método para concatenar duas strings -

string1.concat(string2);

Isso retorna uma nova string que é string1 com string2 adicionada a ela no final. Você também pode usar o método concat () com literais de string, como em -

"My name is ".concat("Zara");

Strings são mais comumente concatenadas com o operador +, como em -

"Hello," + " world" + "!"

que resulta em -

"Hello, world!"

Vejamos o seguinte exemplo -

Exemplo

public class StringDemo {

   public static void main(String args[]) {
      String string1 = "saw I was ";
      System.out.println("Dot " + string1 + "Tod");
   }
}

Isso produzirá o seguinte resultado -

Resultado

Dot saw I was Tod

Criação de strings de formato

Você tem os métodos printf () e format () para imprimir a saída com números formatados. A classe String tem um método de classe equivalente, format (), que retorna um objeto String em vez de um objeto PrintStream.

O uso do método estático format () de String permite criar uma string formatada que pode ser reutilizada, ao contrário de uma instrução de impressão única. Por exemplo, em vez de -

Exemplo

System.out.printf("The value of the float variable is " +
                  "%f, while the value of the integer " +
                  "variable is %d, and the string " +
                  "is %s", floatVar, intVar, stringVar);

Você pode escrever -

String fs;
fs = String.format("The value of the float variable is " +
                   "%f, while the value of the integer " +
                   "variable is %d, and the string " +
                   "is %s", floatVar, intVar, stringVar);
System.out.println(fs);

Métodos de String

Aqui está a lista de métodos suportados pela classe String -

Sr. Não.	Método e Descrição
1	char charAt (índice int) Retorna o caractere no índice especificado.
2	int compareTo (Objeto o) Compara esta String com outro objeto.
3	int compareTo (String anotherString) Compara duas strings lexicograficamente.
4	int compareToIgnoreCase (String str) Compara duas strings lexicograficamente, ignorando diferenças entre maiúsculas e minúsculas.
5	String concat (String str) Concatena a string especificada ao final desta string.
6	boolean contentEquals (StringBuffer sb) Retorna verdadeiro se e somente se esta String representa a mesma sequência de caracteres que o StringBuffer especificado.
7	static String copyValueOf (char [] data) Retorna um String que representa a seqüência de caracteres na matriz especificada.
8	static String copyValueOf (char [] data, int offset, int count) Retorna um String que representa a seqüência de caracteres na matriz especificada.
9	boolean endsWith (sufixo de string) Testa se esta string termina com o sufixo especificado.
10	boolean equals (objeto anObject) Compara esta string com o objeto especificado.
11	boolean equalsIgnoreCase (String anotherString) Compara esta String com outra String, ignorando as considerações de caso.
12	byte getBytes () Codifica essa String em uma sequência de bytes usando o conjunto de caracteres padrão da plataforma, armazenando o resultado em uma nova matriz de bytes.
13	byte [] getBytes (String charsetName) Codifica esta String em uma sequência de bytes usando o charset nomeado, armazenando o resultado em uma nova matriz de bytes.
14	void getChars (int srcBegin, int srcEnd, char [] dst, int dstBegin) Copia os caracteres desta string na matriz de caracteres de destino.
15	int hashCode () Retorna um código hash para esta string.
16	int indexOf (int ch) Retorna o índice dentro desta string da primeira ocorrência do caractere especificado.
17	int indexOf (int ch, int fromIndex) Retorna o índice dentro desta string da primeira ocorrência do caractere especificado, iniciando a pesquisa no índice especificado.
18	int indexOf (String str) Retorna o índice dentro desta string da primeira ocorrência da substring especificada.
19	int indexOf (String str, int fromIndex) Retorna o índice dentro desta string da primeira ocorrência da substring especificada, começando no índice especificado.
20	String interno () Retorna uma representação canônica para o objeto string.
21	int lastIndexOf (int ch) Retorna o índice dentro desta string da última ocorrência do caractere especificado.
22	int lastIndexOf (int ch, int fromIndex) Retorna o índice dentro desta string da última ocorrência do caractere especificado, pesquisando para trás começando no índice especificado.
23	int lastIndexOf (String str) Retorna o índice dentro desta string da ocorrência mais à direita da substring especificada.
24	int lastIndexOf (String str, int fromIndex) Retorna o índice dentro desta string da última ocorrência da substring especificada, pesquisando para trás começando no índice especificado.
25	comprimento interno () Retorna o comprimento desta string.
26	correspondências booleanas (String regex) Informa se esta string corresponde ou não à expressão regular fornecida.
27	boolean regionMatches (boolean ignoreCase, int toffset, String other, int ooffset, int len) Testa se duas regiões de string são iguais.
28	boolean regionMatches (int toffset, String other, int ooffset, int len) Testa se duas regiões de string são iguais.
29	Substituição de string (char oldChar, char newChar) Retorna uma nova string resultante da substituição de todas as ocorrências de oldChar nesta string por newChar.
30	String replaceAll (String regex, substituição de string Substitui cada substring desta string que corresponde à expressão regular fornecida com a substituição fornecida.
31	String replaceFirst (string regex, substituição de string) Substitui a primeira substring desta string que corresponde à expressão regular fornecida com a substituição fornecida.
32	String [] split (String regex) Divide esta string em torno das correspondências da expressão regular fornecida.
33	String [] split (String regex, int limit) Divide esta string em torno das correspondências da expressão regular fornecida.
34	boolean startsWith (prefixo de string) Testa se esta string começa com o prefixo especificado.
35	boolean startsWith (prefixo String, int toffset) Testa se esta string começa com o prefixo especificado iniciando um índice especificado.
36	CharSequence subSequence (int beginIndex, int endIndex) Retorna uma nova sequência de caracteres que é uma subsequência dessa sequência.
37	String substring (int beginIndex) Retorna uma nova string que é uma substring desta string.
38	String substring (int beginIndex, int endIndex) Retorna uma nova string que é uma substring desta string.
39	char [] toCharArray () Converte esta string em uma nova matriz de caracteres.
40	String toLowerCase () Converte todos os caracteres nesta String em minúsculas usando as regras da localidade padrão.
41	String toLowerCase (localidade local) Converte todos os caracteres neste String em minúsculas usando as regras do Locale fornecido.
42	String toString () Este objeto (que já é uma string!) É ele próprio retornado.
43	String toUpperCase () Converte todos os caracteres nesta String em maiúsculas usando as regras da localidade padrão.
44	String toUpperCase (localidade) Converte todos os caracteres neste String em maiúsculas usando as regras do Locale fornecido.
45	Corte da corda () Retorna uma cópia da string, com espaços em branco à esquerda e à direita omitidos.
46	String valueOf estática (tipo de dados primitivos x) Retorna a representação de string do argumento do tipo de dados passado.

Java fornece uma estrutura de dados, o array, que armazena uma coleção sequencial de tamanho fixo de elementos do mesmo tipo. Uma matriz é usada para armazenar uma coleção de dados, mas geralmente é mais útil pensar em uma matriz como uma coleção de variáveis ​​do mesmo tipo.

Em vez de declarar variáveis ​​individuais, como número0, número1, ... e número99, você declara uma variável de matriz, como números e usa números [0], números [1] e ..., números [99] para representar variáveis ​​individuais.

Este tutorial apresenta como declarar variáveis ​​de array, criar arrays e processar arrays usando variáveis ​​indexadas.

Declarando Variáveis ​​de Matriz

Para usar uma matriz em um programa, você deve declarar uma variável para fazer referência à matriz e deve especificar o tipo de matriz à qual a variável pode fazer referência. Aqui está a sintaxe para declarar uma variável de matriz -

Sintaxe

dataType[] arrayRefVar;   // preferred way.
or
dataType arrayRefVar[];  // works but not preferred way.

Note - o estilo dataType[] arrayRefVaré preferível. O estilodataType arrayRefVar[] vem da linguagem C / C ++ e foi adotado em Java para acomodar programadores C / C ++.

Exemplo

Os seguintes trechos de código são exemplos dessa sintaxe -

double[] myList;   // preferred way.
or
double myList[];   // works but not preferred way.

Criação de matrizes

Você pode criar uma matriz usando o novo operador com a seguinte sintaxe -

Sintaxe

arrayRefVar = new dataType[arraySize];

A declaração acima faz duas coisas -

• Ele cria uma matriz usando novo dataType [arraySize].

• Ele atribui a referência do array recém-criado à variável arrayRefVar.

Declarar uma variável de matriz, criar uma matriz e atribuir a referência da matriz à variável podem ser combinados em uma instrução, conforme mostrado abaixo -

dataType[] arrayRefVar = new dataType[arraySize];

Alternativamente, você pode criar matrizes da seguinte maneira -

dataType[] arrayRefVar = {value0, value1, ..., valuek};

Os elementos da matriz são acessados ​​por meio do index. Os índices de array são baseados em 0; ou seja, eles começam de 0 aarrayRefVar.length-1.

Exemplo

A instrução a seguir declara uma variável de array, myList, cria um array de 10 elementos do tipo double e atribui sua referência a myList -

double[] myList = new double[10];

A imagem a seguir representa o array myList. Aqui, myList contém dez valores duplos e os índices vão de 0 a 9.

Processando matrizes

Ao processar elementos da matriz, costumamos usar tanto for loop ou foreach loop porque todos os elementos em uma matriz são do mesmo tipo e o tamanho da matriz é conhecido.

Exemplo

Aqui está um exemplo completo que mostra como criar, inicializar e processar matrizes -

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
     
      // Summing all elements
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      
      // Finding the largest element
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);  
   }
}

Isso produzirá o seguinte resultado -

Resultado

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Os Loops foreach

O JDK 1.5 introduziu um novo loop for conhecido como loop foreach ou loop for aprimorado, que permite percorrer o array completo sequencialmente sem usar uma variável de índice.

Exemplo

O código a seguir exibe todos os elementos na matriz myList -

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

Isso produzirá o seguinte resultado -

Resultado

1.9
2.9
3.4
3.5

Passando Arrays para Métodos

Assim como você pode passar valores de tipo primitivo para métodos, também pode passar matrizes para métodos. Por exemplo, o método a seguir exibe os elementos em umint array -

Exemplo

public static void printArray(int[] array) {
   for (int i = 0; i < array.length; i++) {
      System.out.print(array[i] + " ");
   }
}

Você pode invocá-lo passando um array. Por exemplo, a instrução a seguir invoca o método printArray para exibir 3, 1, 2, 6, 4 e 2 -

Exemplo

printArray(new int[]{3, 1, 2, 6, 4, 2});

Retornando um Array de um Método

Um método também pode retornar uma matriz. Por exemplo, o método a seguir retorna uma matriz que é a reversão de outra matriz -

Exemplo

public static int[] reverse(int[] list) {
   int[] result = new int[list.length];

   for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
      result[j] = list[i];
   }
   return result;
}

A classe Arrays

A classe java.util.Arrays contém vários métodos estáticos para classificar e pesquisar arrays, comparar arrays e preencher elementos de array. Esses métodos são sobrecarregados para todos os tipos primitivos.

Sr. Não.	Método e Descrição
1	public static int binarySearch(Object[] a, Object key) Pesquisa o array especificado de Object (Byte, Int, double, etc.) para o valor especificado usando o algoritmo de pesquisa binária. A matriz deve ser classificada antes de fazer esta chamada. Isso retorna o índice da chave de pesquisa, se estiver contido na lista; caso contrário, retorna (- (ponto de inserção + 1)).
2	public static boolean equals(long[] a, long[] a2) Retorna verdadeiro se as duas matrizes de longos especificados forem iguais. Duas matrizes são consideradas iguais se ambas as matrizes contiverem o mesmo número de elementos e todos os pares de elementos correspondentes nas duas matrizes forem iguais. Isso retorna verdadeiro se as duas matrizes forem iguais. O mesmo método pode ser usado por todos os outros tipos de dados primitivos (Byte, short, Int, etc.)
3	public static void fill(int[] a, int val) Atribui o valor int especificado a cada elemento da matriz especificada de ints. O mesmo método pode ser usado por todos os outros tipos de dados primitivos (Byte, short, Int, etc.)
4	public static void sort(Object[] a) Classifica a matriz especificada de objetos em ordem crescente, de acordo com a ordem natural de seus elementos. O mesmo método pode ser usado por todos os outros tipos de dados primitivos (Byte, short, Int, etc.)

Java fornece o Date classe disponível em java.util pacote, esta classe encapsula a data e hora atuais.

A classe Date oferece suporte a dois construtores, conforme mostrado na tabela a seguir.

Sr. Não.	Construtor e descrição
1	Date( ) Este construtor inicializa o objeto com a data e hora atuais.
2	Date(long millisec) Este construtor aceita um argumento igual ao número de milissegundos decorridos desde a meia-noite de 1º de janeiro de 1970.

A seguir estão os métodos da classe de data.

Sr. Não.	Método e Descrição
1	boolean after(Date date) Retorna verdadeiro se o objeto de chamada Date contiver uma data posterior à especificada por data; caso contrário, retorna falso.
2	boolean before(Date date) Retorna verdadeiro se o objeto Date de chamada contiver uma data anterior à especificada por data; caso contrário, retorna falso.
3	Object clone( ) Duplica o objeto Date de chamada.
4	int compareTo(Date date) Compara o valor do objeto de chamada com o de data. Retorna 0 se os valores forem iguais. Retorna um valor negativo se o objeto de chamada for anterior à data. Retorna um valor positivo se o objeto de chamada for posterior à data.
5	int compareTo(Object obj) Opera de forma idêntica a compareTo (Date) se obj for da classe Date. Caso contrário, ele lança uma ClassCastException.
6	boolean equals(Object date) Retorna verdadeiro se o objeto de invocação Date contém a mesma hora e data que aquele especificado por data; caso contrário, retorna falso.
7	long getTime( ) Retorna o número de milissegundos decorridos desde 1º de janeiro de 1970.
8	int hashCode( ) Retorna um código hash para o objeto de chamada.
9	void setTime(long time) Define a hora e a data conforme especificado por time, que representa um tempo decorrido em milissegundos a partir da meia-noite de 1º de janeiro de 1970.
10	String toString( ) Converte o objeto de chamada Date em uma string e retorna o resultado.

Obtendo data e hora atuais

Este é um método muito fácil de obter a data e a hora atuais em Java. Você pode usar um objeto Date simples com o método toString () para imprimir a data e hora atuais da seguinte forma -

Exemplo

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date using toString()
      System.out.println(date.toString());
   }
}

Isso produzirá o seguinte resultado -

Resultado

on May 04 09:51:52 CDT 2009

Comparação de datas

A seguir estão as três maneiras de comparar duas datas -

• Você pode usar getTime () para obter o número de milissegundos decorridos desde a meia-noite de 1º de janeiro de 1970 para ambos os objetos e, em seguida, comparar esses dois valores.

• Você pode usar os métodos before (), after () e equals (). Como o 12º dia do mês vem antes do 18º, por exemplo, new Date (99, 2, 12) .before (new Date (99, 2, 18)) retorna true.

• Você pode usar o método compareTo (), que é definido pela interface Comparable e implementado por Date.

Formatação de data usando SimpleDateFormat

SimpleDateFormat é uma classe concreta para formatar e analisar datas de uma maneira que diferencia a localidade. SimpleDateFormat permite que você comece escolhendo quaisquer padrões definidos pelo usuário para a formatação de data e hora.

Exemplo

import java.util.*;
import java.text.*;

public class DateDemo {

   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

      System.out.println("Current Date: " + ft.format(dNow));
   }
}

Isso produzirá o seguinte resultado -

Resultado

Current Date: Sun 2004.07.18 at 04:14:09 PM PDT

Códigos de formato simples de DateFormat

Para especificar o formato da hora, use uma string de padrão de hora. Neste padrão, todas as letras ASCII são reservadas como letras padrão, que são definidas da seguinte forma -

Personagem	Descrição	Exemplo
G	Designador era	DE ANÚNCIOS
y	Ano em quatro dígitos	2001
M	Mês no ano	Julho ou 07
d	Dia no mês	10
h	Hora em AM / PM (1 ~ 12)	12
H	Hora do dia (0 ~ 23)	22
m	Minuto em hora	30
s	Segundo em minuto	55
S	Milissegundo	234
E	Dia da semana	terça
D	Dia no ano	360
F	Dia da semana no mês	2 (segunda quarta-feira em julho)
W	Semana no ano	40
W	Semana no mês	1
uma	Marcador AM / PM	PM
k	Hora do dia (1 ~ 24)	24
K	Hora em AM / PM (0 ~ 11)	10
z	Fuso horário	Hora Padrão do Leste
'	Escape para texto	Delimitador
"	Citação única	`

Formatação de data usando printf

A formatação de data e hora pode ser feita facilmente usando printfmétodo. Você usa um formato de duas letras, começando comt e terminando em uma das letras da tabela conforme mostrado no código a seguir.

Exemplo

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();

      // display time and date
      String str = String.format("Current Date/Time : %tc", date );

      System.out.printf(str);
   }
}

Isso produzirá o seguinte resultado -

Resultado

Current Date/Time : Sat Dec 15 16:37:57 MST 2012

Seria um pouco bobo se você tivesse que fornecer a data várias vezes para formatar cada parte. Por esse motivo, uma string de formato pode indicar o índice do argumento a ser formatado.

O índice deve seguir imediatamente o% e deve ser encerrado por um $.

Exemplo

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display time and date
      System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);
   }
}

Isso produzirá o seguinte resultado -

Resultado

Due date: February 09, 2004

Alternativamente, você pode usar o <flag. Indica que o mesmo argumento da especificação de formato anterior deve ser usado novamente.

Exemplo

import java.util.Date;
public class DateDemo {

   public static void main(String args[]) {
      // Instantiate a Date object
      Date date = new Date();
  
      // display formatted date
      System.out.printf("%s %tB %<te, %<tY", "Due date:", date);
   }
}

Isso produzirá o seguinte resultado -

Resultado

Due date: February 09, 2004

Caracteres de conversão de data e hora

Personagem	Descrição	Exemplo
c	Data e hora completas	Seg, 04 de maio, 09:51:52 CDT 2009
F	Data ISO 8601	09/02/2004
D	Data formatada nos EUA (mês / dia / ano)	09/02/2004
T	Tempo de 24 horas	18:05:19
r	Tempo de 12 horas	18:05:19
R	Tempo de 24 horas, sem segundos	18:05
Y	Ano de quatro dígitos (com zeros à esquerda)	2004
y	Últimos dois dígitos do ano (com zeros à esquerda)	04
C	Os primeiros dois dígitos do ano (com zeros à esquerda)	20
B	Nome completo do mês	fevereiro
b	Nome abreviado do mês	Fev
m	Mês de dois dígitos (com zeros à esquerda)	02
d	Dia de dois dígitos (com zeros à esquerda)	03
e	Dia de dois dígitos (sem zeros à esquerda)	9
UMA	Nome completo do dia da semana	Segunda-feira
uma	Nome abreviado do dia da semana	seg
j	Dia do ano com três dígitos (com zeros à esquerda)	069
H	Hora de dois dígitos (com zeros à esquerda), entre 00 e 23	18
k	Hora de dois dígitos (sem zeros à esquerda), entre 0 e 23	18
Eu	Hora de dois dígitos (com zeros à esquerda), entre 01 e 12	06
eu	Hora de dois dígitos (sem zeros à esquerda), entre 1 e 12	6
M	Minutos de dois dígitos (com zeros à esquerda)	05
S	Segundos de dois dígitos (com zeros à esquerda)	19
eu	Milissegundos de três dígitos (com zeros à esquerda)	047
N	Nanossegundos de nove dígitos (com zeros à esquerda)	047000000
P	Marcador de manhã ou tarde em maiúsculas	PM
p	Marcador de manhã ou tarde em caixa baixa	PM
z	Deslocamento numérico RFC 822 do GMT	-0800
Z	Fuso horário	PST
s	Segundos desde 01/01/1970 00:00:00 GMT	1078884319
Q	Milissegundos desde 01/01/1970 00:00:00 GMT	1078884319047

Existem outras classes úteis relacionadas a Data e hora. Para obter mais detalhes, você pode consultar a documentação do Java Standard.

Analisando Strings em Datas

A classe SimpleDateFormat possui alguns métodos adicionais, notavelmente parse (), que tenta analisar uma string de acordo com o formato armazenado no objeto SimpleDateFormat fornecido.

Exemplo

import java.util.*;
import java.text.*;
  
public class DateDemo {

   public static void main(String args[]) {
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd"); 
      String input = args.length == 0 ? "1818-11-11" : args[0]; 

      System.out.print(input + " Parses as "); 
      Date t;
      try {
         t = ft.parse(input); 
         System.out.println(t); 
      } catch (ParseException e) { 
         System.out.println("Unparseable using " + ft); 
      }
   }
}

Uma execução de amostra do programa acima produziria o seguinte resultado -

Resultado

1818-11-11 Parses as Wed Nov 11 00:00:00 EST 1818

Dormindo um pouco

Você pode dormir por qualquer período de tempo de um milissegundo até a vida útil do seu computador. Por exemplo, o seguinte programa iria dormir por 3 segundos -

Exemplo

import java.util.*;
public class SleepDemo {

   public static void main(String args[]) {
      try { 
         System.out.println(new Date( ) + "\n"); 
         Thread.sleep(5*60*10); 
         System.out.println(new Date( ) + "\n"); 
      } catch (Exception e) {
         System.out.println("Got an exception!"); 
      }
   }
}

Isso produzirá o seguinte resultado -

Resultado

Sun May 03 18:04:41 GMT 2009
Sun May 03 18:04:51 GMT 2009

Medindo o tempo decorrido

Às vezes, você pode precisar medir um ponto no tempo em milissegundos. Então, vamos reescrever o exemplo acima mais uma vez -

Exemplo

import java.util.*;
public class DiffDemo {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         
         Thread.sleep(5*60*10);
         System.out.println(new Date( ) + "\n");
         
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

Isso produzirá o seguinte resultado -

Resultado

Sun May 03 18:16:51 GMT 2009
Sun May 03 18:16:57 GMT 2009
Difference is : 5993

Classe GregorianCalendar

GregorianCalendar é uma implementação concreta de uma classe Calendar que implementa o calendário gregoriano normal com o qual você está familiarizado. Não discutimos a classe Calendar neste tutorial, você pode consultar a documentação Java padrão para isso.

o getInstance( )O método Calendar retorna um GregorianCalendar inicializado com a data e hora atuais no local e fuso horário padrão. GregorianCalendar define dois campos: AD e BC. Estes representam as duas eras definidas pelo calendário gregoriano.

Existem também vários construtores para objetos GregorianCalendar -

Sr. Não.	Construtor e descrição
1	GregorianCalendar() Constrói um GregorianCalendar padrão usando a hora atual no fuso horário padrão com o local padrão.
2	GregorianCalendar(int year, int month, int date) Constrói um GregorianCalendar com a data fornecida definida no fuso horário padrão com o local padrão.
3	GregorianCalendar(int year, int month, int date, int hour, int minute) Constrói um GregorianCalendar com a data e hora fornecidas definidas para o fuso horário padrão com o local padrão.
4	GregorianCalendar(int year, int month, int date, int hour, int minute, int second) Constrói um GregorianCalendar com a data e hora fornecidas definidas para o fuso horário padrão com o local padrão.
5	GregorianCalendar(Locale aLocale) Constrói um GregorianCalendar com base na hora atual no fuso horário padrão com o local fornecido.
6	GregorianCalendar(TimeZone zone) Constrói um GregorianCalendar com base na hora atual no fuso horário fornecido com a localidade padrão.
7	GregorianCalendar(TimeZone zone, Locale aLocale) Constrói um GregorianCalendar com base na hora atual no fuso horário fornecido com a localidade fornecida.

Aqui está a lista de alguns métodos de suporte úteis fornecidos pela classe GregorianCalendar -

Sr. Não.	Método e Descrição
1	void add(int field, int amount) Adiciona a quantidade de tempo especificada (assinada) ao campo de tempo determinado, com base nas regras do calendário.
2	protected void computeFields() Converte UTC em milissegundos em valores de campo de hora.
3	protected void computeTime() Substitui o calendário Converte os valores do campo de hora em UTC como milissegundos.
4	boolean equals(Object obj) Compara este GregorianCalendar a uma referência de objeto.
5	int get(int field) Obtém o valor de um determinado campo de hora.
6	int getActualMaximum(int field) Retorna o valor máximo que este campo poderia ter, dada a data atual.
7	int getActualMinimum(int field) Retorna o valor mínimo que este campo poderia ter, dada a data atual.
8	int getGreatestMinimum(int field) Retorna o valor mínimo mais alto para o campo fornecido se variar.
9	Date getGregorianChange() Obtém a data de alteração do calendário gregoriano.
10	int getLeastMaximum(int field) Retorna o valor máximo mais baixo para o campo fornecido se variar.
11	int getMaximum(int field) Retorna o valor máximo para o campo fornecido.
12	Date getTime() Obtém a hora atual deste calendário.
13	long getTimeInMillis() Obtém a hora atual deste calendário como um longo.
14	TimeZone getTimeZone() Obtém o fuso horário.
15	int getMinimum(int field) Retorna o valor mínimo para o campo fornecido.
16	int hashCode() Substitui hashCode.
17	boolean isLeapYear(int year) Determina se o ano especificado é um ano bissexto.
18	void roll(int field, boolean up) Adiciona ou subtrai (para cima / para baixo) uma única unidade de tempo no campo de tempo determinado sem alterar campos maiores.
19	void set(int field, int value) Define o campo de hora com o valor fornecido.
20	void set(int year, int month, int date) Define os valores para os campos ano, mês e data.
21	void set(int year, int month, int date, int hour, int minute) Define os valores para os campos ano, mês, data, hora e minuto.
22	void set(int year, int month, int date, int hour, int minute, int second) Define os valores para os campos ano, mês, data, hora, minuto e segundo.
23	void setGregorianChange(Date date) Define a data de alteração GregorianCalendar.
24	void setTime(Date date) Define a hora atual deste calendário com a data fornecida.
25	void setTimeInMillis(long millis) Define a hora atual deste calendário a partir de um valor longo fornecido.
26	void setTimeZone(TimeZone value) Define o fuso horário com o valor de fuso horário fornecido.
27	String toString() Retorna uma representação de string deste calendário.

Exemplo

import java.util.*;
public class GregorianCalendarDemo {

   public static void main(String args[]) {
      String months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", 
         "Oct", "Nov", "Dec"};
      
      int year;
      // Create a Gregorian calendar initialized
      // with the current date and time in the
      // default locale and timezone.
      
      GregorianCalendar gcalendar = new GregorianCalendar();
      
      // Display current time and date information.
      System.out.print("Date: ");
      System.out.print(months[gcalendar.get(Calendar.MONTH)]);
      System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
      System.out.println(year = gcalendar.get(Calendar.YEAR));
      System.out.print("Time: ");
      System.out.print(gcalendar.get(Calendar.HOUR) + ":");
      System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
      System.out.println(gcalendar.get(Calendar.SECOND));

      // Test if the current year is a leap year
      if(gcalendar.isLeapYear(year)) {
         System.out.println("The current year is a leap year");
      }else {
         System.out.println("The current year is not a leap year");
      }
   }
}

Isso produzirá o seguinte resultado -

Resultado

Date: Apr 22 2009
Time: 11:25:27
The current year is not a leap year

Para obter uma lista completa das constantes disponíveis na classe Calendar, você pode consultar a documentação Java padrão.

Java fornece o pacote java.util.regex para correspondência de padrões com expressões regulares. As expressões regulares Java são muito semelhantes à linguagem de programação Perl e muito fáceis de aprender.

Uma expressão regular é uma sequência especial de caracteres que o ajuda a encontrar ou encontrar outras strings ou conjuntos de strings, usando uma sintaxe especializada mantida em um padrão. Eles podem ser usados ​​para pesquisar, editar ou manipular texto e dados.

O pacote java.util.regex consiste principalmente nas três classes a seguir -

• Pattern Class- Um objeto Pattern é uma representação compilada de uma expressão regular. A classe Pattern não fornece construtores públicos. Para criar um padrão, você deve primeiro invocar um de seuscompile()métodos, que retornarão um objeto Pattern. Esses métodos aceitam uma expressão regular como o primeiro argumento.

• Matcher Class- Um objeto Matcher é o mecanismo que interpreta o padrão e executa operações de correspondência em uma string de entrada. Como a classe Pattern, Matcher não define construtores públicos. Você obtém um objeto Matcher invocando omatcher() método em um objeto Pattern.

• PatternSyntaxException - Um objeto PatternSyntaxException é uma exceção não verificada que indica um erro de sintaxe em um padrão de expressão regular.

Capturando Grupos

Capturar grupos é uma forma de tratar vários personagens como uma única unidade. Eles são criados colocando os caracteres a serem agrupados dentro de um conjunto de parênteses. Por exemplo, a expressão regular (cachorro) cria um único grupo contendo as letras "d", "o" e "g".

Os grupos de captura são numerados contando seus parênteses de abertura da esquerda para a direita. Na expressão ((A) (B (C))), por exemplo, existem quatro desses grupos -

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

Para descobrir quantos grupos estão presentes na expressão, chame o método groupCount em um objeto correspondente. O método groupCount retorna umint mostrando o número de grupos de captura presentes no padrão de correspondência.

Também existe um grupo especial, o grupo 0, que sempre representa a expressão inteira. Este grupo não está incluído no total relatado por groupCount.

Example

O exemplo a seguir ilustra como encontrar uma string de dígitos da string alfanumérica fornecida -

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   public static void main( String args[] ) {
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // Create a Pattern object
      Pattern r = Pattern.compile(pattern);

      // Now create matcher object.
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      }else {
         System.out.println("NO MATCH");
      }
   }
}

Isso produzirá o seguinte resultado -

Output

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

Sintaxe de Expressão Regular

Aqui está a tabela que lista toda a sintaxe de metacaracteres de expressão regular disponível em Java -

Subexpressão	Partidas
^	Corresponde ao início da linha.
$	Corresponde ao final da linha.
.	Corresponde a qualquer caractere único, exceto nova linha. Usandom a opção permite que ele corresponda à nova linha também.
[...]	Corresponde a qualquer caractere único entre colchetes.
[^ ...]	Corresponde a qualquer caractere único que não esteja entre colchetes.
\UMA	Início de toda a string.
\ z	Fim de toda a string.
\ Z	Fim de toda a string, exceto terminador de linha final permitido.
ré*	Corresponde a 0 ou mais ocorrências da expressão anterior.
re +	Corresponde a 1 ou mais do anterior.
ré?	Corresponde a 0 ou 1 ocorrência da expressão anterior.
re {n}	Corresponde exatamente ao número n de ocorrências da expressão anterior.
re {n,}	Corresponde a n ou mais ocorrências da expressão anterior.
re {n, m}	Corresponde a pelo menos n e no máximo m ocorrências da expressão anterior.
a | b	Corresponde a a ou b.
(ré)	Agrupa expressões regulares e lembra o texto correspondente.
(?: re)	Agrupa expressões regulares sem lembrar o texto correspondente.
(?> re)	Corresponde ao padrão independente sem retrocesso.
\W	Corresponde aos caracteres da palavra.
\W	Corresponde aos caracteres não-palavra.
\ s	Corresponde ao espaço em branco. Equivalente a [\ t \ n \ r \ f].
\ S	Corresponde ao não espaço em branco.
\ d	Corresponde aos dígitos. Equivalente a [0-9].
\ D	Corresponde aos não dígitos.
\UMA	Corresponde ao início da string.
\ Z	Corresponde ao final da string. Se houver uma nova linha, ela corresponderá imediatamente antes da nova linha.
\ z	Corresponde ao final da string.
\ G	Corresponde ao ponto onde a última partida terminou.
\ n	Referência anterior para capturar o número do grupo "n".
\ b	Corresponde aos limites da palavra quando está fora dos colchetes. Corresponde ao backspace (0x08) quando dentro dos colchetes.
\ B	Corresponde aos limites sem palavras.
\ n, \ t, etc.	Corresponde a novas linhas, retornos de carro, guias, etc.
\ Q	Escape (aspas) de todos os caracteres até \ E.
\ E	Termina a citação iniciada com \ Q.

Métodos da classe Matcher

Aqui está uma lista de métodos de instância úteis -

Métodos de Índice

Os métodos de índice fornecem valores de índice úteis que mostram precisamente onde a correspondência foi encontrada na string de entrada -

Sr. Não.	Método e Descrição
1	public int start() Retorna o índice inicial da correspondência anterior.
2	public int start(int group) Retorna o índice inicial da subsequência capturada pelo grupo fornecido durante a operação de correspondência anterior.
3	public int end() Retorna o deslocamento após o último caractere encontrado.
4	public int end(int group) Retorna o deslocamento após o último caractere da subsequência capturada por um determinado grupo durante a operação de correspondência anterior.

Métodos de Estudo

Métodos de estudo revisam a string de entrada e retornam um booleano indicando se o padrão foi encontrado ou não -

Sr. Não.	Método e Descrição
1	public boolean lookingAt() Tenta combinar a sequência de entrada, começando no início da região, com o padrão.
2	public boolean find() Tenta encontrar a próxima subsequência da sequência de entrada que corresponda ao padrão.
3	public boolean find(int start) Redefine esse matcher e, em seguida, tenta encontrar a próxima subsequência da sequência de entrada que corresponde ao padrão, começando no índice especificado.
4	public boolean matches() Tenta combinar toda a região com o padrão.

Métodos de Substituição

Métodos de substituição são métodos úteis para substituir texto em uma string de entrada -

Sr. Não.	Método e Descrição
1	public Matcher appendReplacement(StringBuffer sb, String replacement) Implementa uma etapa não terminal de anexar e substituir.
2	public StringBuffer appendTail(StringBuffer sb) Implementa uma etapa de anexar e substituir de terminal.
3	public String replaceAll(String replacement) Substitui cada subsequência da sequência de entrada que corresponde ao padrão com a string de substituição fornecida.
4	public String replaceFirst(String replacement) Substitui a primeira subsequência da sequência de entrada que corresponde ao padrão com a string de substituição fornecida.
5	public static String quoteReplacement(String s) Retorna uma string de substituição literal para a String especificada. Este método produz uma String que funcionará como uma substituição literals no método appendReplacement da classe Matcher.

Os métodos de início e fim

A seguir está o exemplo que conta o número de vezes que a palavra "gato" aparece na string de entrada -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "\\bcat\\b";
   private static final String INPUT = "cat cat cat cattie cat";

   public static void main( String args[] ) {
      Pattern p = Pattern.compile(REGEX);
      Matcher m = p.matcher(INPUT);   // get a matcher object
      int count = 0;

      while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

Isso produzirá o seguinte resultado -

Output

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

Você pode ver que este exemplo usa limites de palavras para garantir que as letras "c" "a" "t" não sejam meramente uma substring em uma palavra mais longa. Ele também fornece algumas informações úteis sobre onde na string de entrada a correspondência ocorreu.

O método start retorna o índice inicial da subsequência capturada por um determinado grupo durante a operação de correspondência anterior e o end retorna o índice do último caractere correspondido, mais um.

As correspondências e métodos lookingAt

Os métodos match e lookingAt tentam combinar uma sequência de entrada com um padrão. A diferença, no entanto, é que as correspondências exigem que toda a sequência de entrada seja correspondida, enquanto que lookingAt não.

Ambos os métodos sempre começam no início da string de entrada. Aqui está o exemplo que explica a funcionalidade -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static final String REGEX = "foo";
   private static final String INPUT = "fooooooooooooooooo";
   private static Pattern pattern;
   private static Matcher matcher;

   public static void main( String args[] ) {
      pattern = Pattern.compile(REGEX);
      matcher = pattern.matcher(INPUT);

      System.out.println("Current REGEX is: "+REGEX);
      System.out.println("Current INPUT is: "+INPUT);

      System.out.println("lookingAt(): "+matcher.lookingAt());
      System.out.println("matches(): "+matcher.matches());
   }
}

Isso produzirá o seguinte resultado -

Output

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

Os métodos replaceFirst e replaceAll

Os métodos replaceFirst e replaceAll substituem o texto que corresponde a uma determinada expressão regular. Como seus nomes indicam, replaceFirst substitui a primeira ocorrência e replaceAll substitui todas as ocorrências.

Aqui está o exemplo que explica a funcionalidade -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "dog";
   private static String INPUT = "The dog says meow. " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT); 
      INPUT = m.replaceAll(REPLACE);
      System.out.println(INPUT);
   }
}

Isso produzirá o seguinte resultado -

Output

The cat says meow. All cats say meow.

Os métodos appendReplacement e appendTail

A classe Matcher também fornece os métodos appendReplacement e appendTail para substituição de texto.

Aqui está o exemplo que explica a funcionalidade -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches {

   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {

      Pattern p = Pattern.compile(REGEX);
      
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()) {
         m.appendReplacement(sb, REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

Isso produzirá o seguinte resultado -

Output

-foo-foo-foo-

Métodos de classe PatternSyntaxException

Uma PatternSyntaxException é uma exceção não verificada que indica um erro de sintaxe em um padrão de expressão regular. A classe PatternSyntaxException fornece os seguintes métodos para ajudá-lo a determinar o que deu errado -

Sr. Não.	Método e Descrição
1	public String getDescription() Recupera a descrição do erro.
2	public int getIndex() Recupera o índice de erros.
3	public String getPattern() Recupera o padrão de expressão regular incorreto.
4	public String getMessage() Retorna uma string de várias linhas contendo a descrição do erro de sintaxe e seu índice, o padrão de expressão regular incorreto e uma indicação visual do índice de erro dentro do padrão.

Um método Java é uma coleção de instruções agrupadas para executar uma operação. Quando você liga para System.out.println() método, por exemplo, o sistema realmente executa várias instruções para exibir uma mensagem no console.

Agora você aprenderá como criar seus próprios métodos com ou sem valores de retorno, invocar um método com ou sem parâmetros e aplicar abstração de método no design do programa.

Método de Criação

Considerando o seguinte exemplo para explicar a sintaxe de um método -

Syntax

public static int methodName(int a, int b) {
   // body
}

Aqui,

• public static - modificador

• int - tipo de retorno

• methodName - nome do método

• a, b - parâmetros formais

• int a, int b - lista de parâmetros

A definição de método consiste em um cabeçalho de método e um corpo de método. O mesmo é mostrado na seguinte sintaxe -

Syntax

modifier returnType nameOfMethod (Parameter List) {
   // method body
}

A sintaxe mostrada acima inclui -

• modifier - Define o tipo de acesso do método e seu uso é opcional.

• returnType - O método pode retornar um valor.

• nameOfMethod- Este é o nome do método. A assinatura do método consiste no nome do método e na lista de parâmetros.

• Parameter List- A lista de parâmetros, é o tipo, a ordem e o número de parâmetros de um método. Estes são opcionais, o método pode conter zero parâmetros.

• method body - O corpo do método define o que o método faz com as instruções.

Example

Aqui está o código-fonte do método definido acima chamado min(). Este método usa dois parâmetros num1 e num2 e retorna o máximo entre os dois -

/** the snippet returns the minimum between two numbers */

public static int minFunction(int n1, int n2) {
   int min;
   if (n1 > n2)
      min = n2;
   else
      min = n1;

   return min; 
}

Método de Chamada

Para usar um método, ele deve ser chamado. Existem duas maneiras de chamar um método, ou seja, o método retorna um valor ou não retorna nada (nenhum valor de retorno).

O processo de chamada de método é simples. Quando um programa invoca um método, o controle do programa é transferido para o método chamado. Este método chamado então retorna o controle ao chamador em duas condições, quando -

• a instrução de retorno é executada.
• ele atinge o método que termina com a chave de fechamento.

Os métodos que retornam void são considerados como uma chamada para uma instrução. Vamos considerar um exemplo -

System.out.println("This is tutorialspoint.com!");

O valor de retorno do método pode ser compreendido pelo seguinte exemplo -

int result = sum(6, 9);

A seguir está o exemplo para demonstrar como definir um método e como chamá-lo -

Example

public class ExampleMinNumber {
   
   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      int c = minFunction(a, b);
      System.out.println("Minimum Value = " + c);
   }

   /** returns the minimum of two numbers */
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Isso produzirá o seguinte resultado -

Output

Minimum value = 6

A palavra-chave vazia

A palavra-chave void nos permite criar métodos que não retornam um valor. Aqui, no exemplo a seguir, estamos considerando um método void methodRankPoints . Este método é um método void, que não retorna nenhum valor. A chamada para um método void deve ser uma instrução, ou seja, methodRankPoints (255.7); . É uma instrução Java que termina com um ponto-e-vírgula, conforme mostrado no exemplo a seguir.

Example

public class ExampleVoid {

   public static void main(String[] args) {
      methodRankPoints(255.7);
   }

   public static void methodRankPoints(double points) {
      if (points >= 202.5) {
         System.out.println("Rank:A1");
      }else if (points >= 122.4) {
         System.out.println("Rank:A2");
      }else {
         System.out.println("Rank:A3");
      }
   }
}

Isso produzirá o seguinte resultado -

Output

Rank:A1

Passando Parâmetros por Valor

Ao trabalhar no processo de chamada, os argumentos devem ser passados. Eles devem estar na mesma ordem que seus respectivos parâmetros na especificação do método. Os parâmetros podem ser passados ​​por valor ou por referência.

Passar parâmetros por valor significa chamar um método com um parâmetro. Com isso, o valor do argumento é passado para o parâmetro.

Example

O programa a seguir mostra um exemplo de passagem de parâmetro por valor. Os valores dos argumentos permanecem os mesmos mesmo após a invocação do método.

public class swappingExample {

   public static void main(String[] args) {
      int a = 30;
      int b = 45;
      System.out.println("Before swapping, a = " + a + " and b = " + b);

      // Invoke the swap method
      swapFunction(a, b);
      System.out.println("\n**Now, Before and After swapping values will be same here**:");
      System.out.println("After swapping, a = " + a + " and b is " + b);
   }

   public static void swapFunction(int a, int b) {
      System.out.println("Before swapping(Inside), a = " + a + " b = " + b);
      
      // Swap n1 with n2
      int c = a;
      a = b;
      b = c;
      System.out.println("After swapping(Inside), a = " + a + " b = " + b);
   }
}

Isso produzirá o seguinte resultado -

Output

Before swapping, a = 30 and b = 45
Before swapping(Inside), a = 30 b = 45
After swapping(Inside), a = 45 b = 30

**Now, Before and After swapping values will be same here**:
After swapping, a = 30 and b is 45

Sobrecarga de método

Quando uma classe tem dois ou mais métodos com o mesmo nome, mas parâmetros diferentes, isso é conhecido como sobrecarga de método. É diferente de substituir. Na substituição, um método tem o mesmo nome de método, tipo, número de parâmetros, etc.

Vamos considerar o exemplo discutido anteriormente para encontrar números mínimos do tipo inteiro. Se, digamos que queremos encontrar o número mínimo de tipo duplo. Em seguida, o conceito de sobrecarga será introduzido para criar dois ou mais métodos com o mesmo nome, mas parâmetros diferentes.

O exemplo a seguir explica o mesmo -

Example

public class ExampleOverloading {

   public static void main(String[] args) {
      int a = 11;
      int b = 6;
      double c = 7.3;
      double d = 9.4;
      int result1 = minFunction(a, b);
      
      // same function name with different parameters
      double result2 = minFunction(c, d);
      System.out.println("Minimum Value = " + result1);
      System.out.println("Minimum Value = " + result2);
   }

   // for integer
   public static int minFunction(int n1, int n2) {
      int min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
   
   // for double
   public static double minFunction(double n1, double n2) {
     double min;
      if (n1 > n2)
         min = n2;
      else
         min = n1;

      return min; 
   }
}

Isso produzirá o seguinte resultado -

Output

Minimum Value = 6
Minimum Value = 7.3

Os métodos de sobrecarga tornam o programa legível. Aqui, dois métodos são dados com o mesmo nome, mas com parâmetros diferentes. O número mínimo dos tipos inteiro e duplo é o resultado.

Usando argumentos de linha de comando

Às vezes, você desejará passar algumas informações para um programa ao executá-lo. Isso é feito passando argumentos de linha de comando para main ().

Um argumento de linha de comando é a informação que segue diretamente o nome do programa na linha de comando quando ele é executado. Para acessar os argumentos da linha de comando dentro de um programa Java é muito fácil. Eles são armazenados como strings no array String passado para main ().

Example

O programa a seguir exibe todos os argumentos da linha de comando que é chamado com -

public class CommandLine {

   public static void main(String args[]) { 
      for(int i = 0; i<args.length; i++) {
         System.out.println("args[" + i + "]: " +  args[i]);
      }
   }
}

Tente executar este programa conforme mostrado aqui -

$java CommandLine this is a command line 200 -100

Isso produzirá o seguinte resultado -

Output

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

Esta palavra-chave

thisé uma palavra-chave em Java que é usada como referência ao objeto da classe atual, com um método de instância ou um construtor. Usando isso, você pode referir os membros de uma classe, como construtores, variáveis ​​e métodos.

Note- A palavra - chave this é usada apenas em métodos de instância ou construtores

Em geral, a palavra - chave para a qual isso é usado -

• Diferencie as variáveis ​​de instância das variáveis ​​locais se elas tiverem os mesmos nomes, dentro de um construtor ou método.

class Student {
   int age;   
   Student(int age) {
      this.age = age;	
   }
}

• Chame um tipo de construtor (construtor parametrizado ou padrão) de outro em uma classe. É conhecido como invocação explícita do construtor.

class Student {
   int age
   Student() {
      this(20);
   }
   
   Student(int age) {
      this.age = age;	
   }
}

Example

Aqui está um exemplo que usa essa palavra-chave para acessar os membros de uma classe. Copie e cole o seguinte programa em um arquivo com o nome,This_Example.java.

public class This_Example {
   // Instance variable num
   int num = 10;
	
   This_Example() {
      System.out.println("This is an example program on keyword this");	
   }

   This_Example(int num) {
      // Invoking the default constructor
      this();
      
      // Assigning the local variable num to the instance variable num
      this.num = num;	   
   }
   
   public void greet() {
      System.out.println("Hi Welcome to Tutorialspoint");
   }
      
   public void print() {
      // Local variable num
      int num = 20;
      
      // Printing the local variable
      System.out.println("value of local variable num is : "+num);
      
      // Printing the instance variable
      System.out.println("value of instance variable num is : "+this.num);
      
      // Invoking the greet method of a class
      this.greet();     
   }
   
   public static void main(String[] args) {
      // Instantiating the class
      This_Example obj1 = new This_Example();
      
      // Invoking the print method
      obj1.print();
	  
      // Passing a new value to the num variable through Parameterized constructor
      This_Example obj2 = new This_Example(30);
      
      // Invoking the print method again
      obj2.print(); 
   }
}

Isso produzirá o seguinte resultado -

Output

This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 10
Hi Welcome to Tutorialspoint
This is an example program on keyword this 
value of local variable num is : 20
value of instance variable num is : 30
Hi Welcome to Tutorialspoint

Argumentos variáveis ​​(var-args)

O JDK 1.5 permite que você passe um número variável de argumentos do mesmo tipo para um método. O parâmetro no método é declarado da seguinte maneira -

typeName... parameterName

Na declaração do método, você especifica o tipo seguido por reticências (...). Apenas um parâmetro de comprimento variável pode ser especificado em um método, e este parâmetro deve ser o último parâmetro. Todos os parâmetros regulares devem precedê-lo.

Example

public class VarargsDemo {

   public static void main(String args[]) {
      // Call method with variable args  
	   printMax(34, 3, 3, 2, 56.5);
      printMax(new double[]{1, 2, 3});
   }

   public static void printMax( double... numbers) {
      if (numbers.length == 0) {
         System.out.println("No argument passed");
         return;
      }

      double result = numbers[0];

      for (int i = 1; i <  numbers.length; i++)
      if (numbers[i] >  result)
      result = numbers[i];
      System.out.println("The max value is " + result);
   }
}

Isso produzirá o seguinte resultado -

Output

The max value is 56.5
The max value is 3.0

O método finalize ()

É possível definir um método que será chamado pouco antes da destruição final de um objeto pelo coletor de lixo. Este método é chamadofinalize( )e pode ser usado para garantir que um objeto termine de forma limpa.

Por exemplo, você pode usar finalize () para garantir que um arquivo aberto pertencente a esse objeto seja fechado.

Para adicionar um finalizador a uma classe, você simplesmente define o método finalize (). O Java runtime chama esse método sempre que está prestes a reciclar um objeto dessa classe.

Dentro do método finalize (), você especificará as ações que devem ser realizadas antes de um objeto ser destruído.

O método finalize () tem esta forma geral -

protected void finalize( ) {
   // finalization code here
}

Aqui, a palavra-chave protegida é um especificador que impede o acesso a finalize () por código definido fora de sua classe.

Isso significa que você não pode saber quando ou mesmo se finalize () será executado. Por exemplo, se seu programa terminar antes de ocorrer a coleta de lixo, finalize () não será executado.

O pacote java.io contém quase todas as classes que você pode precisar para executar entrada e saída (E / S) em Java. Todos esses fluxos representam uma fonte de entrada e um destino de saída. O fluxo no pacote java.io suporta muitos dados, como primitivos, objetos, caracteres localizados, etc.

Corrente

Um fluxo pode ser definido como uma sequência de dados. Existem dois tipos de Streams -

• InPutStream - O InputStream é usado para ler dados de uma fonte.

• OutPutStream - O OutputStream é usado para gravar dados em um destino.

Java fornece suporte forte, mas flexível, para I / O relacionado a arquivos e redes, mas este tutorial cobre funcionalidades básicas relacionadas a streams e I / O. Veremos os exemplos mais comumente usados, um por um -

Streams de bytes

Os fluxos de bytes Java são usados ​​para realizar a entrada e saída de bytes de 8 bits. Embora existam muitas classes relacionadas a fluxos de bytes, mas as classes mais usadas são,FileInputStream e FileOutputStream. A seguir está um exemplo que faz uso dessas duas classes para copiar um arquivo de entrada em um arquivo de saída -

Example

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {  
      FileInputStream in = null;
      FileOutputStream out = null;

      try {
         in = new FileInputStream("input.txt");
         out = new FileOutputStream("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

Agora vamos ter um arquivo input.txt com o seguinte conteúdo -

This is test for copy file.

Como próximo passo, compile o programa acima e execute-o, o que resultará na criação do arquivo output.txt com o mesmo conteúdo que temos em input.txt. Então, vamos colocar o código acima no arquivo CopyFile.java e fazer o seguinte -

$javac CopyFile.java $java CopyFile

Streams de personagens

Java Byte streams são usados ​​para realizar entrada e saída de bytes de 8 bits, enquanto Java Characterstreams são usados ​​para realizar entrada e saída para Unicode de 16 bits. Embora existam muitas classes relacionadas a fluxos de caracteres, as classes mais usadas são,FileReader e FileWriter. Embora internamente FileReader use FileInputStream e FileWriter use FileOutputStream, aqui a principal diferença é que FileReader lê dois bytes por vez e FileWriter grava dois bytes por vez.

Podemos reescrever o exemplo acima, que faz o uso dessas duas classes para copiar um arquivo de entrada (com caracteres Unicode) para um arquivo de saída -

Example

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {
      FileReader in = null;
      FileWriter out = null;

      try {
         in = new FileReader("input.txt");
         out = new FileWriter("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

Agora vamos ter um arquivo input.txt com o seguinte conteúdo -

This is test for copy file.

Como próximo passo, compile o programa acima e execute-o, o que resultará na criação do arquivo output.txt com o mesmo conteúdo que temos em input.txt. Então, vamos colocar o código acima no arquivo CopyFile.java e fazer o seguinte -

$javac CopyFile.java $java CopyFile

Streams padrão

Todas as linguagens de programação fornecem suporte para E / S padrão, onde o programa do usuário pode obter a entrada de um teclado e, em seguida, produzir uma saída na tela do computador. Se você conhece as linguagens de programação C ou C ++, deve conhecer os três dispositivos padrão STDIN, STDOUT e STDERR. Da mesma forma, Java fornece os três fluxos padrão a seguir -

• Standard Input - Isso é usado para alimentar os dados para o programa do usuário e geralmente um teclado é usado como fluxo de entrada padrão e representado como System.in.

• Standard Output - Isso é usado para produzir os dados produzidos pelo programa do usuário e geralmente uma tela de computador é usada para fluxo de saída padrão e representada como System.out.

• Standard Error - Isso é usado para produzir os dados de erro produzidos pelo programa do usuário e geralmente uma tela de computador é usada para o fluxo de erro padrão e representada como System.err.

A seguir está um programa simples, que cria InputStreamReader para ler o fluxo de entrada padrão até que o usuário digite um "q" -

Example

import java.io.*;
public class ReadConsole {

   public static void main(String args[]) throws IOException {
      InputStreamReader cin = null;

      try {
         cin = new InputStreamReader(System.in);
         System.out.println("Enter characters, 'q' to quit.");
         char c;
         do {
            c = (char) cin.read();
            System.out.print(c);
         } while(c != 'q');
      }finally {
         if (cin != null) {
            cin.close();
         }
      }
   }
}

Vamos manter o código acima no arquivo ReadConsole.java e tentar compilá-lo e executá-lo conforme mostrado no programa a seguir. Este programa continua a ler e produzir o mesmo caractere até que pressione 'q' -

$javac ReadConsole.java $java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q

Ler e gravar arquivos

Conforme descrito anteriormente, um fluxo pode ser definido como uma sequência de dados. oInputStream é usado para ler dados de uma fonte e o OutputStream é usado para gravar dados em um destino.

Aqui está uma hierarquia de classes para lidar com fluxos de entrada e saída.

Os dois fluxos importantes são FileInputStream e FileOutputStream, que será discutido neste tutorial.

FileInputStream

Este fluxo é usado para ler dados dos arquivos. Os objetos podem ser criados usando a palavra-chavenew e existem vários tipos de construtores disponíveis.

O construtor a seguir recebe um nome de arquivo como uma string para criar um objeto de fluxo de entrada para ler o arquivo -

InputStream f = new FileInputStream("C:/java/hello");

O construtor a seguir usa um objeto de arquivo para criar um objeto de fluxo de entrada para ler o arquivo. Primeiro, criamos um objeto de arquivo usando o método File () da seguinte maneira -

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

Depois de ter o objeto InputStream em mãos, há uma lista de métodos auxiliares que podem ser usados ​​para ler o fluxo ou para fazer outras operações no fluxo.

Sr. Não.	Método e Descrição
1	public void close() throws IOException{} Este método fecha o fluxo de saída do arquivo. Libera todos os recursos do sistema associados ao arquivo. Lança uma IOException.
2	protected void finalize()throws IOException {} Este método limpa a conexão com o arquivo. Garante que o método close deste fluxo de saída de arquivo seja chamado quando não houver mais referências a este fluxo. Lança uma IOException.
3	public int read(int r)throws IOException{} Este método lê o byte de dados especificado do InputStream. Retorna um int. Retorna o próximo byte de dados e -1 será retornado se for o fim do arquivo.
4	public int read(byte[] r) throws IOException{} Este método lê bytes r.length do fluxo de entrada em uma matriz. Retorna o número total de bytes lidos. Se for o fim do arquivo, -1 será retornado.
5	public int available() throws IOException{} Fornece o número de bytes que podem ser lidos desse fluxo de entrada de arquivo. Retorna um int.

Existem outros fluxos de entrada importantes disponíveis, para mais detalhes, você pode consultar os seguintes links -

• ByteArrayInputStream

• DataInputStream

FileOutputStream

FileOutputStream é usado para criar um arquivo e gravar dados nele. O stream criaria um arquivo, se ainda não existir, antes de abri-lo para saída.

Aqui estão dois construtores que podem ser usados ​​para criar um objeto FileOutputStream.

O construtor a seguir leva um nome de arquivo como uma string para criar um objeto de fluxo de entrada para escrever o arquivo -

OutputStream f = new FileOutputStream("C:/java/hello")

O construtor a seguir pega um objeto de arquivo para criar um objeto de fluxo de saída para gravar o arquivo. Primeiro, criamos um objeto de arquivo usando o método File () da seguinte maneira -

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

Depois de ter o objeto OutputStream em mãos, há uma lista de métodos auxiliares, que podem ser usados ​​para escrever em um fluxo ou para fazer outras operações no fluxo.

Sr. Não.	Método e Descrição
1	public void close() throws IOException{} Este método fecha o fluxo de saída do arquivo. Libera todos os recursos do sistema associados ao arquivo. Lança uma IOException.
2	protected void finalize()throws IOException {} Este método limpa a conexão com o arquivo. Garante que o método close deste fluxo de saída de arquivo seja chamado quando não houver mais referências a este fluxo. Lança uma IOException.
3	public void write(int w)throws IOException{} Este método grava o byte especificado no fluxo de saída.
4	public void write(byte[] w) Grava bytes w.length da matriz de bytes mencionada no OutputStream.

Existem outros fluxos de saída importantes disponíveis, para mais detalhes, você pode consultar os seguintes links -

• ByteArrayOutputStream

• DataOutputStream

Example

A seguir está o exemplo para demonstrar InputStream e OutputStream -

import java.io.*;
public class fileStreamTest {

   public static void main(String args[]) {
   
      try {
         byte bWrite [] = {11,21,3,40,5};
         OutputStream os = new FileOutputStream("test.txt");
         for(int x = 0; x < bWrite.length ; x++) {
            os.write( bWrite[x] );   // writes the bytes
         }
         os.close();
     
         InputStream is = new FileInputStream("test.txt");
         int size = is.available();

         for(int i = 0; i < size; i++) {
            System.out.print((char)is.read() + "  ");
         }
         is.close();
      } catch (IOException e) {
         System.out.print("Exception");
      }	
   }
}

O código acima criaria o arquivo test.txt e escreveria os números dados em formato binário. O mesmo seria a saída na tela stdout.

Navegação em arquivos e I / O

Existem várias outras classes pelas quais passaríamos para conhecer os fundamentos de Navegação de Arquivos e E / S.

• Classe de arquivo

• Classe FileReader

• Classe FileWriter

Diretórios em Java

Um diretório é um arquivo que pode conter uma lista de outros arquivos e diretórios. Você usaFileobjeto para criar diretórios, para listar os arquivos disponíveis em um diretório. Para detalhes completos, verifique uma lista de todos os métodos que você pode chamar no objeto File e quais estão relacionados aos diretórios.

Criação de diretórios

Existem dois úteis File métodos utilitários, que podem ser usados ​​para criar diretórios -

• o mkdir( )O método cria um diretório, retornando verdadeiro em caso de sucesso e falso em caso de falha. Falha indica que o caminho especificado no objeto Arquivo já existe ou que o diretório não pode ser criado porque o caminho inteiro ainda não existe.

• o mkdirs() método cria um diretório e todos os pais do diretório.

O exemplo a seguir cria o diretório "/ tmp / user / java / bin" -

Example

import java.io.File;
public class CreateDir {

   public static void main(String args[]) {
      String dirname = "/tmp/user/java/bin";
      File d = new File(dirname);
      
      // Create directory now.
      d.mkdirs();
   }
}

Compile e execute o código acima para criar "/ tmp / user / java / bin".

Note- Java cuida automaticamente dos separadores de caminho no UNIX e Windows de acordo com as convenções. Se você usar uma barra (/) em uma versão Windows do Java, o caminho ainda será resolvido corretamente.

Listagem de diretórios

Você pode usar list( ) método fornecido por File objeto para listar todos os arquivos e diretórios disponíveis em um diretório da seguinte forma -

Example

import java.io.File;
public class ReadDir {

   public static void main(String[] args) {
      File file = null;
      String[] paths;
  
      try {      
         // create new file object
         file = new File("/tmp");

         // array of files and directory
         paths = file.list();

         // for each name in the path array
         for(String path:paths) {
            // prints filename and directory name
            System.out.println(path);
         }
      } catch (Exception e) {
         // if any error occurs
         e.printStackTrace();
      }
   }
}

Isso produzirá o seguinte resultado com base nos diretórios e arquivos disponíveis em seu /tmp diretório -

Output

test1.txt
test2.txt
ReadDir.java
ReadDir.class

Uma exceção (ou evento excepcional) é um problema que surge durante a execução de um programa. Quando umException ocorrer, o fluxo normal do programa é interrompido e o programa / Aplicativo é encerrado de forma anormal, o que não é recomendado, portanto, essas exceções devem ser tratadas.

Uma exceção pode ocorrer por vários motivos diferentes. A seguir estão alguns cenários em que ocorre uma exceção.

• Um usuário inseriu dados inválidos.

• Um arquivo que precisa ser aberto não pode ser encontrado.

• Uma conexão de rede foi perdida no meio das comunicações ou o JVM ficou sem memória.

Algumas dessas exceções são causadas por erro do usuário, outras por erro do programador e outras por recursos físicos que falharam de alguma maneira.

Com base nisso, temos três categorias de exceções. Você precisa entendê-los para saber como o tratamento de exceções funciona em Java.

• Checked exceptions- Uma exceção verificada é uma exceção que é verificada (notificada) pelo compilador em tempo de compilação; elas também são chamadas de exceções de tempo de compilação. Essas exceções não podem ser simplesmente ignoradas, o programador deve cuidar (manipular) essas exceções.

Por exemplo, se você usar FileReaderclasse em seu programa para ler dados de um arquivo, se o arquivo especificado em seu construtor não existir, então ocorre uma FileNotFoundException e o compilador solicita que o programador trate a exceção.

Exemplo

import java.io.File;
import java.io.FileReader;

public class FilenotFound_Demo {

   public static void main(String args[]) {		
      File file = new File("E://file.txt");
      FileReader fr = new FileReader(file); 
   }
}

Se você tentar compilar o programa acima, obterá as seguintes exceções.

Resultado

C:\>javac FilenotFound_Demo.java
FilenotFound_Demo.java:8: error: unreported exception FileNotFoundException; must be caught or declared to be thrown
      FileReader fr = new FileReader(file);
                      ^
1 error

Note - Desde os métodos read() e close() da classe FileReader lança IOException, você pode observar que o compilador notifica para manipular IOException, junto com FileNotFoundException.

• Unchecked exceptions- Uma exceção não verificada é uma exceção que ocorre no momento da execução. Estes também são chamados deRuntime Exceptions. Isso inclui bugs de programação, como erros de lógica ou uso impróprio de uma API. As exceções de tempo de execução são ignoradas no momento da compilação.

Por exemplo, se você declarou uma matriz de tamanho 5 em seu programa e tenta chamar o ^6º elemento da matriz, ocorre uma exceção ArrayIndexOutOfBoundsException .

Exemplo

public class Unchecked_Demo {
   
   public static void main(String args[]) {
      int num[] = {1, 2, 3, 4};
      System.out.println(num[5]);
   }
}

Se você compilar e executar o programa acima, obterá a seguinte exceção.

Resultado

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at Exceptions.Unchecked_Demo.main(Unchecked_Demo.java:8)

• Errors- Não são exceções de forma alguma, mas problemas que surgem além do controle do usuário ou do programador. Os erros são geralmente ignorados em seu código porque você raramente pode fazer algo sobre um erro. Por exemplo, se ocorrer um estouro de pilha, ocorrerá um erro. Eles também são ignorados no momento da compilação.

Hierarquia de exceção

Todas as classes de exceção são subtipos da classe java.lang.Exception. A classe de exceção é uma subclasse da classe Throwable. Além da classe de exceção, há outra subclasse chamada Error, que é derivada da classe Throwable.

Os erros são condições anormais que acontecem em caso de falhas graves e não são tratadas pelos programas Java. Erros são gerados para indicar erros gerados pelo ambiente de tempo de execução. Exemplo: JVM está sem memória. Normalmente, os programas não podem se recuperar de erros.

A classe Exception possui duas subclasses principais: IOException class e RuntimeException Class.

A seguir está uma lista das exceções integradas de Java mais comuns verificadas e não verificadas .

Métodos de exceção

A seguir está a lista de métodos importantes disponíveis na classe Throwable.

Sr. Não.	Método e Descrição
1	public String getMessage() Retorna uma mensagem detalhada sobre a exceção que ocorreu. Esta mensagem é inicializada no construtor Throwable.
2	public Throwable getCause() Retorna a causa da exceção conforme representado por um objeto Throwable.
3	public String toString() Retorna o nome da classe concatenada com o resultado de getMessage ().
4	public void printStackTrace() Imprime o resultado de toString () junto com o rastreamento de pilha em System.err, o fluxo de saída de erro.
5	public StackTraceElement [] getStackTrace() Retorna uma matriz contendo cada elemento no rastreamento da pilha. O elemento no índice 0 representa o topo da pilha de chamadas e o último elemento na matriz representa o método na parte inferior da pilha.
6	public Throwable fillInStackTrace() Preenche o rastreamento de pilha deste objeto Throwable com o rastreamento de pilha atual, adicionando a qualquer informação anterior no rastreamento de pilha.

Captura de exceções

Um método captura uma exceção usando uma combinação de try e catchpalavras-chave. Um bloco try / catch é colocado em torno do código que pode gerar uma exceção. O código dentro de um bloco try / catch é referido como código protegido, e a sintaxe para usar try / catch se parece com a seguinte -

Sintaxe

try {
   // Protected code
} catch (ExceptionName e1) {
   // Catch block
}

O código que está sujeito a exceções é colocado no bloco try. Quando ocorre uma exceção, essa exceção ocorrida é tratada pelo bloco catch associado a ela. Cada bloco try deve ser seguido imediatamente por um bloco catch ou bloco finally.

Uma instrução catch envolve a declaração do tipo de exceção que você está tentando capturar. Se ocorrer uma exceção no código protegido, o bloco catch (ou blocos) que segue o try é verificado. Se o tipo de exceção que ocorreu estiver listado em um bloco catch, a exceção é passada para o bloco catch da mesma forma que um argumento é passado para um parâmetro de método.

Exemplo

A seguir está uma matriz declarada com 2 elementos. Em seguida, o código tenta acessar o ^terceiro elemento da matriz, o que gera uma exceção.

// File Name : ExcepTest.java
import java.io.*;

public class ExcepTest {

   public static void main(String args[]) {
      try {
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

Isso produzirá o seguinte resultado -

Resultado

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

Vários blocos de captura

Um bloco try pode ser seguido por vários blocos catch. A sintaxe para vários blocos catch se parece com a seguinte -

Sintaxe

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}

As instruções anteriores demonstram três blocos catch, mas você pode ter qualquer número deles após uma única tentativa. Se ocorrer uma exceção no código protegido, a exceção é lançada para o primeiro bloco catch na lista. Se o tipo de dados da exceção lançada corresponder a ExceptionType1, ele será detectado lá. Caso contrário, a exceção passa para a segunda instrução catch. Isso continua até que a exceção seja capturada ou falhe em todas as capturas, caso em que o método atual interrompe a execução e a exceção é lançada para o método anterior na pilha de chamadas.

Exemplo

Aqui está o segmento de código que mostra como usar várias instruções try / catch.

try {
   file = new FileInputStream(fileName);
   x = (byte) file.read();
} catch (IOException i) {
   i.printStackTrace();
   return -1;
} catch (FileNotFoundException f) // Not valid! {
   f.printStackTrace();
   return -1;
}

Captura de vários tipos de exceções

Desde o Java 7, você pode manipular mais de uma exceção usando um único bloco catch, esse recurso simplifica o código. Aqui está como você faria isso -

catch (IOException|FileNotFoundException ex) {
   logger.log(ex);
   throw ex;

As Palavras-chave Throws / Throw

Se um método não lida com uma exceção verificada, o método deve declará-lo usando o throwspalavra-chave. A palavra-chave throws aparece no final da assinatura de um método.

Você pode lançar uma exceção, uma recém-instanciada ou uma exceção que acabou de capturar, usando o throw palavra-chave.

Tente entender a diferença entre throws e throw keywords, throws é usado para adiar o tratamento de uma exceção verificada e throw é usado para invocar uma exceção explicitamente.

O método a seguir declara que lança uma RemoteException -

Exemplo

import java.io.*;
public class className {

   public void deposit(double amount) throws RemoteException {
      // Method implementation
      throw new RemoteException();
   }
   // Remainder of class definition
}

Um método pode declarar que lança mais de uma exceção, caso em que as exceções são declaradas em uma lista separada por vírgulas. Por exemplo, o método a seguir declara que lança uma RemoteException e uma InsufficientFundsException -

Exemplo

import java.io.*;
public class className {

   public void withdraw(double amount) throws RemoteException, 
      InsufficientFundsException {
      // Method implementation
   }
   // Remainder of class definition
}

O bloco finalmente

O bloco finalmente segue um bloco try ou um bloco catch. Um bloco final de código sempre é executado, independentemente da ocorrência de uma Exceção.

Usar um bloco finally permite que você execute quaisquer instruções do tipo de limpeza que deseja executar, não importa o que aconteça no código protegido.

Um bloco finalmente aparece no final dos blocos catch e tem a seguinte sintaxe -

Sintaxe

try {
   // Protected code
} catch (ExceptionType1 e1) {
   // Catch block
} catch (ExceptionType2 e2) {
   // Catch block
} catch (ExceptionType3 e3) {
   // Catch block
}finally {
   // The finally block always executes.
}

Exemplo

public class ExcepTest {

   public static void main(String args[]) {
      int a[] = new int[2];
      try {
         System.out.println("Access element three :" + a[3]);
      } catch (ArrayIndexOutOfBoundsException e) {
         System.out.println("Exception thrown  :" + e);
      }finally {
         a[0] = 6;
         System.out.println("First element value: " + a[0]);
         System.out.println("The finally statement is executed");
      }
   }
}

Isso produzirá o seguinte resultado -

Resultado

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
First element value: 6
The finally statement is executed

Observe o seguinte -

• Uma cláusula catch não pode existir sem uma instrução try.

• Não é obrigatório ter cláusulas finally sempre que um bloco try / catch estiver presente.

• O bloco try não pode estar presente sem a cláusula catch ou a cláusula finally.

• Nenhum código pode estar presente entre os blocos try, catch e finally.

O teste com recursos

Geralmente, quando usamos quaisquer recursos como streams, conexões, etc., temos que fechá-los explicitamente usando finally block. No programa a seguir, estamos lendo dados de um arquivo usandoFileReader e o estamos fechando usando o bloco finally.

Exemplo

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadData_Demo {

   public static void main(String args[]) {
      FileReader fr = null;		
      try {
         File file = new File("file.txt");
         fr = new FileReader(file); char [] a = new char[50];
         fr.read(a);   // reads the content to the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }finally {
         try {
            fr.close();
         } catch (IOException ex) {		
            ex.printStackTrace();
         }
      }
   }
}

try-with-resources, também conhecido como automatic resource management, é um novo mecanismo de tratamento de exceções que foi introduzido no Java 7, que fecha automaticamente os recursos usados ​​no bloco try catch.

Para usar esta instrução, você simplesmente precisa declarar os recursos necessários entre parênteses, e o recurso criado será fechado automaticamente no final do bloco. A seguir está a sintaxe da instrução try-with-resources.

Sintaxe

try(FileReader fr = new FileReader("file path")) {
   // use the resource
   } catch () {
      // body of catch 
   }
}

A seguir está o programa que lê os dados em um arquivo usando a instrução try-with-resources.

Exemplo

import java.io.FileReader;
import java.io.IOException;

public class Try_withDemo {

   public static void main(String args[]) {
      try(FileReader fr = new FileReader("E://file.txt")) {
         char [] a = new char[50];
         fr.read(a);   // reads the contentto the array
         for(char c : a)
         System.out.print(c);   // prints the characters one by one
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Os pontos a seguir devem ser mantidos em mente ao trabalhar com a instrução try-with-resources.

• Para usar uma classe com a instrução try-with-resources, ela deve implementar AutoCloseable interface e o close() método dele é chamado automaticamente em tempo de execução.

• Você pode declarar mais de uma classe na instrução try-with-resources.

• Enquanto você declara várias classes no bloco try da instrução try-with-resources, essas classes são fechadas na ordem inversa.

• Exceto pela declaração de recursos entre parênteses, tudo é igual ao bloco try / catch normal de um bloco try.

• O recurso declarado em try é instanciado logo antes do início do bloco try.

• O recurso declarado no bloco try é declarado implicitamente como final.

Exceções definidas pelo usuário

Você pode criar suas próprias exceções em Java. Mantenha os seguintes pontos em mente ao escrever suas próprias classes de exceção -

• Todas as exceções devem ser filho de Throwable.

• Se você deseja escrever uma exceção marcada que é automaticamente imposta pela regra de tratamento ou declaração, você precisa estender a classe de exceção.

• Se você deseja escrever uma exceção de tempo de execução, você precisa estender a classe RuntimeException.

Podemos definir nossa própria classe de exceção conforme abaixo -

class MyException extends Exception {
}

Você só precisa estender o pré-definido Exceptionclasse para criar sua própria exceção. Essas são consideradas exceções verificadas. Os seguintesInsufficientFundsExceptionclasse é uma exceção definida pelo usuário que estende a classe Exception, tornando-a uma exceção verificada. Uma classe de exceção é como qualquer outra classe, contendo campos e métodos úteis.

Exemplo

// File Name InsufficientFundsException.java
import java.io.*;

public class InsufficientFundsException extends Exception {
   private double amount;
   
   public InsufficientFundsException(double amount) {
      this.amount = amount;
   }
   
   public double getAmount() {
      return amount;
   }
}

Para demonstrar o uso de nossa exceção definida pelo usuário, a seguinte classe CheckingAccount contém um métododraw () que lança uma InsufficientFundsException.

// File Name CheckingAccount.java
import java.io.*;

public class CheckingAccount {
   private double balance;
   private int number;
   
   public CheckingAccount(int number) {
      this.number = number;
   }
   
   public void deposit(double amount) {
      balance += amount;
   }
   
   public void withdraw(double amount) throws InsufficientFundsException {
      if(amount <= balance) {
         balance -= amount;
      }else {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
   
   public double getBalance() {
      return balance;
   }
   
   public int getNumber() {
      return number;
   }
}

O programa BankDemo a seguir demonstra como chamar os métodos deposit () e saque () de CheckingAccount.

// File Name BankDemo.java
public class BankDemo {

   public static void main(String [] args) {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500..."); c.deposit(500.00); try { System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600..."); c.withdraw(600.00); } catch (InsufficientFundsException e) { System.out.println("Sorry, but you are short $" + e.getAmount());
         e.printStackTrace();
      }
   }
}

Compile todos os três arquivos acima e execute o BankDemo. Isso produzirá o seguinte resultado -

Resultado

Depositing $500... Withdrawing $100...

Withdrawing $600... Sorry, but you are short $200.0
InsufficientFundsException
         at CheckingAccount.withdraw(CheckingAccount.java:25)
         at BankDemo.main(BankDemo.java:13)

Exceções Comuns

Em Java, é possível definir duas categorias de exceções e erros.

• JVM Exceptions- Essas são exceções / erros que são exclusiva ou logicamente lançados pela JVM. Exemplos: NullPointerException, ArrayIndexOutOfBoundsException, ClassCastException.

• Programmatic Exceptions- Essas exceções são lançadas explicitamente pelo aplicativo ou pelos programadores de API. Exemplos: IllegalArgumentException, IllegalStateException.

Neste capítulo, discutiremos as classes internas de Java.

Classes aninhadas

Em Java, assim como os métodos, as variáveis ​​de uma classe também podem ter outra classe como membro. Escrever uma classe dentro de outra é permitido em Java. A classe escrita dentro é chamada denested class, e a classe que contém a classe interna é chamada de outer class.

Syntax

A seguir está a sintaxe para escrever uma classe aninhada. Aqui a aulaOuter_Demo é a classe externa e a classe Inner_Demo é a classe aninhada.

class Outer_Demo {
   class Inner_Demo {
   }
}

As classes aninhadas são divididas em dois tipos -

• Non-static nested classes - Esses são os membros não estáticos de uma classe.

• Static nested classes - Estes são os membros estáticos de uma classe.

Classes internas (classes aninhadas não estáticas)

As classes internas são um mecanismo de segurança em Java. Sabemos que uma classe não pode ser associada ao modificador de acessoprivate, mas se tivermos a classe como membro de outra classe, a classe interna poderá se tornar privada. E isso também é usado para acessar os membros privados de uma classe.

As classes internas são de três tipos, dependendo de como e onde você as define. Eles são -

• Classe Interna
• Classe interna local do método
• Classe interna anônima

Classe Interna

Criar uma classe interna é bastante simples. Você só precisa escrever uma classe dentro de uma classe. Ao contrário de uma classe, uma classe interna pode ser privada e, uma vez que você declare uma classe interna privada, ela não pode ser acessada de um objeto fora da classe.

A seguir está o programa para criar uma classe interna e acessá-la. No exemplo fornecido, tornamos a classe interna privada e acessamos a classe por meio de um método.

Example

class Outer_Demo {
   int num;
   
   // inner class
   private class Inner_Demo {
      public void print() {
         System.out.println("This is an inner class");
      }
   }
   
   // Accessing he inner class from the method within
   void display_Inner() {
      Inner_Demo inner = new Inner_Demo();
      inner.print();
   }
}
   
public class My_class {

   public static void main(String args[]) {
      // Instantiating the outer class 
      Outer_Demo outer = new Outer_Demo();
      
      // Accessing the display_Inner() method.
      outer.display_Inner();
   }
}

Aqui você pode observar que Outer_Demo é a classe externa, Inner_Demo é a classe interna, display_Inner() é o método dentro do qual estamos instanciando a classe interna, e este método é invocado a partir do main método.

Se você compilar e executar o programa acima, obterá o seguinte resultado -

Output

This is an inner class.

Acessando os membros privados

Conforme mencionado anteriormente, as classes internas também são usadas para acessar os membros privados de uma classe. Suponha que uma classe tenha membros privados para acessá-los. Escreva uma classe interna nele, retorne os membros privados de um método dentro da classe interna, digamos,getValue()e, finalmente, de outra classe (da qual você deseja acessar os membros privados), chame o método getValue () da classe interna.

Para instanciar a classe interna, inicialmente você deve instanciar a classe externa. Depois disso, usando o objeto da classe externa, a seguir está a maneira pela qual você pode instanciar a classe interna.

Outer_Demo outer = new Outer_Demo();
Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();

O programa a seguir mostra como acessar os membros privados de uma classe usando uma classe interna.

Example

class Outer_Demo {
   // private variable of the outer class
   private int num = 175;  
   
   // inner class
   public class Inner_Demo {
      public int getNum() {
         System.out.println("This is the getnum method of the inner class");
         return num;
      }
   }
}

public class My_class2 {

   public static void main(String args[]) {
      // Instantiating the outer class
      Outer_Demo outer = new Outer_Demo();
      
      // Instantiating the inner class
      Outer_Demo.Inner_Demo inner = outer.new Inner_Demo();
      System.out.println(inner.getNum());
   }
}

Se você compilar e executar o programa acima, obterá o seguinte resultado -

Output

This is the getnum method of the inner class: 175

Classe interna local do método

Em Java, podemos escrever uma classe dentro de um método e este será um tipo local. Como as variáveis ​​locais, o escopo da classe interna é restrito ao método.

Uma classe interna local de método pode ser instanciada apenas dentro do método em que a classe interna está definida. O programa a seguir mostra como usar uma classe interna local de método.

Example

public class Outerclass {
   // instance method of the outer class 
   void my_Method() {
      int num = 23;

      // method-local inner class
      class MethodInner_Demo {
         public void print() {
            System.out.println("This is method inner class "+num);	   
         }   
      } // end of inner class
	   
      // Accessing the inner class
      MethodInner_Demo inner = new MethodInner_Demo();
      inner.print();
   }
   
   public static void main(String args[]) {
      Outerclass outer = new Outerclass();
      outer.my_Method();	   	   
   }
}

Se você compilar e executar o programa acima, obterá o seguinte resultado -

Output

This is method inner class 23

Classe interna anônima

Uma classe interna declarada sem um nome de classe é conhecida como um anonymous inner class. No caso de classes internas anônimas, nós as declaramos e instanciamos ao mesmo tempo. Geralmente, eles são usados ​​sempre que você precisa substituir o método de uma classe ou interface. A sintaxe de uma classe interna anônima é a seguinte -

Syntax

AnonymousInner an_inner = new AnonymousInner() {
   public void my_method() {
      ........
      ........
   }   
};

O programa a seguir mostra como substituir o método de uma classe usando uma classe interna anônima.

Example

abstract class AnonymousInner {
   public abstract void mymethod();
}

public class Outer_class {

   public static void main(String args[]) {
      AnonymousInner inner = new AnonymousInner() {
         public void mymethod() {
            System.out.println("This is an example of anonymous inner class");
         }
      };
      inner.mymethod();	
   }
}

Se você compilar e executar o programa acima, obterá o seguinte resultado -

Output

This is an example of anonymous inner class

Da mesma forma, você pode substituir os métodos da classe concreta, bem como a interface, usando uma classe interna anônima.

Classe interna anônima como argumento

Geralmente, se um método aceita um objeto de uma interface, uma classe abstrata ou uma classe concreta, podemos implementar a interface, estender a classe abstrata e passar o objeto para o método. Se for uma classe, podemos passá-la diretamente para o método.

Mas em todos os três casos, você pode passar uma classe interna anônima para o método. Aqui está a sintaxe para passar uma classe interna anônima como um argumento de método -

obj.my_Method(new My_Class() {
   public void Do() {
      .....
      .....
   }
});

O programa a seguir mostra como passar uma classe interna anônima como um argumento de método.

Example

// interface
interface Message {
   String greet();
}

public class My_class {
   // method which accepts the object of interface Message
   public void displayMessage(Message m) {
      System.out.println(m.greet() +
         ", This is an example of anonymous inner class as an argument");  
   }

   public static void main(String args[]) {
      // Instantiating the class
      My_class obj = new My_class();

      // Passing an anonymous inner class as an argument
      obj.displayMessage(new Message() {
         public String greet() {
            return "Hello";
         }
      });
   }
}

Se você compilar e executar o programa acima, ele fornecerá o seguinte resultado -

Output

Hello, This is an example of anonymous inner class as an argument

Classe Aninhada Estática

Uma classe interna estática é uma classe aninhada que é um membro estático da classe externa. Ele pode ser acessado sem instanciar a classe externa, usando outros membros estáticos. Assim como os membros estáticos, uma classe aninhada estática não tem acesso às variáveis ​​de instância e métodos da classe externa. A sintaxe da classe aninhada estática é a seguinte -

Syntax

class MyOuter {
   static class Nested_Demo {
   }
}

Instanciar uma classe aninhada estática é um pouco diferente de instanciar uma classe interna. O programa a seguir mostra como usar uma classe aninhada estática.

Example

public class Outer {
   static class Nested_Demo {
      public void my_method() {
         System.out.println("This is my nested class");
      }
   }
   
   public static void main(String args[]) {
      Outer.Nested_Demo nested = new Outer.Nested_Demo();	 
      nested.my_method();
   }
}

Se você compilar e executar o programa acima, obterá o seguinte resultado -

Output

This is my nested class

A herança pode ser definida como o processo em que uma classe adquire as propriedades (métodos e campos) de outra. Com o uso de herança, as informações são gerenciáveis ​​em uma ordem hierárquica.

A classe que herda as propriedades de outra é conhecida como subclasse (classe derivada, classe filha) e a classe cujas propriedades são herdadas é conhecida como superclasse (classe base, classe pai).

estende a palavra-chave

extendsé a palavra-chave usada para herdar as propriedades de uma classe. A seguir está a sintaxe da palavra-chave extends.

Syntax

class Super {
   .....
   .....
}
class Sub extends Super {
   .....
   .....
}

Código de amostra

A seguir está um exemplo que demonstra a herança Java. Neste exemplo, você pode observar duas classes, a saber, Calculation e My_Calculation.

Usando a palavra-chave extends, o My_Calculation herda os métodos add () e Subtraction () da classe Calculation.

Copie e cole o seguinte programa em um arquivo com o nome My_Calculation.java

Example

class Calculation {
   int z;
	
   public void addition(int x, int y) {
      z = x + y;
      System.out.println("The sum of the given numbers:"+z);
   }
	
   public void Subtraction(int x, int y) {
      z = x - y;
      System.out.println("The difference between the given numbers:"+z);
   }
}

public class My_Calculation extends Calculation {
   public void multiplication(int x, int y) {
      z = x * y;
      System.out.println("The product of the given numbers:"+z);
   }
	
   public static void main(String args[]) {
      int a = 20, b = 10;
      My_Calculation demo = new My_Calculation();
      demo.addition(a, b);
      demo.Subtraction(a, b);
      demo.multiplication(a, b);
   }
}

Compile e execute o código acima conforme mostrado abaixo.

javac My_Calculation.java
java My_Calculation

Depois de executar o programa, ele produzirá o seguinte resultado -

Output

The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200

No programa fornecido, quando um objeto para My_Calculationclasse é criada, uma cópia do conteúdo da superclasse é feita dentro dela. É por isso que, usando o objeto da subclasse, você pode acessar os membros de uma superclasse.

A variável de referência da Superclasse pode conter o objeto da subclasse, mas usando essa variável você pode acessar apenas os membros da superclasse, portanto, para acessar os membros de ambas as classes, é recomendado sempre criar uma variável de referência para a subclasse.

Se você considerar o programa acima, poderá instanciar a classe conforme fornecido a seguir. Mas usando a variável de referência da superclasse (cal neste caso) você não pode chamar o método multiplication(), que pertence à subclasse My_Calculation.

Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);

Note- Uma subclasse herda todos os membros (campos, métodos e classes aninhadas) de sua superclasse. Construtores não são membros, portanto, não são herdados por subclasses, mas o construtor da superclasse pode ser invocado a partir da subclasse.

A super palavra-chave

o super palavra-chave é semelhante a thispalavra-chave. A seguir estão os cenários em que a palavra-chave super é usada.

• É usado para differentiate the members da superclasse dos membros da subclasse, se eles tiverem os mesmos nomes.

• É usado para invoke the superclass construtor da subclasse.

Diferenciando os membros

Se uma classe está herdando as propriedades de outra classe. E se os membros da superclasse têm os mesmos nomes da subclasse, para diferenciar essas variáveis ​​usamos superpalavra-chave conforme mostrado abaixo.

super.variable
super.method();

Código de amostra

Esta seção fornece um programa que demonstra o uso do super palavra-chave.

No programa fornecido, você tem duas classes, nomeadamente Sub_class e Super_class , ambas têm um método denominado display () com diferentes implementações e uma variável denominada num com valores diferentes. Estamos invocando o método display () de ambas as classes e imprimindo o valor da variável num de ambas as classes. Aqui você pode observar que usamos a palavra-chave super para diferenciar os membros da superclasse da subclasse.

Copie e cole o programa em um arquivo com o nome Sub_class.java.

Example

class Super_class {
   int num = 20;

   // display method of superclass
   public void display() {
      System.out.println("This is the display method of superclass");
   }
}

public class Sub_class extends Super_class {
   int num = 10;

   // display method of sub class
   public void display() {
      System.out.println("This is the display method of subclass");
   }

   public void my_method() {
      // Instantiating subclass
      Sub_class sub = new Sub_class();

      // Invoking the display() method of sub class
      sub.display();

      // Invoking the display() method of superclass
      super.display();

      // printing the value of variable num of subclass
      System.out.println("value of the variable named num in sub class:"+ sub.num);

      // printing the value of variable num of superclass
      System.out.println("value of the variable named num in super class:"+ super.num);
   }

   public static void main(String args[]) {
      Sub_class obj = new Sub_class();
      obj.my_method();
   }
}

Compile e execute o código acima usando a seguinte sintaxe.

javac Super_Demo
java Super

Ao executar o programa, você obterá o seguinte resultado -

Output

This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20

Invocando o Construtor de Superclasse

Se uma classe está herdando as propriedades de outra classe, a subclasse adquire automaticamente o construtor padrão da superclasse. Mas se você quiser chamar um construtor parametrizado da superclasse, você precisa usar a palavra-chave super conforme mostrado abaixo.

super(values);

Código de amostra

O programa fornecido nesta seção demonstra como usar a palavra-chave super para invocar o construtor Parametrizado da superclasse. Este programa contém uma superclasse e uma subclasse, onde a superclasse contém um construtor parametrizado que aceita um valor inteiro, e usamos a palavra-chave super para invocar o construtor parametrizado da superclasse.

Copie e cole o seguinte programa em um arquivo com o nome Subclass.java

Example

class Superclass {
   int age;

   Superclass(int age) {
      this.age = age; 		 
   }

   public void getAge() {
      System.out.println("The value of the variable named age in super class is: " +age);
   }
}

public class Subclass extends Superclass {
   Subclass(int age) {
      super(age);
   }

   public static void main(String args[]) {
      Subclass s = new Subclass(24);
      s.getAge();
   }
}

Compile e execute o código acima usando a seguinte sintaxe.

javac Subclass
java Subclass

Ao executar o programa, você obterá o seguinte resultado -

Output

The value of the variable named age in super class is: 24

Relacionamento IS-A

IS-A é uma maneira de dizer: este objeto é um tipo desse objeto. Vamos ver como oextends palavra-chave é usada para obter herança.

public class Animal {
}

public class Mammal extends Animal {
}

public class Reptile extends Animal {
}

public class Dog extends Mammal {
}

Agora, com base no exemplo acima, em termos orientados a objetos, o seguinte é verdadeiro -

• Animal é a superclasse da classe Mammal.
• Animal é a superclasse da classe Reptile.
• Mamífero e Réptil são subclasses da classe Animal.
• Cachorro é a subclasse das classes Mamíferos e Animais.

Agora, se considerarmos o relacionamento IS-A, podemos dizer -

• Mamífero É-Um Animal
• Réptil É-Um Animal
• Cão É um mamífero
• Portanto: Cachorro É-Um Animal também

Com o uso da palavra-chave extends, as subclasses serão capazes de herdar todas as propriedades da superclasse, exceto as propriedades privadas da superclasse.

Podemos garantir que Mammal é realmente um Animal com o uso do operador de instância.

Example

class Animal {
}

class Mammal extends Animal {
}

class Reptile extends Animal {
}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Animal a = new Animal();
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

Isso produzirá o seguinte resultado -

Output

true
true
true

Uma vez que temos um bom entendimento do extends palavra-chave, vejamos como o implements palavra-chave é usada para obter o relacionamento IS-A.

Geralmente, o implementspalavra-chave é usada com classes para herdar as propriedades de uma interface. As interfaces nunca podem ser estendidas por uma classe.

Example

public interface Animal {
}

public class Mammal implements Animal {
}

public class Dog extends Mammal {
}

A instância da palavra-chave

Vamos usar o instanceof operador para verificar se o mamífero é realmente um animal e se o cão é realmente um animal.

Example

interface Animal{}
class Mammal implements Animal{}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

Isso produzirá o seguinte resultado -

Output

true
true
true

Relação HAS-A

Essas relações são baseadas principalmente no uso. Isso determina se uma certa classeHAS-Adeterminada coisa. Essa relação ajuda a reduzir a duplicação de código e também os bugs.

Vejamos um exemplo -

Example

public class Vehicle{}
public class Speed{}

public class Van extends Vehicle {
   private Speed sp;
}

Isso mostra que a classe Van HAS-A Speed. Por ter uma classe separada para Speed, não precisamos colocar todo o código pertencente a speed dentro da classe Van, o que torna possível reutilizar a classe Speed ​​em vários aplicativos.

No recurso Orientado a Objetos, os usuários não precisam se preocupar com qual objeto está fazendo o trabalho real. Para conseguir isso, a classe Van oculta os detalhes de implementação dos usuários da classe Van. Então, basicamente o que acontece é que os usuários pediriam à classe Van para fazer uma determinada ação e a classe Van faria o trabalho sozinha ou pediria a outra classe para executar a ação.

Tipos de herança

Existem vários tipos de herança, conforme demonstrado abaixo.

Um fato muito importante a lembrar é que Java não oferece suporte a herança múltipla. Isso significa que uma classe não pode estender mais de uma classe. Portanto, seguir é ilegal -

Example

public class extends Animal, Mammal{}

No entanto, uma classe pode implementar uma ou mais interfaces, o que ajudou o Java a se livrar da impossibilidade de herança múltipla.

No capítulo anterior, falamos sobre superclasses e subclasses. Se uma classe herda um método de sua superclasse, há uma chance de sobrescrever o método, desde que ele não seja marcado como final.

O benefício da substituição é: capacidade de definir um comportamento específico para o tipo de subclasse, o que significa que uma subclasse pode implementar um método de classe pai com base em seus requisitos.

Em termos orientados a objetos, substituir significa substituir a funcionalidade de um método existente.

Exemplo

Vamos ver um exemplo.

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
   }
}

Isso produzirá o seguinte resultado -

Resultado

Animals can move
Dogs can walk and run

No exemplo acima, você pode ver que embora bé um tipo de Animal que executa o método move na classe Dog. O motivo é: Em tempo de compilação, a verificação é feita no tipo de referência. No entanto, no tempo de execução, a JVM descobre o tipo de objeto e executa o método que pertence a esse objeto específico.

Portanto, no exemplo acima, o programa irá compilar corretamente, uma vez que a classe Animal possui o método move. Então, em tempo de execução, ele executa o método específico para aquele objeto.

Considere o seguinte exemplo -

Exemplo

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      System.out.println("Dogs can walk and run");
   }
   public void bark() {
      System.out.println("Dogs can bark");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal();   // Animal reference and object
      Animal b = new Dog();   // Animal reference but Dog object

      a.move();   // runs the method in Animal class
      b.move();   // runs the method in Dog class
      b.bark();
   }
}

Isso produzirá o seguinte resultado -

Resultado

TestDog.java:26: error: cannot find symbol
      b.bark();
       ^
  symbol:   method bark()
  location: variable b of type Animal
1 error

Este programa lançará um erro de tempo de compilação, pois o tipo de referência de b Animal não tem um método com o nome de bark.

Regras para Substituição de Método

• A lista de argumentos deve ser exatamente a mesma do método sobrescrito.

• O tipo de retorno deve ser o mesmo ou um subtipo do tipo de retorno declarado no método original sobrescrito na superclasse.

• O nível de acesso não pode ser mais restritivo do que o nível de acesso do método substituído. Por exemplo: Se o método da superclasse for declarado público, o método de substituição na subclasse não pode ser privado ou protegido.

• Os métodos de instância podem ser substituídos apenas se forem herdados pela subclasse.

• Um método declarado final não pode ser substituído.

• Um método declarado como estático não pode ser substituído, mas pode ser declarado novamente.

• Se um método não pode ser herdado, ele não pode ser substituído.

• Uma subclasse dentro do mesmo pacote que a superclasse da instância pode sobrescrever qualquer método da superclasse que não seja declarado privado ou final.

• Uma subclasse em um pacote diferente só pode substituir os métodos não finais declarados públicos ou protegidos.

• Um método de substituição pode lançar quaisquer exceções não verificadas, independentemente de o método substituído lançar exceções ou não. No entanto, o método de substituição não deve lançar exceções verificadas que são novas ou mais amplas do que as declaradas pelo método de substituição. O método de substituição pode lançar exceções mais restritas ou menos do que o método substituído.

• Construtores não podem ser substituídos.

Usando a super palavra-chave

Ao invocar uma versão da superclasse de um método sobrescrito, o super palavra-chave é usada.

Exemplo

class Animal {
   public void move() {
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {
   public void move() {
      super.move();   // invokes the super class method
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal b = new Dog();   // Animal reference but Dog object
      b.move();   // runs the method in Dog class
   }
}

Isso produzirá o seguinte resultado -

Resultado

Animals can move
Dogs can walk and run

Polimorfismo é a capacidade de um objeto de assumir várias formas. O uso mais comum de polimorfismo em OOP ocorre quando uma referência de classe pai é usada para se referir a um objeto de classe filho.

Qualquer objeto Java que pode passar em mais de um teste IS-A é considerado polimórfico. Em Java, todos os objetos Java são polimórficos, pois qualquer objeto passará no teste IS-A para seu próprio tipo e para a classe Object.

É importante saber que a única forma possível de acessar um objeto é por meio de uma variável de referência. Uma variável de referência pode ser de apenas um tipo. Uma vez declarado, o tipo de uma variável de referência não pode ser alterado.

A variável de referência pode ser reatribuída a outros objetos, desde que não seja declarada final. O tipo da variável de referência determinaria os métodos que ela pode invocar no objeto.

Uma variável de referência pode se referir a qualquer objeto de seu tipo declarado ou qualquer subtipo de seu tipo declarado. Uma variável de referência pode ser declarada como uma classe ou tipo de interface.

Exemplo

Vamos ver um exemplo.

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

Agora, a classe Deer é considerada polimórfica, pois tem herança múltipla. A seguir são verdadeiros para os exemplos acima -

• Um cervo é um animal
• A Deer IS-A Vegetarian
• A Deer IS-A Deer
• Um cervo é um objeto

Quando aplicamos os fatos da variável de referência a uma referência de objeto Deer, as seguintes declarações são legais -

Exemplo

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

Todas as variáveis ​​de referência d, a, v, o referem-se ao mesmo objeto Deer no heap.

Métodos Virtuais

Nesta seção, mostrarei como o comportamento dos métodos substituídos em Java permite que você aproveite o polimorfismo ao projetar suas classes.

Já discutimos a substituição de método, onde uma classe filha pode substituir um método em seu pai. Um método sobrescrito está essencialmente oculto na classe pai e não é chamado a menos que a classe filha use a palavra-chave super no método de sobrescrita.

Exemplo

/* File name : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}

Agora, suponha que estendamos a classe Employee da seguinte forma -

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary; // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName()
      + " with salary " + salary);
   }
   
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Agora, você estuda o seguinte programa cuidadosamente e tenta determinar sua saída -

/* File name : VirtualDemo.java */
public class VirtualDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");   
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Isso produzirá o seguinte resultado -

Resultado

Constructing an Employee
Constructing an Employee

Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

Aqui, instanciamos dois objetos Salário. Um usando uma referência de salários, e o outro usando uma referência de funcionário e.

Ao invocar s.mailCheck () , o compilador vê mailCheck () na classe Salary em tempo de compilação e a JVM chama mailCheck () na classe Salary em tempo de execução.

mailCheck () em e é bem diferente porque eé uma referência do funcionário. Quando o compilador vê e.mailCheck () , o compilador vê o método mailCheck () na classe Employee.

Aqui, em tempo de compilação, o compilador usou mailCheck () em Employee para validar esta declaração. No tempo de execução, entretanto, a JVM chama mailCheck () na classe Salary.

Esse comportamento é conhecido como invocação de método virtual e esses métodos são chamados de métodos virtuais. Um método sobrescrito é invocado em tempo de execução, não importa o tipo de dados de referência que foi usado no código-fonte em tempo de compilação.

De acordo com o dicionário, abstractioné a qualidade de lidar com ideias e não com eventos. Por exemplo, quando você considera o caso do e-mail, detalhes complexos, como o que acontece assim que você envia um e-mail, o protocolo que seu servidor de e-mail usa são ocultados do usuário. Portanto, para enviar um e-mail basta digitar o conteúdo, citar o endereço do destinatário e clicar em enviar.

Da mesma forma na programação orientada a objetos, a abstração é um processo de ocultar os detalhes da implementação do usuário, apenas a funcionalidade será fornecida ao usuário. Em outras palavras, o usuário terá as informações sobre o que o objeto faz e não como o faz.

Em Java, a abstração é obtida usando classes e interfaces abstratas.

Classe Abstrata

Uma classe que contém o abstract palavra-chave em sua declaração é conhecida como classe abstrata.

• As classes abstratas podem ou não conter métodos abstratos , ou seja, métodos sem corpo (public void get ();)

• Mas, se uma classe tem pelo menos um método abstrato, então a classe must ser declarado abstrato.

• Se uma classe for declarada abstrata, ela não pode ser instanciada.

• Para usar uma classe abstrata, você precisa herdá-la de outra classe, fornecer implementações para os métodos abstratos nela.

• Se você herdar uma classe abstrata, terá que fornecer implementações para todos os métodos abstratos nela.

Exemplo

Esta seção fornece um exemplo da classe abstrata. Para criar uma classe abstrata, basta usar oabstract palavra-chave antes da palavra-chave class, na declaração de classe.

/* File name : Employee.java */
public abstract class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   
   public double computePay() {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }
 
   public String getAddress() {
      return address;
   }
   
   public void setAddress(String newAddress) {
      address = newAddress;
   }
 
   public int getNumber() {
      return number;
   }
}

Você pode observar que, exceto os métodos abstratos, a classe Employee é igual à classe normal em Java. A classe agora é abstrata, mas ainda tem três campos, sete métodos e um construtor.

Agora você pode tentar instanciar a classe Employee da seguinte maneira -

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      /* Following is not allowed and would raise error */
      Employee e = new Employee("George W.", "Houston, TX", 43);
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Quando você compila a classe acima, obtém o seguinte erro -

Employee.java:46: Employee is abstract; cannot be instantiated
      Employee e = new Employee("George W.", "Houston, TX", 43);
                   ^
1 error

Herdando a classe abstrata

Podemos herdar as propriedades da classe Employee assim como a classe concreta da seguinte maneira -

Exemplo

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName() + " with salary " + salary);
   }
 
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Aqui, você não pode instanciar a classe Employee, mas pode instanciar a classe Salary e, usando essa instância, pode acessar todos os três campos e sete métodos da classe Employee, conforme mostrado abaixo.

/* File name : AbstractDemo.java */
public class AbstractDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Isso produz o seguinte resultado -

Resultado

Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class 
Mailing check to Mohd Mohtashim with salary 3600.0

 Call mailCheck using Employee reference--
Within mailCheck of Salary class 
Mailing check to John Adams with salary 2400.0

Métodos Abstratos

Se você deseja que uma classe contenha um método específico, mas deseja que a implementação real desse método seja determinada por classes filhas, você pode declarar o método na classe pai como um abstrato.

• abstract palavra-chave é usada para declarar o método como abstrato.

• Você tem que colocar o abstract palavra-chave antes do nome do método na declaração do método.

• Um método abstrato contém uma assinatura de método, mas nenhum corpo de método.

• Em vez de chaves, um método abstrato terá dois pontos semoi (;) no final.

A seguir está um exemplo do método abstrato.

Exemplo

public abstract class Employee {
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   // Remainder of class definition
}

Declarar um método como abstrato tem duas consequências -

• A classe que o contém deve ser declarada como abstrata.

• Qualquer classe que herde a classe atual deve substituir o método abstrato ou declarar-se como abstrato.

Note- Eventualmente, uma classe descendente tem que implementar o método abstrato; caso contrário, você teria uma hierarquia de classes abstratas que não podem ser instanciadas.

Suponha que a classe Salary herde a classe Employee, então ela deve implementar o computePay() método como mostrado abaixo -

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary;   // Annual salary
  
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
   // Remainder of class definition
}

Encapsulationé um dos quatro conceitos OOP fundamentais. Os outros três são herança, polimorfismo e abstração.

O encapsulamento em Java é um mecanismo de agrupar os dados (variáveis) e o código que atua nos dados (métodos) juntos como uma única unidade. No encapsulamento, as variáveis ​​de uma classe serão ocultadas de outras classes e podem ser acessadas apenas por meio dos métodos de sua classe atual. Portanto, também é conhecido comodata hiding.

Para conseguir encapsulamento em Java -

• Declare as variáveis ​​de uma classe como privadas.

• Fornece métodos setter e getter públicos para modificar e visualizar os valores das variáveis.

Exemplo

A seguir está um exemplo que demonstra como obter encapsulamento em Java -

/* File name : EncapTest.java */
public class EncapTest {
   private String name;
   private String idNum;
   private int age;

   public int getAge() {
      return age;
   }

   public String getName() {
      return name;
   }

   public String getIdNum() {
      return idNum;
   }

   public void setAge( int newAge) {
      age = newAge;
   }

   public void setName(String newName) {
      name = newName;
   }

   public void setIdNum( String newId) {
      idNum = newId;
   }
}

Os métodos públicos setXXX () e getXXX () são os pontos de acesso das variáveis ​​de instância da classe EncapTest. Normalmente, esses métodos são chamados de getters e setters. Portanto, qualquer classe que deseja acessar as variáveis ​​deve acessá-las por meio desses getters e setters.

As variáveis ​​da classe EncapTest podem ser acessadas usando o seguinte programa -

/* File name : RunEncap.java */
public class RunEncap {

   public static void main(String args[]) {
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");

      System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
   }
}

Isso produzirá o seguinte resultado -

Resultado

Name : James Age : 20

Benefícios do encapsulamento

• Os campos de uma classe podem ser somente leitura ou somente gravação.

• Uma classe pode ter controle total sobre o que está armazenado em seus campos.

Uma interface é um tipo de referência em Java. É semelhante à aula. É uma coleção de métodos abstratos. Uma classe implementa uma interface, herdando assim os métodos abstratos da interface.

Junto com métodos abstratos, uma interface também pode conter constantes, métodos padrão, métodos estáticos e tipos aninhados. Corpos de método existem apenas para métodos padrão e métodos estáticos.

Escrever uma interface é semelhante a escrever uma classe. Mas uma classe descreve os atributos e comportamentos de um objeto. E uma interface contém comportamentos que uma classe implementa.

A menos que a classe que implementa a interface seja abstrata, todos os métodos da interface precisam ser definidos na classe.

Uma interface é semelhante a uma classe das seguintes maneiras -

• Uma interface pode conter vários métodos.

• Uma interface é escrita em um arquivo com um .java extensão, com o nome da interface correspondendo ao nome do arquivo.

• O código de byte de uma interface aparece em um .class Arquivo.

• As interfaces aparecem nos pacotes, e seu arquivo bytecode correspondente deve estar em uma estrutura de diretório que corresponda ao nome do pacote.

No entanto, uma interface é diferente de uma classe de várias maneiras, incluindo -

• Você não pode instanciar uma interface.

• Uma interface não contém nenhum construtor.

• Todos os métodos em uma interface são abstratos.

• Uma interface não pode conter campos de instância. Os únicos campos que podem aparecer em uma interface devem ser declarados estáticos e finais.

• Uma interface não é estendida por uma classe; é implementado por uma classe.

• Uma interface pode estender várias interfaces.

Declaração de interfaces

o interfacepalavra-chave é usada para declarar uma interface. Aqui está um exemplo simples para declarar uma interface -

Exemplo

A seguir está um exemplo de uma interface -

/* File name : NameOfInterface.java */
import java.lang.*;
// Any number of import statements

public interface NameOfInterface {
   // Any number of final, static fields
   // Any number of abstract method declarations\
}

As interfaces têm as seguintes propriedades -

• Uma interface é implicitamente abstrata. Você não precisa usar oabstract palavra-chave ao declarar uma interface.

• Cada método em uma interface também é implicitamente abstrato, portanto, a palavra-chave abstract não é necessária.

• Os métodos em uma interface são implicitamente públicos.

Exemplo

/* File name : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

Implementando Interfaces

Quando uma classe implementa uma interface, você pode pensar na classe como uma assinatura de um contrato, concordando em realizar os comportamentos específicos da interface. Se uma classe não executa todos os comportamentos da interface, ela deve se declarar abstrata.

Uma classe usa o implementspalavra-chave para implementar uma interface. A palavra-chave implements aparece na declaração de classe após a parte extends da declaração.

Exemplo

/* File name : MammalInt.java */
public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

Isso produzirá o seguinte resultado -

Resultado

Mammal eats
Mammal travels

Ao substituir métodos definidos em interfaces, existem várias regras a serem seguidas -

• As exceções verificadas não devem ser declaradas em métodos de implementação diferentes daqueles declarados pelo método de interface ou subclasses daqueles declarados pelo método de interface.

• A assinatura do método de interface e o mesmo tipo de retorno ou subtipo devem ser mantidos ao substituir os métodos.

• Uma classe de implementação em si pode ser abstrata e, nesse caso, os métodos de interface não precisam ser implementados.

Quando interfaces de implementação, existem várias regras -

• Uma classe pode implementar mais de uma interface por vez.

• Uma classe pode estender apenas uma classe, mas implementar muitas interfaces.

• Uma interface pode estender outra interface, da mesma forma que uma classe pode estender outra classe.

Estendendo Interfaces

Uma interface pode estender outra interface da mesma maneira que uma classe pode estender outra classe. oextends A palavra-chave é usada para estender uma interface, e a interface filha herda os métodos da interface pai.

A seguinte interface de esportes é estendida pelas interfaces de hóquei e futebol.

Exemplo

// Filename: Sports.java
public interface Sports {
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

// Filename: Football.java
public interface Football extends Sports {
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

// Filename: Hockey.java
public interface Hockey extends Sports {
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

A interface Hockey tem quatro métodos, mas herda dois de Sports; portanto, uma classe que implementa Hockey precisa implementar todos os seis métodos. Da mesma forma, uma classe que implementa Futebol precisa definir os três métodos de Futebol e os dois métodos de Esportes.

Estendendo Múltiplas Interfaces

Uma classe Java pode estender apenas uma classe pai. A herança múltipla não é permitida. As interfaces não são classes, entretanto, e uma interface pode estender mais de uma interface pai.

A palavra-chave extends é usada uma vez e as interfaces pai são declaradas em uma lista separada por vírgulas.

Por exemplo, se a interface do Hockey estendesse tanto Esportes quanto Eventos, seria declarada como -

Exemplo

public interface Hockey extends Sports, Event

Interfaces de marcação

O uso mais comum de extensões de interfaces ocorre quando a interface pai não contém nenhum método. Por exemplo, a interface MouseListener no pacote java.awt.event estendido java.util.EventListener, que é definido como -

Exemplo

package java.util;
public interface EventListener
{}

Uma interface sem métodos é chamada de tagginginterface. Existem dois objetivos básicos de design de interfaces de marcação -

Creates a common parent- Assim como a interface EventListener, que é estendida por dezenas de outras interfaces na API Java, você pode usar uma interface de marcação para criar um pai comum entre um grupo de interfaces. Por exemplo, quando uma interface estende EventListener, a JVM sabe que essa interface específica será usada em um cenário de delegação de evento.

Adds a data type to a class- É dessa situação que vem o termo marcação. Uma classe que implementa uma interface de marcação não precisa definir nenhum método (já que a interface não tem nenhum), mas a classe se torna um tipo de interface por meio de polimorfismo.

Os pacotes são usados ​​em Java para evitar conflitos de nomenclatura, para controlar o acesso, para tornar mais fácil a pesquisa / localização e uso de classes, interfaces, enumerações e anotações, etc.

UMA Package pode ser definido como um agrupamento de tipos relacionados (classes, interfaces, enumerações e anotações) fornecendo proteção de acesso e gerenciamento de namespace.

Alguns dos pacotes existentes em Java são -

• java.lang - agrupa as classes fundamentais

• java.io - classes para funções de entrada e saída estão incluídas neste pacote

Os programadores podem definir seus próprios pacotes para agrupar grupos de classes / interfaces, etc. É uma boa prática agrupar classes relacionadas implementadas por você para que um programador possa determinar facilmente que as classes, interfaces, enumerações e anotações estão relacionadas.

Como o pacote cria um novo namespace, não haverá conflitos de nome com nomes de outros pacotes. Usando pacotes, é mais fácil fornecer controle de acesso e também é mais fácil localizar as classes relacionadas.

Criando um Pacote

Ao criar um pacote, você deve escolher um nome para o pacote e incluir um package junto com esse nome no início de cada arquivo de origem que contém as classes, interfaces, enumerações e tipos de anotação que você deseja incluir no pacote.

A instrução do pacote deve ser a primeira linha no arquivo de origem. Pode haver apenas uma instrução de pacote em cada arquivo de origem e se aplica a todos os tipos no arquivo.

Se uma instrução de pacote não for usada, a classe, as interfaces, as enumerações e os tipos de anotação serão colocados no pacote padrão atual.

Para compilar os programas Java com instruções de pacote, você deve usar a opção -d conforme mostrado abaixo.

javac -d Destination_folder file_name.java

Em seguida, uma pasta com o nome de pacote fornecido é criada no destino especificado e os arquivos de classe compilados serão colocados nessa pasta.

Exemplo

Vejamos um exemplo que cria um pacote chamado animals. É uma boa prática usar nomes de pacotes com letras minúsculas para evitar conflitos com os nomes das classes e interfaces.

O exemplo de pacote a seguir contém uma interface chamada animals -

/* File name : Animal.java */
package animals;

interface Animal {
   public void eat();
   public void travel();
}

Agora, vamos implementar a interface acima no mesmo pacote de animais -

package animals;
/* File name : MammalInt.java */

public class MammalInt implements Animal {

   public void eat() {
      System.out.println("Mammal eats");
   }

   public void travel() {
      System.out.println("Mammal travels");
   } 

   public int noOfLegs() {
      return 0;
   }

   public static void main(String args[]) {
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

Agora compile os arquivos java conforme mostrado abaixo -

$ javac -d . Animal.java $ javac -d . MammalInt.java

Agora um pacote / pasta com o nome animals será criado no diretório atual e esses arquivos de classe serão colocados nele conforme mostrado abaixo.

Você pode executar o arquivo de classe dentro do pacote e obter o resultado conforme mostrado abaixo.

Mammal eats
Mammal travels

A palavra-chave de importação

Se uma classe deseja usar outra classe no mesmo pacote, o nome do pacote não precisa ser usado. As classes no mesmo pacote se encontram sem nenhuma sintaxe especial.

Exemplo

Aqui, uma classe chamada Boss é adicionada ao pacote da folha de pagamento que já contém Employee. O Boss pode então referir-se à classe Employee sem usar o prefixo da folha de pagamento, conforme demonstrado pela seguinte classe Boss.

package payroll;
public class Boss {
   public void payEmployee(Employee e) {
      e.mailCheck();
   }
}

O que acontece se a classe Funcionário não estiver no pacote de folha de pagamento? A classe Boss deve então usar uma das seguintes técnicas para se referir a uma classe em um pacote diferente.

• O nome totalmente qualificado da classe pode ser usado. Por exemplo -

payroll.Employee

• O pacote pode ser importado usando a palavra-chave import e o curinga (*). Por exemplo -

import payroll.*;

• A própria classe pode ser importada usando a palavra-chave import. Por exemplo -

import payroll.Employee;

Note- Um arquivo de classe pode conter qualquer número de instruções de importação. As instruções de importação devem aparecer após a instrução do pacote e antes da declaração da classe.

A Estrutura do Diretório dos Pacotes

Dois resultados principais ocorrem quando uma classe é colocada em um pacote -

• O nome do pacote passa a fazer parte do nome da classe, conforme discutimos na seção anterior.

• O nome do pacote deve corresponder à estrutura de diretório onde reside o bytecode correspondente.

Esta é uma maneira simples de gerenciar seus arquivos em Java -

Coloque o código-fonte de uma classe, interface, enumeração ou tipo de anotação em um arquivo de texto cujo nome é o nome simples do tipo e cuja extensão é .java.

Por exemplo -

// File Name :  Car.java
package vehicle;

public class Car {
   // Class implementation.   
}

Agora, coloque o arquivo de origem em um diretório cujo nome reflita o nome do pacote ao qual a classe pertence -

....\vehicle\Car.java

Agora, o nome da classe qualificada e o nome do caminho seriam os seguintes -

• Nome da classe → veículo.Carro
• Nome do caminho → veículo \ Car.java (no Windows)

Em geral, uma empresa usa seu nome de domínio da Internet invertido para seus nomes de pacote.

Example- O nome de domínio de Internet de uma empresa é apple.com, todos os nomes de seus pacotes começam com com.apple. Cada componente do nome do pacote corresponde a um subdiretório.

Example - A empresa tinha um pacote com.apple.computers que continha um arquivo de origem Dell.java, que estaria contido em uma série de subdiretórios como este -

....\com\apple\computers\Dell.java

No momento da compilação, o compilador cria um arquivo de saída diferente para cada classe, interface e enumeração definida nele. O nome base do arquivo de saída é o nome do tipo e sua extensão é.class.

Por exemplo -

// File Name: Dell.java
package com.apple.computers;

public class Dell {
}

class Ups {
}

Agora, compile este arquivo como segue usando a opção -d -

$javac -d . Dell.java

Os arquivos serão compilados da seguinte forma -

.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class

Você pode importar todas as classes ou interfaces definidas em \ com \ apple \ computers \ como segue -

import com.apple.computers.*;

Como os arquivos de origem .java, os arquivos .class compilados devem estar em uma série de diretórios que refletem o nome do pacote. No entanto, o caminho para os arquivos .class não precisa ser igual ao caminho para os arquivos de origem .java. Você pode organizar seus diretórios de origem e de classe separadamente, como -

<path-one>\sources\com\apple\computers\Dell.java

<path-two>\classes\com\apple\computers\Dell.class

Fazendo isso, é possível dar acesso ao diretório de classes a outros programadores sem revelar suas fontes. Você também precisa gerenciar os arquivos de origem e de classe dessa maneira para que o compilador e a Java Virtual Machine (JVM) possam encontrar todos os tipos que seu programa usa.

O caminho completo para o diretório de classes, <path-two> \ classes, é chamado de caminho de classe e é definido com a variável de sistema CLASSPATH. Tanto o compilador quanto a JVM constroem o caminho para seus arquivos .class adicionando o nome do pacote ao caminho da classe.

Digamos que <path-two> \ classes é o caminho da classe e o nome do pacote é com.apple.computers, então o compilador e a JVM procurarão por arquivos .class em <path-two> \ classes \ com \ apple \ computers.

Um caminho de classe pode incluir vários caminhos. Vários caminhos devem ser separados por ponto e vírgula (Windows) ou dois pontos (Unix). Por padrão, o compilador e a JVM procuram o diretório atual e o arquivo JAR que contém as classes da plataforma Java para que esses diretórios estejam automaticamente no caminho da classe.

Definir variável de sistema CLASSPATH

Para exibir a variável CLASSPATH atual, use os seguintes comandos no Windows e UNIX (shell Bourne) -

• No Windows → C: \> definir CLASSPATH
• Em UNIX →% echo $ CLASSPATH

Para excluir o conteúdo atual da variável CLASSPATH, use -

• No Windows → C: \> defina CLASSPATH =
• Em UNIX →% unset CLASSPATH; exportar CLASSPATH

Para definir a variável CLASSPATH -

• No Windows → defina CLASSPATH = C: \ users \ jack \ java \ classes
• Em UNIX →% CLASSPATH = / home / jack / java / classes; exportar CLASSPATH

As estruturas de dados fornecidas pelo pacote de utilitários Java são muito poderosas e executam uma ampla variedade de funções. Essas estruturas de dados consistem nas seguintes interfaces e classes -

• Enumeration
• BitSet
• Vector
• Stack
• Dictionary
• Hashtable
• Properties

Todas essas classes agora são legadas e Java-2 introduziu uma nova estrutura chamada Collections Framework, que é discutida no próximo capítulo. -

A Enumeração

A interface Enumeration em si não é uma estrutura de dados, mas é muito importante no contexto de outras estruturas de dados. A interface Enumeration define um meio de recuperar elementos sucessivos de uma estrutura de dados.

Por exemplo, Enumeration define um método chamado nextElement que é usado para obter o próximo elemento em uma estrutura de dados que contém vários elementos.

Para ter mais detalhes sobre esta interface, verifique The Enumeration .

O BitSet

A classe BitSet implementa um grupo de bits ou sinalizadores que podem ser definidos e limpos individualmente.

Esta classe é muito útil nos casos em que você precisa se manter atualizado com um conjunto de valores booleanos; você apenas atribui um bit a cada valor e define ou apaga conforme apropriado.

Para obter mais detalhes sobre esta classe, verifique The BitSet .

O vetor

A classe Vector é semelhante a um array Java tradicional, exceto que pode crescer conforme necessário para acomodar novos elementos.

Como uma matriz, os elementos de um objeto Vector podem ser acessados ​​por meio de um índice no vetor.

O bom de usar a classe Vector é que você não precisa se preocupar em defini-la para um tamanho específico na criação; ele encolhe e cresce automaticamente quando necessário.

Para obter mais detalhes sobre esta classe, verifique The Vector .

A pilha

A classe Stack implementa uma pilha de elementos LIFO (last-in-first-out).

Você pode pensar em uma pilha literalmente como uma pilha vertical de objetos; quando você adiciona um novo elemento, ele é empilhado em cima dos outros.

Quando você puxa um elemento da pilha, ele sai do topo. Em outras palavras, o último elemento adicionado à pilha é o primeiro a retornar.

Para obter mais detalhes sobre esta classe, consulte The Stack .

O dicionário

A classe Dictionary é uma classe abstrata que define uma estrutura de dados para mapear chaves para valores.

Isso é útil nos casos em que você deseja acessar dados por meio de uma chave específica, em vez de um índice inteiro.

Como a classe Dictionary é abstrata, ela fornece apenas a estrutura para uma estrutura de dados mapeada por chave, em vez de uma implementação específica.

Para obter mais detalhes sobre esta aula, consulte O Dicionário .

The Hashtable

A classe Hashtable fornece um meio de organizar dados com base em alguma estrutura de chave definida pelo usuário.

Por exemplo, em uma tabela de hash de lista de endereços, você pode armazenar e classificar dados com base em uma chave, como o CEP, em vez do nome de uma pessoa.

O significado específico das chaves em relação às tabelas hash é totalmente dependente do uso da tabela hash e dos dados que ela contém.

Para obter mais detalhes sobre esta classe, verifique The Hashtable .

As Propriedades

Propriedades é uma subclasse de Hashtable. É usado para manter listas de valores em que a chave é uma String e o valor também é uma String.

A classe Properties é usada por muitas outras classes Java. Por exemplo, é o tipo de objeto retornado por System.getProperties () ao obter valores ambientais.

Para obter mais detalhes sobre esta classe, verifique as propriedades .

Antes do Java 2, o Java fornecia classes ad hoc, como Dictionary, Vector, Stack, e Propertiespara armazenar e manipular grupos de objetos. Embora essas classes fossem bastante úteis, careciam de um tema central e unificador. Portanto, a maneira como você usou o Vector foi diferente da maneira como você usou as Propriedades.

A estrutura de coleções foi projetada para atender a vários objetivos, tais como -

• A estrutura precisava ser de alto desempenho. As implementações para as coleções fundamentais (matrizes dinâmicas, listas vinculadas, árvores e tabelas de hash) deveriam ser altamente eficientes.

• A estrutura precisava permitir que diferentes tipos de coleções funcionassem de maneira semelhante e com um alto grau de interoperabilidade.

• A estrutura teve que estender e / ou adaptar uma coleção facilmente.

Para esse fim, toda a estrutura de coleções é projetada em torno de um conjunto de interfaces padrão. Várias implementações padrão, comoLinkedList, HashSet, e TreeSet, dessas interfaces são fornecidas para que você possa usar no estado em que se encontra e também pode implementar sua própria coleção, se desejar.

Uma estrutura de coleções é uma arquitetura unificada para representar e manipular coleções. Todas as estruturas de coleções contêm o seguinte -

• Interfaces- Esses são tipos de dados abstratos que representam coleções. As interfaces permitem que as coleções sejam manipuladas independentemente dos detalhes de sua representação. Em linguagens orientadas a objetos, as interfaces geralmente formam uma hierarquia.

• Implementations, i.e., Classes- Estas são as implementações concretas das interfaces de coleção. Em essência, eles são estruturas de dados reutilizáveis.

• Algorithms- Esses são os métodos que executam cálculos úteis, como pesquisa e classificação, em objetos que implementam interfaces de coleção. Os algoritmos são polimórficos: isto é, o mesmo método pode ser usado em muitas implementações diferentes da interface de coleção apropriada.

Além das coleções, a estrutura define várias interfaces e classes de mapas. Os mapas armazenam pares de chave / valor. Embora os mapas não sejam coleções no uso adequado do termo, eles estão totalmente integrados às coleções.

As interfaces da coleção

A estrutura de coleções define várias interfaces. Esta seção fornece uma visão geral de cada interface -

Sr. Não.	Interface e descrição
1	A interface da coleção Isso permite que você trabalhe com grupos de objetos; está no topo da hierarquia de coleções.
2	A interface da lista Isso estende Collection e uma instância de List armazena uma coleção ordenada de elementos.
3	O conjunto Isso estende a coleção para lidar com conjuntos, que devem conter elementos exclusivos.
4	O SortedSet Isso estende Set para lidar com conjuntos classificados.
5	O mapa Isso mapeia chaves exclusivas para valores.
6	The Map.Entry Isso descreve um elemento (um par chave / valor) em um mapa. Esta é uma classe interna de Map.
7	O SortedMap Isso estende o mapa para que as chaves sejam mantidas em ordem crescente.
8	A Enumeração Esta interface legada define os métodos pelos quais você pode enumerar (obter um por vez) os elementos em uma coleção de objetos. Esta interface legada foi substituída pelo Iterator.

As Classes de Coleção

Java fornece um conjunto de classes de coleção padrão que implementam interfaces de coleção. Algumas das classes fornecem implementações completas que podem ser usadas no estado em que se encontram e outras são classes abstratas, fornecendo implementações esqueléticas que são usadas como pontos de partida para a criação de coleções concretas.

As classes de coleção padrão são resumidas na tabela a seguir -

Sr. Não.	Classe e descrição
1	AbstractCollection Implementa a maior parte da interface de coleção.
2	AbstractList Estende AbstractCollection e implementa a maior parte da interface List.
3	AbstractSequentialList Estende AbstractList para uso por uma coleção que usa acesso sequencial em vez de aleatório de seus elementos.
4	LinkedList Implementa uma lista vinculada estendendo AbstractSequentialList.
5	ArrayList Implementa uma matriz dinâmica estendendo AbstractList.
6	AbstractSet Estende AbstractCollection e implementa a maior parte da interface Set.
7	HashSet Estende AbstractSet para uso com uma tabela hash.
8	LinkedHashSet Estende HashSet para permitir iterações de pedido de inserção.
9	TreeSet Implementa um conjunto armazenado em uma árvore. Estende AbstractSet.
10	AbstractMap Implementa a maior parte da interface do Mapa.
11	HashMap Estende AbstractMap para usar uma tabela de hash.
12	TreeMap Estende AbstractMap para usar uma árvore.
13	WeakHashMap Estende AbstractMap para usar uma tabela de hash com chaves fracas.
14	LinkedHashMap Estende o HashMap para permitir iterações de pedido de inserção.
15	IdentityHashMap Estende AbstractMap e usa igualdade de referência ao comparar documentos.

As classes AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList e AbstractMap fornecem implementações esqueléticas das interfaces de coleção principais, para minimizar o esforço necessário para implementá-las.

As seguintes classes legadas definidas por java.util foram discutidas no capítulo anterior -

Sr. Não.	Classe e descrição
1	Vetor Isso implementa uma matriz dinâmica. É semelhante a ArrayList, mas com algumas diferenças.
2	Pilha Stack é uma subclasse de Vector que implementa uma pilha padrão último a entrar, primeiro a sair.
3	Dicionário Dicionário é uma classe abstrata que representa um repositório de armazenamento de chave / valor e opera de forma semelhante ao Map.
4	Hashtable Hashtable fazia parte do java.util original e é uma implementação concreta de um Dicionário.
5	Propriedades Propriedades é uma subclasse de Hashtable. É usado para manter listas de valores em que a chave é uma String e o valor também é uma String.
6	BitSet Uma classe BitSet cria um tipo especial de matriz que contém valores de bits. Essa matriz pode aumentar de tamanho conforme necessário.

Os Algoritmos de Coleção

A estrutura de coleções define vários algoritmos que podem ser aplicados a coleções e mapas. Esses algoritmos são definidos como métodos estáticos dentro da classe Collections.

Vários dos métodos podem lançar um ClassCastException, que ocorre quando é feita uma tentativa de comparar tipos incompatíveis, ou um UnsupportedOperationException, que ocorre quando é feita uma tentativa de modificar uma coleção não modificável.

As coleções definem três variáveis ​​estáticas: EMPTY_SET, EMPTY_LIST e EMPTY_MAP. Todos são imutáveis.

Sr. Não.	Algoritmo e descrição
1	Os Algoritmos de Coleção Aqui está uma lista de toda a implementação do algoritmo.

Como usar um iterador?

Freqüentemente, você desejará percorrer os elementos de uma coleção. Por exemplo, você pode querer exibir cada elemento.

A maneira mais fácil de fazer isso é empregar um iterador, que é um objeto que implementa a interface Iterator ou ListIterator.

Iterator permite que você percorra uma coleção, obtendo ou removendo elementos. ListIterator estende Iterator para permitir a passagem bidirecional de uma lista e a modificação de elementos.

Sr. Não.	Método e descrição do iterador
1	Usando Java Iterator Aqui está uma lista de todos os métodos com exemplos fornecidos pelas interfaces Iterator e ListIterator.

Como usar um comparador?

Tanto TreeSet quanto TreeMap armazenam elementos em uma ordem de classificação. No entanto, é o comparador que define precisamente o que significa ordem de classificação .

Essa interface nos permite classificar uma determinada coleção de várias maneiras diferentes. Além disso, essa interface pode ser usada para classificar quaisquer instâncias de qualquer classe (mesmo classes que não podemos modificar).

Sr. Não.	Método e descrição do iterador
1	Usando Java Comparator Aqui está uma lista de todos os métodos com exemplos fornecidos pela Interface de comparação.

Resumo

A estrutura de coleções Java dá ao programador acesso a estruturas de dados predefinidas, bem como a algoritmos para manipulá-las.

Uma coleção é um objeto que pode conter referências a outros objetos. As interfaces de coleção declaram as operações que podem ser realizadas em cada tipo de coleção.

As classes e interfaces da estrutura de coleções estão no pacote java.util.

Seria bom se pudéssemos escrever um único método de classificação que pudesse classificar os elementos em um array Integer, um array String ou um array de qualquer tipo que suporte ordenação.

Java Generic métodos e classes genéricas permitem que os programadores especifiquem, com uma única declaração de método, um conjunto de métodos relacionados ou, com uma única declaração de classe, um conjunto de tipos relacionados, respectivamente.

Os genéricos também fornecem segurança de tipo em tempo de compilação que permite aos programadores detectar tipos inválidos em tempo de compilação.

Usando o conceito Java Genérico, podemos escrever um método genérico para classificar uma matriz de objetos e, em seguida, invocar o método genérico com matrizes Integer, matrizes Double, matrizes String e assim por diante, para classificar os elementos da matriz.

Métodos Genéricos

Você pode escrever uma única declaração de método genérico que pode ser chamada com argumentos de diferentes tipos. Com base nos tipos de argumentos passados ​​para o método genérico, o compilador trata cada chamada de método apropriadamente. A seguir estão as regras para definir métodos genéricos -

• Todas as declarações de método genérico têm uma seção de parâmetro de tipo delimitada por colchetes angulares (<e>) que precede o tipo de retorno do método (<E> no próximo exemplo).

• Cada seção de parâmetro de tipo contém um ou mais parâmetros de tipo separados por vírgulas. Um parâmetro de tipo, também conhecido como variável de tipo, é um identificador que especifica um nome de tipo genérico.

• Os parâmetros de tipo podem ser usados ​​para declarar o tipo de retorno e atuar como marcadores para os tipos de argumentos passados ​​para o método genérico, que são conhecidos como argumentos de tipo reais.

• O corpo de um método genérico é declarado como o de qualquer outro método. Observe que os parâmetros de tipo podem representar apenas tipos de referência, não tipos primitivos (como int, double e char).

Exemplo

O exemplo a seguir ilustra como podemos imprimir uma matriz de tipo diferente usando um único método genérico -

public class GenericMethodTest {
   // generic method printArray
   public static < E > void printArray( E[] inputArray ) {
      // Display array elements
      for(E element : inputArray) {
         System.out.printf("%s ", element);
      }
      System.out.println();
   }

   public static void main(String args[]) {
      // Create arrays of Integer, Double and Character
      Integer[] intArray = { 1, 2, 3, 4, 5 };
      Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
      Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

      System.out.println("Array integerArray contains:");
      printArray(intArray);   // pass an Integer array

      System.out.println("\nArray doubleArray contains:");
      printArray(doubleArray);   // pass a Double array

      System.out.println("\nArray characterArray contains:");
      printArray(charArray);   // pass a Character array
   }
}

Isso produzirá o seguinte resultado -

Resultado

Array integerArray contains:
1 2 3 4 5 

Array doubleArray contains:
1.1 2.2 3.3 4.4 

Array characterArray contains:
H E L L O

Parâmetros de tipo limitado

Pode haver momentos em que você queira restringir os tipos de tipos que podem ser passados ​​para um parâmetro de tipo. Por exemplo, um método que opera em números pode aceitar apenas instâncias de Number ou suas subclasses. É para isso que servem os parâmetros de tipo limitado.

Para declarar um parâmetro de tipo limitado, liste o nome do parâmetro de tipo, seguido pela palavra-chave extends, seguida por seu limite superior.

Exemplo

O exemplo a seguir ilustra como extends é usado em um sentido geral para significar "estende" (como nas classes) ou "implementa" (como nas interfaces). Este exemplo é o método genérico para retornar o maior dos três objetos comparáveis ​​-

public class MaximumTest {
   // determines the largest of three Comparable objects
   
   public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
      T max = x;   // assume x is initially the largest
      
      if(y.compareTo(max) > 0) {
         max = y;   // y is the largest so far
      }
      
      if(z.compareTo(max) > 0) {
         max = z;   // z is the largest now                 
      }
      return max;   // returns the largest object   
   }
   
   public static void main(String args[]) {
      System.out.printf("Max of %d, %d and %d is %d\n\n", 
         3, 4, 5, maximum( 3, 4, 5 ));

      System.out.printf("Max of %.1f,%.1f and %.1f is %.1f\n\n",
         6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ));

      System.out.printf("Max of %s, %s and %s is %s\n","pear",
         "apple", "orange", maximum("pear", "apple", "orange"));
   }
}

Isso produzirá o seguinte resultado -

Resultado

Max of 3, 4 and 5 is 5

Max of 6.6,8.8 and 7.7 is 8.8

Max of pear, apple and orange is pear

Classes Genéricas

Uma declaração de classe genérica parece uma declaração de classe não genérica, exceto que o nome da classe é seguido por uma seção de parâmetro de tipo.

Tal como acontece com os métodos genéricos, a seção de parâmetro de tipo de uma classe genérica pode ter um ou mais parâmetros de tipo separados por vírgulas. Essas classes são conhecidas como classes parametrizadas ou tipos parametrizados porque aceitam um ou mais parâmetros.

Exemplo

O exemplo a seguir ilustra como podemos definir uma classe genérica -

public class Box<T> {
   private T t;

   public void add(T t) {
      this.t = t;
   }

   public T get() {
      return t;
   }

   public static void main(String[] args) {
      Box<Integer> integerBox = new Box<Integer>();
      Box<String> stringBox = new Box<String>();
    
      integerBox.add(new Integer(10));
      stringBox.add(new String("Hello World"));

      System.out.printf("Integer Value :%d\n\n", integerBox.get());
      System.out.printf("String Value :%s\n", stringBox.get());
   }
}

Isso produzirá o seguinte resultado -

Resultado

Integer Value :10
String Value :Hello World

Java fornece um mecanismo, chamado serialização de objeto, onde um objeto pode ser representado como uma sequência de bytes que inclui os dados do objeto, bem como informações sobre o tipo do objeto e os tipos de dados armazenados no objeto.

Depois que um objeto serializado é gravado em um arquivo, ele pode ser lido do arquivo e desserializado, ou seja, as informações de tipo e bytes que representam o objeto e seus dados podem ser usados ​​para recriar o objeto na memória.

O mais impressionante é que todo o processo é independente da JVM, o que significa que um objeto pode ser serializado em uma plataforma e desserializado em uma plataforma totalmente diferente.

Aulas ObjectInputStream e ObjectOutputStream são fluxos de alto nível que contêm os métodos para serializar e desserializar um objeto.

A classe ObjectOutputStream contém muitos métodos de gravação para escrever vários tipos de dados, mas um método em particular se destaca -

public final void writeObject(Object x) throws IOException

O método acima serializa um objeto e o envia para o fluxo de saída. Da mesma forma, a classe ObjectInputStream contém o seguinte método para desserializar um objeto -

public final Object readObject() throws IOException, ClassNotFoundException

Este método recupera o próximo Object fora do fluxo e o desserializa. O valor de retorno é Object, portanto, você precisará convertê-lo em seu tipo de dados apropriado.

Para demonstrar como a serialização funciona em Java, vou usar a classe Employee que discutimos no início do livro. Suponha que tenhamos a seguinte classe Employee, que implementa a interface Serializable -

Exemplo

public class Employee implements java.io.Serializable {
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   
   public void mailCheck() {
      System.out.println("Mailing a check to " + name + " " + address);
   }
}

Observe que para uma classe ser serializada com sucesso, duas condições devem ser atendidas -

• A classe deve implementar a interface java.io.Serializable.

• Todos os campos da classe devem ser serializáveis. Se um campo não for serializável, ele deve ser marcadotransient.

Se você está curioso para saber se uma classe padrão Java é serializável ou não, verifique a documentação da classe. O teste é simples: se a classe implementa java.io.Serializable, ela é serializável; caso contrário, não é.

Serializando um objeto

A classe ObjectOutputStream é usada para serializar um Object. O programa SerializeDemo a seguir instancia um objeto Employee e o serializa em um arquivo.

Quando a execução do programa termina, um arquivo chamado employee.ser é criado. O programa não gera nenhuma saída, mas estuda o código e tenta determinar o que o programa está fazendo.

Note - Ao serializar um objeto para um arquivo, a convenção padrão em Java é dar ao arquivo um .ser extensão.

Exemplo

import java.io.*;
public class SerializeDemo {

   public static void main(String [] args) {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      
      try {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      } catch (IOException i) {
         i.printStackTrace();
      }
   }
}

Desserializando um objeto

O programa DeserializeDemo a seguir desserializa o objeto Employee criado no programa SerializeDemo. Estude o programa e tente determinar seu resultado -

Exemplo

import java.io.*;
public class DeserializeDemo {

   public static void main(String [] args) {
      Employee e = null;
      try {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      } catch (IOException i) {
         i.printStackTrace();
         return;
      } catch (ClassNotFoundException c) {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
   }
}

Isso produzirá o seguinte resultado -

Resultado

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

Aqui estão os seguintes pontos importantes a serem observados -

• O bloco try / catch tenta capturar uma ClassNotFoundException, que é declarada pelo método readObject (). Para que uma JVM seja capaz de desserializar um objeto, ela deve ser capaz de encontrar o bytecode para a classe. Se a JVM não puder encontrar uma classe durante a desserialização de um objeto, ela lançará uma ClassNotFoundException.

• Observe que o valor de retorno de readObject () é convertido em uma referência Employee.

• O valor do campo SSN era 11122333 quando o objeto foi serializado, mas como o campo é temporário, esse valor não foi enviado para o fluxo de saída. O campo SSN do objeto Employee desserializado é 0.

O termo programação de rede refere-se a programas de escrita que são executados em vários dispositivos (computadores), nos quais os dispositivos estão todos conectados entre si por meio de uma rede.

O pacote java.net das APIs J2SE contém uma coleção de classes e interfaces que fornecem os detalhes de comunicação de baixo nível, permitindo que você escreva programas que se concentram em resolver o problema em questão.

O pacote java.net fornece suporte para os dois protocolos de rede comuns -

• TCP- TCP significa Transmission Control Protocol, que permite a comunicação confiável entre dois aplicativos. O TCP é normalmente usado no protocolo da Internet, conhecido como TCP / IP.

• UDP - UDP significa User Datagram Protocol, um protocolo sem conexão que permite que pacotes de dados sejam transmitidos entre aplicativos.

Este capítulo oferece um bom entendimento sobre os dois assuntos a seguir -

• Socket Programming - Este é o conceito mais amplamente utilizado em Redes e foi explicado em detalhes.

• URL Processing- Isso seria coberto separadamente. Clique aqui para aprender sobre Processamento de URL na linguagem Java.

Programação de soquete

Os soquetes fornecem o mecanismo de comunicação entre dois computadores usando TCP. Um programa cliente cria um soquete em sua extremidade da comunicação e tenta conectar esse soquete a um servidor.

Quando a conexão é feita, o servidor cria um objeto de soquete em sua extremidade da comunicação. O cliente e o servidor agora podem se comunicar gravando e lendo no soquete.

A classe java.net.Socket representa um soquete e a classe java.net.ServerSocket fornece um mecanismo para o programa do servidor escutar os clientes e estabelecer conexões com eles.

As etapas a seguir ocorrem ao estabelecer uma conexão TCP entre dois computadores usando soquetes -

• O servidor instancia um objeto ServerSocket, indicando em qual número de porta a comunicação deve ocorrer.

• O servidor invoca o método accept () da classe ServerSocket. Este método espera até que um cliente se conecte ao servidor na porta fornecida.

• Depois que o servidor está esperando, um cliente instancia um objeto Socket, especificando o nome do servidor e o número da porta à qual se conectar.

• O construtor da classe Socket tenta conectar o cliente ao servidor especificado e ao número da porta. Se a comunicação for estabelecida, o cliente agora tem um objeto Socket capaz de se comunicar com o servidor.

• No lado do servidor, o método accept () retorna uma referência a um novo soquete no servidor que está conectado ao soquete do cliente.

Depois que as conexões são estabelecidas, a comunicação pode ocorrer usando fluxos de E / S. Cada soquete tem um OutputStream e um InputStream. O OutputStream do cliente está conectado ao InputStream do servidor e o InputStream do cliente está conectado ao OutputStream do servidor.

O TCP é um protocolo de comunicação bidirecional, portanto, os dados podem ser enviados pelos dois fluxos ao mesmo tempo. A seguir estão as classes úteis que fornecem um conjunto completo de métodos para implementar sockets.

Métodos de classe ServerSocket

o java.net.ServerSocket classe é usada por aplicativos de servidor para obter uma porta e ouvir os pedidos do cliente.

A classe ServerSocket tem quatro construtores -

Sr. Não.	Método e Descrição
1	public ServerSocket(int port) throws IOException Tenta criar um soquete de servidor vinculado à porta especificada. Uma exceção ocorre se a porta já estiver vinculada por outro aplicativo.
2	public ServerSocket(int port, int backlog) throws IOException Semelhante ao construtor anterior, o parâmetro backlog especifica quantos clientes de entrada armazenar em uma fila de espera.
3	public ServerSocket(int port, int backlog, InetAddress address) throws IOException Semelhante ao construtor anterior, o parâmetro InetAddress especifica o endereço IP local a ser vinculado. O InetAddress é usado para servidores que podem ter vários endereços IP, permitindo ao servidor especificar em qual de seus endereços IP aceitará as solicitações do cliente.
4	public ServerSocket() throws IOException Cria um soquete de servidor não acoplado. Ao usar esse construtor, use o método bind () quando estiver pronto para vincular o soquete do servidor.

Se o construtor ServerSocket não lançar uma exceção, significa que seu aplicativo foi vinculado com êxito à porta especificada e está pronto para as solicitações do cliente.

A seguir estão alguns dos métodos comuns da classe ServerSocket -

Sr. Não.	Método e Descrição
1	public int getLocalPort() Retorna a porta em que o soquete do servidor está escutando. Este método é útil se você passou 0 como o número da porta em um construtor e deixou o servidor encontrar uma porta para você.
2	public Socket accept() throws IOException Espera por um cliente de entrada. Este método bloqueia até que um cliente se conecte ao servidor na porta especificada ou o soquete expire, assumindo que o valor de tempo limite foi definido usando o método setSoTimeout (). Caso contrário, este método bloqueia indefinidamente.
3	public void setSoTimeout(int timeout) Define o valor de tempo limite para quanto tempo o soquete do servidor espera por um cliente durante o accept ().
4	public void bind(SocketAddress host, int backlog) Vincula o soquete ao servidor e porta especificados no objeto SocketAddress. Use este método se você tiver instanciado o ServerSocket usando o construtor sem argumento.

Quando o ServerSocket invoca accept (), o método não retorna até que um cliente se conecte. Depois que um cliente se conecta, o ServerSocket cria um novo Socket em uma porta não especificada e retorna uma referência a esse novo Socket. Agora existe uma conexão TCP entre o cliente e o servidor e a comunicação pode começar.

Métodos de classe de soquete

o java.net.Socketclasse representa o soquete que o cliente e o servidor usam para se comunicarem. O cliente obtém um objeto Socket instanciando um, enquanto o servidor obtém um objeto Socket do valor de retorno do método accept ().

A classe Socket tem cinco construtores que um cliente usa para se conectar a um servidor -

Sr. Não.	Método e Descrição
1	public Socket(String host, int port) throws UnknownHostException, IOException. Este método tenta se conectar ao servidor especificado na porta especificada. Se esse construtor não lançar uma exceção, a conexão será bem-sucedida e o cliente será conectado ao servidor.
2	public Socket(InetAddress host, int port) throws IOException Este método é idêntico ao construtor anterior, exceto que o host é denotado por um objeto InetAddress.
3	public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException. Conecta-se ao host e porta especificados, criando um soquete no host local no endereço e porta especificados.
4	public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException. Este método é idêntico ao construtor anterior, exceto que o host é denotado por um objeto InetAddress em vez de um String.
5	public Socket() Cria um soquete não conectado. Use o método connect () para conectar este socket a um servidor.

Quando o construtor Socket retorna, ele não apenas instancia um objeto Socket, mas na verdade tenta se conectar ao servidor e à porta especificados.

Alguns métodos de interesse na classe Socket estão listados aqui. Observe que o cliente e o servidor têm um objeto Socket, portanto, esses métodos podem ser chamados tanto pelo cliente quanto pelo servidor.

Sr. Não.	Método e Descrição
1	public void connect(SocketAddress host, int timeout) throws IOException Este método conecta o soquete ao host especificado. Este método é necessário apenas quando você instancia o Socket usando o construtor sem argumento.
2	public InetAddress getInetAddress() Este método retorna o endereço do outro computador ao qual este soquete está conectado.
3	public int getPort() Retorna a porta à qual o soquete está vinculado na máquina remota.
4	public int getLocalPort() Retorna a porta à qual o soquete está vinculado na máquina local.
5	public SocketAddress getRemoteSocketAddress() Retorna o endereço do soquete remoto.
6	public InputStream getInputStream() throws IOException Retorna o fluxo de entrada do soquete. O fluxo de entrada é conectado ao fluxo de saída do soquete remoto.
7	public OutputStream getOutputStream() throws IOException Retorna o fluxo de saída do soquete. O fluxo de saída é conectado ao fluxo de entrada do soquete remoto.
8	public void close() throws IOException Fecha o soquete, o que faz com que este objeto Socket não seja mais capaz de se conectar novamente a qualquer servidor.

Métodos de classe InetAddress

Esta classe representa um endereço de protocolo da Internet (IP). Aqui estão os seguintes métodos úteis que você precisa ao fazer a programação de socket -

Sr. Não.	Método e Descrição
1	static InetAddress getByAddress(byte[] addr) Retorna um objeto InetAddress dado o endereço IP bruto.
2	static InetAddress getByAddress(String host, byte[] addr) Cria um InetAddress com base no nome do host e endereço IP fornecidos.
3	static InetAddress getByName(String host) Determina o endereço IP de um host, dado o nome do host.
4	String getHostAddress() Retorna a string do endereço IP na apresentação textual.
5	String getHostName() Obtém o nome do host para este endereço IP.
6	static InetAddress InetAddress getLocalHost() Retorna o host local.
7	String toString() Converte este endereço IP em uma String.

Exemplo de cliente de soquete

O seguinte GreetingClient é um programa cliente que se conecta a um servidor usando um soquete e envia uma saudação e, em seguida, aguarda uma resposta.

Exemplo

// File Name GreetingClient.java
import java.net.*;
import java.io.*;

public class GreetingClient {

   public static void main(String [] args) {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try {
         System.out.println("Connecting to " + serverName + " on port " + port);
         Socket client = new Socket(serverName, port);
         
         System.out.println("Just connected to " + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);
         
         out.writeUTF("Hello from " + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);
         
         System.out.println("Server says " + in.readUTF());
         client.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Exemplo de servidor de soquete

O programa GreetingServer a seguir é um exemplo de um aplicativo de servidor que usa a classe Socket para ouvir clientes em um número de porta especificado por um argumento de linha de comando -

Exemplo

// File Name GreetingServer.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread {
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }

   public void run() {
      while(true) {
         try {
            System.out.println("Waiting for client on port " + 
               serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            
            System.out.println("Just connected to " + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress()
               + "\nGoodbye!");
            server.close();
            
         } catch (SocketTimeoutException s) {
            System.out.println("Socket timed out!");
            break;
         } catch (IOException e) {
            e.printStackTrace();
            break;
         }
      }
   }
   
   public static void main(String [] args) {
      int port = Integer.parseInt(args[0]);
      try {
         Thread t = new GreetingServer(port);
         t.start();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Compile o cliente e o servidor e inicie o servidor da seguinte forma -

$ java GreetingServer 6066
Waiting for client on port 6066...

Verifique o programa cliente da seguinte forma -

Resultado

$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!

Para enviar um e-mail usando seu aplicativo Java é simples o suficiente, mas para começar você deve ter JavaMail API e Java Activation Framework (JAF) instalado em sua máquina.

• Você pode baixar a versão mais recente do JavaMail (versão 1.2) do site padrão do Java.

• Você pode baixar a versão mais recente do JAF (Versão 1.1.1) do site padrão do Java.

Baixe e descompacte esses arquivos. Nos diretórios de nível superior recém-criados, você encontrará vários arquivos jar para ambos os aplicativos. Você precisa adicionarmail.jar e activation.jar arquivos em seu CLASSPATH.

Envie um e-mail simples

Aqui está um exemplo para enviar um e-mail simples de sua máquina. Presume-se que seulocalhost está conectado à Internet e é capaz de enviar um e-mail.

Exemplo

// File Name SendEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendEmail {

   public static void main(String [] args) {    
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Now set the actual message
         message.setText("This is actual message");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Compile e execute este programa para enviar um simples e-mail -

Resultado

$ java SendEmail
Sent message successfully....

Se você deseja enviar um e-mail para vários destinatários, os seguintes métodos seriam usados ​​para especificar vários IDs de e-mail -

void addRecipients(Message.RecipientType type, Address[] addresses)
   throws MessagingException

Aqui está a descrição dos parâmetros -

• type- Isso seria definido como TO, CC ou BCC. Aqui, CC representa Carbon Copy e BCC representa Black Carbon Copy. Exemplo: Message.RecipientType.TO

• addresses- Esta é uma matriz de ID de e-mail. Você precisaria usar o método InternetAddress () ao especificar os IDs de email.

Envie um e-mail HTML

Aqui está um exemplo para enviar um e-mail em HTML de sua máquina. Aqui, presume-se que seulocalhost está conectado à Internet e é capaz de enviar um e-mail.

Este exemplo é muito semelhante ao anterior, exceto que aqui estamos usando o método setContent () para definir o conteúdo cujo segundo argumento é "text / html" para especificar que o conteúdo HTML está incluído na mensagem.

Usando este exemplo, você pode enviar o conteúdo HTML que desejar.

Exemplo

// File Name SendHTMLEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendHTMLEmail {

   public static void main(String [] args) {
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Send the actual HTML message, as big as you like
         message.setContent("<h1>This is actual message</h1>", "text/html");

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Compile e execute este programa para enviar um e-mail em HTML -

Resultado

$ java SendHTMLEmail
Sent message successfully....

Enviar anexo por e-mail

Aqui está um exemplo para enviar um e-mail com anexo de sua máquina. Aqui, presume-se que seulocalhost está conectado à internet e é capaz de enviar um e-mail.

Exemplo

// File Name SendFileEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendFileEmail {

   public static void main(String [] args) {     
      // Recipient's email ID needs to be mentioned.
      String to = "[email protected]";

      // Sender's email ID needs to be mentioned
      String from = "[email protected]";

      // Assuming you are sending email from localhost
      String host = "localhost";

      // Get system properties
      Properties properties = System.getProperties();

      // Setup mail server
      properties.setProperty("mail.smtp.host", host);

      // Get the default Session object.
      Session session = Session.getDefaultInstance(properties);

      try {
         // Create a default MimeMessage object.
         MimeMessage message = new MimeMessage(session);

         // Set From: header field of the header.
         message.setFrom(new InternetAddress(from));

         // Set To: header field of the header.
         message.addRecipient(Message.RecipientType.TO,new InternetAddress(to));

         // Set Subject: header field
         message.setSubject("This is the Subject Line!");

         // Create the message part 
         BodyPart messageBodyPart = new MimeBodyPart();

         // Fill the message
         messageBodyPart.setText("This is message body");
         
         // Create a multipar message
         Multipart multipart = new MimeMultipart();

         // Set text message part
         multipart.addBodyPart(messageBodyPart);

         // Part two is attachment
         messageBodyPart = new MimeBodyPart();
         String filename = "file.txt";
         DataSource source = new FileDataSource(filename);
         messageBodyPart.setDataHandler(new DataHandler(source));
         messageBodyPart.setFileName(filename);
         multipart.addBodyPart(messageBodyPart);

         // Send the complete message parts
         message.setContent(multipart );

         // Send message
         Transport.send(message);
         System.out.println("Sent message successfully....");
      } catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

Compile e execute este programa para enviar um e-mail em HTML -

Resultado

$ java SendFileEmail
Sent message successfully....

Parte de autenticação do usuário

Se for necessário fornecer ID de usuário e senha ao servidor de e-mail para fins de autenticação, você pode definir essas propriedades da seguinte forma -

props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");

O resto do mecanismo de envio de e-mail permaneceria conforme explicado acima.

Java é uma linguagem de programação multithread, o que significa que podemos desenvolver programas multithread usando Java. Um programa multi-threaded contém duas ou mais partes que podem ser executadas simultaneamente e cada parte pode lidar com uma tarefa diferente ao mesmo tempo, fazendo uso otimizado dos recursos disponíveis, especialmente quando seu computador tem várias CPUs.

Por definição, multitarefa é quando vários processos compartilham recursos de processamento comuns, como uma CPU. O multi-threading estende a ideia de multitarefa em aplicativos onde você pode subdividir operações específicas em um único aplicativo em threads individuais. Cada um dos threads pode ser executado em paralelo. O sistema operacional divide o tempo de processamento não apenas entre os diferentes aplicativos, mas também entre cada thread de um aplicativo.

Multi-threading permite que você escreva de uma maneira em que várias atividades possam prosseguir simultaneamente no mesmo programa.

Ciclo de vida de um fio

Um segmento passa por vários estágios de seu ciclo de vida. Por exemplo, um encadeamento nasce, é iniciado, é executado e depois morre. O diagrama a seguir mostra o ciclo de vida completo de um encadeamento.

A seguir estão os estágios do ciclo de vida -

• New- Um novo encadeamento inicia seu ciclo de vida no novo estado. Ele permanece neste estado até que o programa inicie o thread. Também é conhecido comoborn thread.

• Runnable- Depois que um encadeamento recém-nascido é iniciado, o encadeamento se torna executável. Um thread neste estado é considerado como executando sua tarefa.

• Waiting- Às vezes, um thread faz a transição para o estado de espera enquanto espera por outro thread para realizar uma tarefa. Um thread faz a transição de volta ao estado executável apenas quando outro thread sinaliza ao thread em espera para continuar em execução.

• Timed Waiting- Um thread executável pode entrar no estado de espera cronometrado por um intervalo de tempo especificado. Um encadeamento neste estado faz a transição de volta ao estado executável quando esse intervalo de tempo expira ou quando ocorre o evento pelo qual está esperando.

• Terminated (Dead) - Um thread executável entra no estado finalizado quando completa sua tarefa ou então termina.

Prioridades de discussão

Cada encadeamento Java tem uma prioridade que ajuda o sistema operacional a determinar a ordem em que os encadeamentos são planejados.

As prioridades do encadeamento Java estão no intervalo entre MIN_PRIORITY (uma constante de 1) e MAX_PRIORITY (uma constante de 10). Por padrão, cada thread tem prioridade NORM_PRIORITY (uma constante de 5).

Threads com prioridade mais alta são mais importantes para um programa e devem ter tempo de processador alocado antes de threads de prioridade mais baixa. No entanto, as prioridades de thread não podem garantir a ordem em que os threads são executados e são muito dependentes da plataforma.

Crie um thread implementando uma interface executável

Se sua classe se destina a ser executada como um segmento, você pode conseguir isso implementando um Runnableinterface. Você precisará seguir três etapas básicas -

Passo 1

Como primeira etapa, você precisa implementar um método run () fornecido por um Runnableinterface. Este método fornece um ponto de entrada para o encadeamento e você colocará sua lógica de negócios completa dentro desse método. A seguir está uma sintaxe simples do método run () -

public void run( )

Passo 2

Como uma segunda etapa, você instanciará um Thread objeto usando o seguinte construtor -

Thread(Runnable threadObj, String threadName);

Onde, threadObj é uma instância de uma classe que implementa oRunnable interface e threadName é o nome dado ao novo tópico.

etapa 3

Depois que um objeto Thread é criado, você pode iniciá-lo chamando start(), que executa uma chamada ao método run (). A seguir está uma sintaxe simples do método start () -

void start();

Exemplo

Aqui está um exemplo que cria um novo thread e começa a executá-lo -

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

Isso produzirá o seguinte resultado -

Resultado

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Criar um thread estendendo uma classe de thread

A segunda maneira de criar um thread é criar uma nova classe que estende Threadclasse usando as duas etapas simples a seguir. Esta abordagem fornece mais flexibilidade no tratamento de vários threads criados usando os métodos disponíveis na classe Thread.

Passo 1

Você precisará substituir run( )método disponível na classe Thread. Este método fornece um ponto de entrada para o encadeamento e você colocará sua lógica de negócios completa dentro desse método. A seguir está uma sintaxe simples do método run () -

public void run( )

Passo 2

Uma vez que o objeto Thread é criado, você pode iniciá-lo chamando start(), que executa uma chamada ao método run (). A seguir está uma sintaxe simples do método start () -

void start( );

Exemplo

Aqui está o programa anterior reescrito para estender o Thread -

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

Isso produzirá o seguinte resultado -

Resultado

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Métodos de linha

A seguir está a lista de métodos importantes disponíveis na classe Thread.

Sr. Não.	Método e Descrição
1	public void start() Inicia o thread em um caminho de execução separado e, a seguir, invoca o método run () neste objeto Thread.
2	public void run() Se este objeto Thread foi instanciado usando um destino Runnable separado, o método run () é invocado nesse objeto Runnable.
3	public final void setName(String name) Altera o nome do objeto Thread. Também existe um método getName () para recuperar o nome.
4	public final void setPriority(int priority) Define a prioridade deste objeto Thread. Os valores possíveis estão entre 1 e 10.
5	public final void setDaemon(boolean on) Um parâmetro true denota este Thread como um thread daemon.
6	public final void join(long millisec) O thread atual invoca este método em um segundo thread, fazendo com que o thread atual seja bloqueado até que o segundo thread termine ou o número especificado de milissegundos passe.
7	public void interrupt() Interrompe este thread, fazendo com que continue a execução se ele foi bloqueado por qualquer motivo.
8	public final boolean isAlive() Retorna verdadeiro se o encadeamento está ativo, ou seja, a qualquer momento após o encadeamento ter sido iniciado, mas antes de sua execução até a conclusão.

Os métodos anteriores são invocados em um objeto Thread específico. Os métodos a seguir na classe Thread são estáticos. Invocar um dos métodos estáticos executa a operação no thread em execução no momento.

Sr. Não.	Método e Descrição
1	public static void yield() Faz com que o encadeamento atualmente em execução ceda a qualquer outro encadeamento com a mesma prioridade que esteja aguardando para ser agendado.
2	public static void sleep(long millisec) Faz com que o thread em execução no momento seja bloqueado por pelo menos o número especificado de milissegundos.
3	public static boolean holdsLock(Object x) Retorna verdadeiro se o segmento atual mantém o bloqueio no objeto fornecido.
4	public static Thread currentThread() Retorna uma referência ao encadeamento atualmente em execução, que é o encadeamento que invoca este método.
5	public static void dumpStack() Imprime o rastreamento de pilha para o encadeamento atualmente em execução, o que é útil ao depurar um aplicativo multithread.

Exemplo

O programa ThreadClassDemo a seguir demonstra alguns desses métodos da classe Thread. Considere uma aulaDisplayMessage que implementa Runnable -

// File Name : DisplayMessage.java
// Create a thread to implement Runnable

public class DisplayMessage implements Runnable {
   private String message;
   
   public DisplayMessage(String message) {
      this.message = message;
   }
   
   public void run() {
      while(true) {
         System.out.println(message);
      }
   }
}

A seguir está outra classe que estende a classe Thread -

// File Name : GuessANumber.java
// Create a thread to extentd Thread

public class GuessANumber extends Thread {
   private int number;
   public GuessANumber(int number) {
      this.number = number;
   }
   
   public void run() {
      int counter = 0;
      int guess = 0;
      do {
         guess = (int) (Math.random() * 100 + 1);
         System.out.println(this.getName() + " guesses " + guess);
         counter++;
      } while(guess != number);
      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
   }
}

A seguir está o programa principal, que faz uso das classes definidas acima -

// File Name : ThreadClassDemo.java
public class ThreadClassDemo {

   public static void main(String [] args) {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
      
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();

      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try {
         thread3.join();
      } catch (InterruptedException e) {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
      
      thread4.start();
      System.out.println("main() is ending...");
   }
}

Isso produzirá o seguinte resultado. Você pode tentar este exemplo repetidamente e obterá um resultado diferente a cada vez.

Resultado

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

Principais conceitos de multithreading Java

Ao fazer programação multithreading em Java, você precisa ter os seguintes conceitos muito úteis -

• O que é sincronização de thread?

• Lidando com a comunicação entre threads

• Lidando com impasse de thread

• Operações principais de thread

A appleté um programa Java executado em um navegador da web. Um miniaplicativo pode ser um aplicativo Java totalmente funcional, pois possui toda a API Java à sua disposição.

Existem algumas diferenças importantes entre um miniaplicativo e um aplicativo Java autônomo, incluindo o seguinte -

• Um applet é uma classe Java que estende a classe java.applet.Applet.

• Um método main () não é chamado em um miniaplicativo e uma classe de miniaplicativo não definirá main ().

• Os miniaplicativos são projetados para serem incorporados a uma página HTML.

• Quando um usuário visualiza uma página HTML que contém um miniaplicativo, o código do miniaplicativo é baixado para a máquina do usuário.

• É necessário um JVM para visualizar um miniaplicativo. A JVM pode ser um plug-in do navegador da Web ou um ambiente de tempo de execução separado.

• A JVM na máquina do usuário cria uma instância da classe do miniaplicativo e chama vários métodos durante a vida útil do miniaplicativo.

• Os miniaplicativos têm regras de segurança rígidas que são aplicadas pelo navegador da web. A segurança de um miniaplicativo é freqüentemente referida como segurança de sandbox, comparando o miniaplicativo a uma criança brincando em uma sandbox com várias regras que devem ser seguidas.

• Outras classes de que o miniaplicativo precisa podem ser baixadas em um único arquivo Java Archive (JAR).

Ciclo de Vida de um Applet

Quatro métodos na classe Applet fornecem a estrutura na qual você constrói qualquer miniaplicativo sério -

• init- Este método se destina a qualquer inicialização necessária para o seu miniaplicativo. Ele é chamado depois que as tags param dentro da tag do miniaplicativo foram processadas.

• start- Este método é chamado automaticamente depois que o navegador chama o método init. Também é chamado sempre que o usuário retorna à página que contém o miniaplicativo após ter ido para outras páginas.

• stop- Este método é chamado automaticamente quando o usuário sai da página em que o miniaplicativo está. Ele pode, portanto, ser chamado repetidamente no mesmo miniaplicativo.

• destroy- Este método só é chamado quando o navegador é encerrado normalmente. Como os miniaplicativos devem residir em uma página HTML, normalmente você não deve deixar recursos para trás depois que um usuário deixa a página que contém o miniaplicativo.

• paint- Chamado imediatamente após o método start (), e também sempre que o miniaplicativo precisar se redesenhar no navegador. O método paint () é, na verdade, herdado de java.awt.

Um miniaplicativo "Hello, World"

A seguir está um miniaplicativo simples chamado HelloWorldApplet.java -

import java.applet.*;
import java.awt.*;

public class HelloWorldApplet extends Applet {
   public void paint (Graphics g) {
      g.drawString ("Hello World", 25, 50);
   }
}

Essas instruções de importação trazem as classes para o escopo de nossa classe de applet -

• java.applet.Applet
• java.awt.Graphics

Sem essas instruções de importação, o compilador Java não reconheceria as classes Applet e Graphics, às quais a classe do applet se refere.

A classe Applet

Cada applet é uma extensão da classe java.applet.Applet . A classe Applet base fornece métodos que uma classe Applet derivada pode chamar para obter informações e serviços do contexto do navegador.

Isso inclui métodos que fazem o seguinte -

• Obter parâmetros de miniaplicativo
• Obtenha a localização de rede do arquivo HTML que contém o miniaplicativo
• Obtenha a localização de rede do diretório de classe do miniaplicativo
• Imprima uma mensagem de status no navegador
• Busque uma imagem
• Buscar um clipe de áudio
• Tocar um clipe de áudio
• Redimensione o miniaplicativo

Além disso, a classe Applet fornece uma interface pela qual o visualizador ou navegador obtém informações sobre o miniaplicativo e controla sua execução. O visualizador pode -

• Solicite informações sobre o autor, versão e direitos autorais do miniaplicativo
• Solicite uma descrição dos parâmetros que o miniaplicativo reconhece
• Inicialize o miniaplicativo
• Destrua o miniaplicativo
• Inicie a execução do applet
• Pare a execução do miniaplicativo

A classe Applet fornece implementações padrão de cada um desses métodos. Essas implementações podem ser substituídas conforme necessário.

O miniaplicativo "Hello, World" está completo como está. O único método substituído é o método de pintura.

Invocando um miniaplicativo

Um miniaplicativo pode ser chamado incorporando diretivas em um arquivo HTML e exibindo o arquivo por meio de um visualizador de miniaplicativo ou navegador habilitado para Java.

A tag <applet> é a base para embutir um miniaplicativo em um arquivo HTML. A seguir está um exemplo que invoca o miniaplicativo "Hello, World" -

<html>
   <title>The Hello, World Applet</title>
   <hr>
   <applet code = "HelloWorldApplet.class" width = "320" height = "120">
      If your browser was Java-enabled, a "Hello, World"
      message would appear here.
   </applet>
   <hr>
</html>

Note- Você pode consultar Tag do miniaplicativo HTML para entender mais sobre como chamar miniaplicativos a partir de HTML.

O atributo code da tag <applet> é obrigatório. Ele especifica a classe Applet a ser executada. A largura e a altura também são necessárias para especificar o tamanho inicial do painel no qual um miniaplicativo é executado. A diretiva do applet deve ser fechada com uma tag </applet>.

Se um miniaplicativo aceita parâmetros, os valores podem ser passados ​​para os parâmetros adicionando tags <param> entre <applet> e </applet>. O navegador ignora o texto e outras marcas entre as marcas do miniaplicativo.

Navegadores não habilitados para Java não processam <applet> e </applet>. Portanto, qualquer coisa que apareça entre as tags, não relacionada ao miniaplicativo, é visível em navegadores não habilitados para Java.

O visualizador ou navegador procura o código Java compilado no local do documento. Para especificar o contrário, use o atributo codebase da tag <applet> como mostrado -

<applet codebase = "https://amrood.com/applets" code = "HelloWorldApplet.class"
   width = "320" height = "120">

Se um miniaplicativo residir em um pacote diferente do padrão, o pacote de retenção deve ser especificado no atributo code usando o caractere ponto (.) Para separar os componentes do pacote / classe. Por exemplo -

<applet  = "mypackage.subpackage.TestApplet.class" 
   width = "320" height = "120">

Obtendo os Parâmetros do Applet

O exemplo a seguir demonstra como fazer um miniaplicativo responder aos parâmetros de configuração especificados no documento. Este miniaplicativo exibe um padrão quadriculado de preto e uma segunda cor.

A segunda cor e o tamanho de cada quadrado podem ser especificados como parâmetros para o miniaplicativo dentro do documento.

CheckerApplet obtém seus parâmetros no método init (). Ele também pode obter seus parâmetros no método paint (). No entanto, obter os valores e salvar as configurações uma vez no início do miniaplicativo, em vez de a cada atualização, é conveniente e eficiente.

O visualizador ou navegador do miniaplicativo chama o método init () de cada miniaplicativo que executa. O visualizador chama init () uma vez, imediatamente após carregar o miniaplicativo. (Applet.init () é implementado para não fazer nada.) Substitua a implementação padrão para inserir o código de inicialização personalizado.

O método Applet.getParameter () busca um parâmetro dado o nome do parâmetro (o valor de um parâmetro é sempre uma string). Se o valor for numérico ou outro dado sem caractere, a string deve ser analisada.

O seguinte é um esqueleto de CheckerApplet.java -

import java.applet.*;
import java.awt.*;

public class CheckerApplet extends Applet {
   int squareSize = 50;   // initialized to default size
   public void init() {}
   private void parseSquareSize (String param) {}
   private Color parseColor (String param) {}
   public void paint (Graphics g) {}
}

Aqui estão os métodos init () e private parseSquareSize () de CheckerApplet -

public void init () {
   String squareSizeParam = getParameter ("squareSize");
   parseSquareSize (squareSizeParam);
   
   String colorParam = getParameter ("color");
   Color fg = parseColor (colorParam);
   
   setBackground (Color.black);
   setForeground (fg);
}

private void parseSquareSize (String param) {
   if (param == null) return;
   try {
      squareSize = Integer.parseInt (param);
   } catch (Exception e) {
      // Let default value remain
   }
}

O miniaplicativo chama parseSquareSize () para analisar o parâmetro squareSize. parseSquareSize () chama o método de biblioteca Integer.parseInt (), que analisa uma string e retorna um inteiro. Integer.parseInt () lança uma exceção sempre que seu argumento é inválido.

Portanto, parseSquareSize () captura exceções, em vez de permitir que o miniaplicativo falhe em uma entrada incorreta.

O miniaplicativo chama parseColor () para analisar o parâmetro de cor em um valor de cor. parseColor () faz uma série de comparações de strings para combinar o valor do parâmetro com o nome de uma cor predefinida. Você precisa implementar esses métodos para fazer este miniaplicativo funcionar.

Especificando Parâmetros de Applet

A seguir está um exemplo de um arquivo HTML com um CheckerApplet incorporado nele. O arquivo HTML especifica ambos os parâmetros para o miniaplicativo por meio da tag <param>.

<html>
   <title>Checkerboard Applet</title>
   <hr>
   <applet code = "CheckerApplet.class" width = "480" height = "320">
      <param name = "color" value = "blue">
      <param name = "squaresize" value = "30">
   </applet>
   <hr>
</html>

Note - Os nomes dos parâmetros não diferenciam maiúsculas de minúsculas.

Conversão de aplicativo para miniaplicativos

É fácil converter um aplicativo Java gráfico (ou seja, um aplicativo que usa o AWT e que você pode iniciar com o iniciador do programa Java) em um miniaplicativo que pode ser incorporado a uma página da web.

A seguir estão as etapas específicas para converter um aplicativo em um miniaplicativo.

• Faça uma página HTML com a tag apropriada para carregar o código do miniaplicativo.

• Forneça uma subclasse da classe JApplet. Torne esta aula pública. Caso contrário, o miniaplicativo não pode ser carregado.

• Elimine o método principal do aplicativo. Não construa uma janela de quadro para o aplicativo. Seu aplicativo será exibido dentro do navegador.

• Mova qualquer código de inicialização do construtor da janela do quadro para o método init do miniaplicativo. Você não precisa construir explicitamente o objeto do miniaplicativo. O navegador cria uma instância para você e chama o método init.

• Remova a chamada para setSize; para miniaplicativos, o dimensionamento é feito com os parâmetros de largura e altura no arquivo HTML.

• Remova a chamada para setDefaultCloseOperation. Um miniaplicativo não pode ser fechado; ele termina quando o navegador é encerrado.

• Se o aplicativo chamar setTitle, elimine a chamada para o método. Os miniaplicativos não podem ter barras de título. (Você pode, é claro, dar um título à própria página da web, usando a tag de título HTML.)

• Não chame setVisible (true). O miniaplicativo é exibido automaticamente.

Manipulação de eventos

Os miniaplicativos herdam um grupo de métodos de tratamento de eventos da classe Container. A classe Container define vários métodos, como processKeyEvent e processMouseEvent, para lidar com tipos específicos de eventos e, em seguida, um método pega-tudo chamado processEvent.

Para reagir a um evento, um miniaplicativo deve substituir o método específico do evento apropriado.

import java.awt.event.MouseListener;
import java.awt.event.MouseEvent;
import java.applet.Applet;
import java.awt.Graphics;

public class ExampleEventHandling extends Applet implements MouseListener {
   StringBuffer strBuffer;

   public void init() {
      addMouseListener(this);
      strBuffer = new StringBuffer();
      addItem("initializing the apple ");
   }

   public void start() {
      addItem("starting the applet ");
   }

   public void stop() {
      addItem("stopping the applet ");
   }

   public void destroy() {
      addItem("unloading the applet");
   }

   void addItem(String word) {
      System.out.println(word);
      strBuffer.append(word);
      repaint();
   }

   public void paint(Graphics g) {
      // Draw a Rectangle around the applet's display area.
      g.drawRect(0, 0, 
      getWidth() - 1,
      getHeight() - 1);

      // display the string inside the rectangle.
      g.drawString(strBuffer.toString(), 10, 20);
   }

   
   public void mouseEntered(MouseEvent event) {
   }
   public void mouseExited(MouseEvent event) {
   }
   public void mousePressed(MouseEvent event) {
   }
   public void mouseReleased(MouseEvent event) {
   }
   public void mouseClicked(MouseEvent event) {
      addItem("mouse clicked! ");
   }
}

Agora, vamos chamar este miniaplicativo da seguinte maneira -

<html>
   <title>Event Handling</title>
   <hr>
   <applet code = "ExampleEventHandling.class" 
      width = "300" height = "300">
   </applet>
   <hr>
</html>

Inicialmente, o miniaplicativo exibirá "inicializando o miniaplicativo. Iniciando o miniaplicativo." Depois de clicar dentro do retângulo, "mouse clicado" será exibido também.

Exibindo Imagens

Um miniaplicativo pode exibir imagens no formato GIF, JPEG, BMP e outros. Para exibir uma imagem dentro do miniaplicativo, você usa o método drawImage () encontrado na classe java.awt.Graphics.

A seguir está um exemplo que ilustra todas as etapas para mostrar imagens -

import java.applet.*;
import java.awt.*;
import java.net.*;

public class ImageDemo extends Applet {
   private Image image;
   private AppletContext context;
   
   public void init() {
      context = this.getAppletContext();
      String imageURL = this.getParameter("image");
      if(imageURL == null) {
         imageURL = "java.jpg";
      }
      try {
         URL url = new URL(this.getDocumentBase(), imageURL);
         image = context.getImage(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         // Display in browser status bar
         context.showStatus("Could not load image!");
      }
   }
   
   public void paint(Graphics g) {
      context.showStatus("Displaying image");
      g.drawImage(image, 0, 0, 200, 84, null);
      g.drawString("www.javalicense.com", 35, 100);
   }  
}

Agora, vamos chamar este miniaplicativo da seguinte maneira -

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "300" height = "200">
      <param name = "image" value = "java.jpg">
   </applet>
   <hr>
</html>

Reproduzindo Áudio

Um miniaplicativo pode reproduzir um arquivo de áudio representado pela interface AudioClip no pacote java.applet. A interface AudioClip possui três métodos, incluindo -

• public void play() - Reproduz o clipe de áudio uma vez, desde o início.

• public void loop() - Faz com que o clipe de áudio seja reproduzido continuamente.

• public void stop() - Pára de reproduzir o clipe de áudio.

Para obter um objeto AudioClip, você deve invocar o método getAudioClip () da classe Applet. O método getAudioClip () retorna imediatamente, independentemente de o URL ser resolvido ou não para um arquivo de áudio real. O arquivo de áudio não é baixado até que seja feita uma tentativa de reproduzir o clipe de áudio.

A seguir está um exemplo que ilustra todas as etapas para reproduzir um áudio -

import java.applet.*;
import java.awt.*;
import java.net.*;

public class AudioDemo extends Applet {
   private AudioClip clip;
   private AppletContext context;
   
   public void init() {
      context = this.getAppletContext();
      String audioURL = this.getParameter("audio");
      if(audioURL == null) {
         audioURL = "default.au";
      }
      try {
         URL url = new URL(this.getDocumentBase(), audioURL);
         clip = context.getAudioClip(url);
      } catch (MalformedURLException e) {
         e.printStackTrace();
         context.showStatus("Could not load audio file!");
      }
   }
   
   public void start() {
      if(clip != null) {
         clip.loop();
      }
   }
   
   public void stop() {
      if(clip != null) {
         clip.stop();
      }
   }
}

Agora, vamos chamar este miniaplicativo da seguinte maneira -

<html>
   <title>The ImageDemo applet</title>
   <hr>
   <applet code = "ImageDemo.class" width = "0" height = "0">
      <param name = "audio" value = "test.wav">
   </applet>
   <hr>
</html>

Você pode usar test.wav em seu PC para testar o exemplo acima.

A linguagem Java suporta três tipos de comentários -

Sr. Não.	Comentário e descrição
1	/* text */ O compilador ignora tudo de / * a * /.
2	//text O compilador ignora tudo desde // até o final da linha.
3	/** documentation */ Este é um comentário de documentação e em geral é chamado doc comment. oJDK javadocferramenta usa comentários de documentos ao preparar documentação gerada automaticamente.

Este capítulo explica como explicar Javadoc. Veremos como podemos usar Javadoc para gerar documentação útil para o código Java.

O que é Javadoc?

Javadoc é uma ferramenta que acompanha o JDK e é utilizada para gerar documentação de código Java em formato HTML a partir do código-fonte Java, o que requer documentação em formato predefinido.

A seguir está um exemplo simples onde as linhas dentro de /*….*/ são comentários Java de várias linhas. Da mesma forma, a linha que precede // é o comentário de linha única do Java.

Exemplo

/**
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31 
*/
public class HelloWorld {

   public static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

Você pode incluir tags HTML necessárias dentro da parte da descrição. Por exemplo, o exemplo a seguir usa <h1> .... </h1> para título e <p> foi usado para criar quebra de parágrafo -

Exemplo

/**
* <h1>Hello, World!</h1>
* The HelloWorld program implements an application that
* simply displays "Hello World!" to the standard output.
* <p>
* Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
* 
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31 
*/
public class HelloWorld {

   public static void main(String[] args) {
      // Prints Hello, World! on standard output.
      System.out.println("Hello World!");
   }
}

As tags javadoc

A ferramenta javadoc reconhece as seguintes tags -

Tag	Descrição	Sintaxe
@autor	Adiciona o autor de uma classe.	@author name-text
{@código}	Exibe texto em fonte de código sem interpretar o texto como marcação HTML ou tags javadoc aninhadas.	{@code text}
{@docRoot}	Representa o caminho relativo para o diretório raiz do documento gerado a partir de qualquer página gerada.	{@docRoot}
@descontinuada	Adiciona um comentário indicando que esta API não deve mais ser usada.	@deprecated deprecatedtext
@exceção	Adiciona um Throws subtítulo da documentação gerada, com o nome da classe e o texto de descrição.	@exception class-name description
{@inheritDoc}	Herda um comentário do nearest classe herdável ou interface implementável.	Herda um comentário da superclasse imediata.
{@ligação}	Insere um link em linha com o rótulo de texto visível que aponta para a documentação do pacote, classe ou nome de membro de uma classe referenciada.	{@link package.class # member label}
{@linkplain}	Idêntico a {@link}, exceto que o rótulo do link é exibido em texto simples do que a fonte do código.	{@linkplain package.class # member label}
@param	Adiciona um parâmetro com o nome do parâmetro especificado seguido pela descrição especificada à seção "Parâmetros".	@param parameter-name description
@Retorna	Adiciona uma seção "Devoluções" com o texto da descrição.	@return description
@Vejo	Adiciona um título "Consulte também" com um link ou entrada de texto que aponta para a referência.	@ver referência
@serial	Usado no comentário do documento para um campo serializável padrão.	@serial field-description | incluir | excluir
@serialData	Documenta os dados gravados pelos métodos writeObject () ou writeExternal ().	@serialData data-description
@serialField	Documenta um componente ObjectStreamField.	@serialField field-name field-type field-description
@Desde a	Adiciona um título "Desde" com o texto desde especificado à documentação gerada.	@since release
@throws	As tags @throws e @exception são sinônimos.	@throws class-name description
{@valor}	Quando {@value} é usado no comentário de documento de um campo estático, ele exibe o valor dessa constante.	{@value package.class # field}
@versão	Adiciona um subtítulo "Versão" com o texto da versão especificado aos documentos gerados quando a opção -version é usada.	@version version-text

Exemplo

O programa a seguir usa algumas das tags importantes disponíveis para comentários de documentação. Você pode usar outras tags com base em seus requisitos.

A documentação sobre a classe AddNum será produzida no arquivo HTML AddNum.html, mas ao mesmo tempo um arquivo mestre com um nome index.html também será criado.

import java.io.*;

/**
* <h1>Add Two Numbers!</h1>
* The AddNum program implements an application that
* simply adds two given integer numbers and Prints
* the output on the screen.
* <p>
* <b>Note:</b> Giving proper comments in your program makes it more
* user friendly and it is assumed as a high quality code.
*
* @author  Zara Ali
* @version 1.0
* @since   2014-03-31
*/
public class AddNum {
   /**
   * This method is used to add two integers. This is
   * a the simplest form of a class method, just to
   * show the usage of various javadoc Tags.
   * @param numA This is the first paramter to addNum method
   * @param numB  This is the second parameter to addNum method
   * @return int This returns sum of numA and numB.
   */
   public int addNum(int numA, int numB) {
      return numA + numB;
   }

   /**
   * This is the main method which makes use of addNum method.
   * @param args Unused.
   * @return Nothing.
   * @exception IOException On input error.
   * @see IOException
   */

   public static void main(String args[]) throws IOException {
      AddNum obj = new AddNum();
      int sum = obj.addNum(10, 20);

      System.out.println("Sum of 10 and 20 is :" + sum);
   }
}

Agora, processe o arquivo AddNum.java acima usando o utilitário javadoc da seguinte maneira -

$ javadoc AddNum.java
Loading source file AddNum.java...
Constructing Javadoc information...
Standard Doclet version 1.7.0_51
Building tree for all the packages and classes...
Generating /AddNum.html...
AddNum.java:36: warning - @return tag cannot be used in method with void return type.
Generating /package-frame.html...
Generating /package-summary.html...
Generating /package-tree.html...
Generating /constant-values.html...
Building index for all the packages and classes...
Generating /overview-tree.html...
Generating /index-all.html...
Generating /deprecated-list.html...
Building index for all classes...
Generating /allclasses-frame.html...
Generating /allclasses-noframe.html...
Generating /index.html...
Generating /help-doc.html...
1 warning
$

Você pode verificar toda a documentação gerada aqui - AddNum . Se você estiver usando JDK 1.7, o javadoc não gera um grandestylesheet.css, então sugerimos baixar e usar a folha de estilo padrão do https://docs.oracle.com/javase/7/docs/api/stylesheet.css