Método Construtor em Java I Sobrecarga de Construtor
Fonte: Programação Orientada a Objetos77 O que é Construtor ? Este é um tipo especial de método cujo nome é igual ao nome da classe, que determina como o objeto é inicializado quando é criado. Como outros métodos, também podemos definir um método Construtor em nosso programa Java, mas diferentemente de outros métodos, não podemos chamar o Construtor diretamente; Java chama o construtor automaticamente quando um objeto é criado. Quando usamos a palavra-chave new para criar um objeto de uma classe, Java faz três coisas:- Aloca memória para um objeto.
- Inicialize esta variável de instância de objeto com seu valor inicial ou padrão.
- Chama o construtor Method da classe.
Construtor Básico
Por definição, o Construtor parece um método regular com duas diferenças principais.- O construtor e o nome da classe são sempre iguais.
- Não tem tipo de retorno
class Person
{
String name;
int age;
Person (String n, int a)
{
name = n;
age = a;
}
void printPerson ()
{
System.out.print("Hi, I am " +name);
System.out.println(" I am "+ age + " years old.");
}
public static void main(String args[])
{
Person p;
p = new Person ("Ajab", 20);
p.printPerson();
p = new Person ("Rizwan", 30);
p.printPerson();
Obtemos a saída:
Olá, meu nome é Ajab. Eu tenho 20 anos. Olá, meu nome é Rizwan. eu tenho 30 anos de idade
Sobrecarga do construtor
Como outros métodos, o Construtor também pode aceitar diferentes números e tipos de parâmetros, permitindo que objetos sejam criados com propriedades especificadas ou permitindo que o Construtor calcule propriedades com base em diferentes tipos de entrada. Por exemplo, a classe MyRectone em uma determinada tabela cria um construtor MyRectone e passa um parâmetro diferente em vez de criar métodos diferentes para os argumentos fornecidos.class MyRectone
{
int x1 = 0;
int y1 = 0;
int x2 = 0;
int y2 = 0;
MyRectone ( int x1, int x2, int x2, int y2)
{
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}
MyRectone (Point topLeft, Point bottomRight)
{
x1 = topLeft.x;
y1 = topLeft.y;
x2 = bottomRight.x;
y2 = bottomRight.y;
}
MyRectone ( Point topLeft, int w, int h)
{
x1 = topLeft.x;
y1 = top left.y;
x2 = ( x1 + w);
y2 = (y1 + h);
}
void printRect ()
{
System.out.print ("MyRectone: <" + x1 + ", " + y1);
system.out.println (", " + x2 + " ,"+ y2 + ">");
}
public static void main (String args [] )
{
MyRectone rect;
System.out.println ("Calling MyRectone with coordinates 35,35 70,70");
rect = new MyRectone (35,35,70,70);
rect.printRect();
System.out.println ("Calling MyRectone with coordinates (15,15) (30,30)");
rect = new MyRectone (15,15,30,30);
rect.printRect();
System.out.print (" Calling buildRect w/1 point (10,10),");
System.out.println ("width (50) and height (50)");
rect = new MyRectone ( new Point (10,10), 50, 50);
rect.printRect();
Conclusão:
Chamando MyRectone com coordenadas 35,35 70,70: MyRectone: <35,35,70,70> Chamando buildRect com 1 ponto (15,15), (30,30): MyRectone: <15,15,30,30 > Chamando buildRect com 1 ponto (10,10), largura (50) e altura (50): MyRectone:<10,10,50,50>
Chamando outro construtor
Um construtor pode ser um superconjunto de outro construtor definido na sua classe; isto é, eles podem se comportar da mesma forma e um pouco mais. Em vez de duplicar o comportamento idêntico em vários métodos construtores em nossa classe, faz sentido poder simplesmente chamar o primeiro construtor a partir do corpo do segundo construtor. Java fornece uma sintaxe especial para isso. Para chamar um construtor definido na classe atual, use este formulário:this (arg1, arg2, arg3… ..);
Os argumentos para isso são, obviamente, os argumentos para o construtor.
Classes e interfaces Java abstratas
Fonte: Dev.to Uma classe abstrata é uma classe que possui alguns métodos sem uma definição completa e possui o modificador abstrato .- Você não pode criar um objeto usando um construtor de classe abstrata.
- Você pode usar uma classe abstrata como classe base para definir uma classe derivada.
- Uma classe abstrata possui pelo menos um método abstrato.
- Método abstrato : possui um cabeçalho como um método regular, mas sem corpo, e requer o modificador abstrato e ponto e vírgula.
- Um método abstrato não pode ser privado.
- Uma classe abstrata pode ser um tipo.
public abstract class Example{
private String data1;
private double data2;
public abstract double getPay();
}
Interface : Define um conjunto de métodos que qualquer classe que implemente esta interface deve ter.
- Uma interface é um tipo.
- Ele contém cabeçalhos de métodos sem definição e sem variáveis de instância:
public interface Interface1{
public void method1();
public int method2();
}
Para implementar uma interface, uma classe deve fazer duas coisas:
- Inclui implementos InterfaceName .
- A classe deve implementar todos os cabeçalhos de métodos listados na interface.
public class Implementer implements Interface1 {
@Override
public void method1() {
//definition
}
@Override
public int method2() {
//definition
}
}
- Os cabeçalhos dos métodos são declarados public .
- Uma classe abstrata também pode implementar uma interface; esta classe fornece definições para alguns dos cabeçalhos de métodos na interface.
- As interfaces Java também podem conter constantes , por exemplo:
public interface Constant {
public static final int JANUARY = 1, FEBRUARY = 2, MARCH = 3;
}
- Qualquer classe que implemente a interface Constant terá automaticamente estas constantes, por exemplo:
public class Constants implements Constant {
public static void main(String[] args) {
System.out.println(JANUARY);
}
}
- Você pode combinar o uso de interfaces incluindo constantes e cabeçalhos de métodos em uma única interface.
- Java não suporta herança múltipla, portanto uma classe só pode estender uma classe base. Entretanto, usando interfaces, uma classe pode implementar múltiplas interfaces:
public class Implementer implements Interface1, Interface2, .. InterfaceN{
}
- A razão pela qual uma classe Java só pode estender uma classe base é porque se Java permitir duas classes base, as duas classes podem ter o mesmo cabeçalho de método com uma definição diferente, resultando em inconsistência.
- Duas interfaces podem ser incompatíveis se você definir duas constantes com o mesmo nome e valores diferentes:
public interface Interface1{
public static final int ANSWEAR = 0;
}
public interface Interface1{
public static final int ANSWEAR = 3;
}
GO TO FULL VERSION