Desenvolvimento Código Aberto

Método de sobrecarga é uma característica encontrada em várias linguagens de programação, que permite a criação de vários métodos com o mesmo nome, que diferem uns dos outros no tipo da entrada e a saída da função. É simplesmente definido como a capacidade de uma função para executar diferentes tarefas.

Construtores, são usados ​​para criar instâncias de um objeto, também podem ser sobrecarregados em algumas linguagens de programação orientadas a objeto. Porque em muitas línguas o nome do construtor é pré-determinado pelo nome da classe. Sempre que são necessários vários construtores são implementados como funções sobrecarregadas. Um construtor padrão não tem parâmetros, instanciam os membros do objeto com um valor zero.

Ter pelo menos dois construtores é quase obrigatório em programação orientada a objeto, o construtor default facilita criar métodos Modifiers e Fill-in, pois é possível manipular objetos sem ter que passar nenhum parâmetros para eles e trabalhar com seus atributos dentro dos métodos, enquanto ao mesmo tempo é pratico criar objetos com valores inicializados, sem ter que escrever varias linhas.

Em Java, C++ e C# sobrecarregar um construtor  é simples, basta apenas criar quantos construtores forem necessários, por outro lado linguagens hibridas como Abap e Python (C++ também é uma linguagem hibrida, mas é muito poderosa) não é possível  sobrecarregar o método construtor, mas como este é um recurso extremamente útil, existe um modo de criar o mesmo efeito de sobrecarga nos construtores.

Abap possui a palavra chave OPTIONAL, na qual marca o parâmetro como opcional, deste modo é possível criar um objeto que simula o construtor Overload.

Python é uma linguagem moderna e bem flexível em sua sintaxe e possibilita inicializar o construtor atribuindo valores a variável e podemos usar a palavra chave None para dizer que o conteúdo é vazio, simulando deste modo um construtor Overload.

Exemplo:

Neste exemplo criamos dois construtores : o construtor default e um construtor Overload, para as linguagens Java, C++ e C# e para as  linguagens Abap e Python usamos um recurso da língua para simular o construtor Overload obtendo o mesmo efeito.

Java

public class Sobrecarga
  {
     int x = 0;
     int y = 0;

     public Sobrecarga () {}

     public Sobrecarga(int x, int y)
   {
     this.x = x;
     this.y = y;
   }

   public  void imprimeSb()
   {
     System.out.println("X=" + this.x + " Y=" + this.y);
   }

   public static void main(String[] args)
   {
       Sobrecarga sc1 = new Sobrecarga();
       Sobrecarga sc2 = new Sobrecarga(10,20);
       System.out.println("Construtor Default");
       sc1.imprimeSb();
       System.out.println("Construtor Overload");
       sc2.imprimeSb();
  }
 }

C++

#include "stdafx.h"
#include <iostream>

using namespace std;

class Sobrecarga
  {
  public:
   int x = 0;
   int y = 0;

   Sobrecarga( )   {   }

   Sobrecarga(int x, int y)
   {
    this->x = x;
    this->y = y;
   }

  void imprimeSb()
   {
    cout << "X=" << this->x << " Y=" << this->y << endl;
   }
};

int _tmain(int argc, _TCHAR* argv[])
  {
   Sobrecarga sc1;  Sobrecarga sc2(10, 20);
   cout << "Construtor Default" << endl;
   sc1.imprimeSb();

   cout << "Construtor Overload" << endl;
   sc2.imprimeSb();
   system("pause");
   return 0;
  }

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesenvolvimentoAberto
  {
      class Sobrecarga
      {
          int x = 0;
          int y = 0;

         public Sobrecarga() { }

         public Sobrecarga(int x, int y)
          {
              this.x = x;
              this.y = y;
          }

      public void imprimeSb()
       {
         Console.WriteLine("X=" + this.x + " Y=" + this.y);
       }

          static void Main(string[] args)
          {
              Sobrecarga sc1 = new Sobrecarga();
              Sobrecarga sc2 = new Sobrecarga(10,20);
              Console.WriteLine("Construtor Default");
              sc1.imprimeSb();
              Console.WriteLine("Construtor Overload");
              sc2.imprimeSb();
              Console.ReadKey();
          }
      }
  }

Abap

*&---------------------------------------------------------------------*
*& Report  ZOBJETOS_OVER
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Construtor Overload
*&---------------------------------------------------------------------*

REPORT  ZOBJETOS_OVER.

* Declara Classe

Class SobreCarga DEFINITION.

PUBLIC SECTION.
   DATA X TYPE i.
    DATA Y TYPE i.

" Efeito Overload
METHODS:
CONSTRUCTOR IMPORTING
             X TYPE i OPTIONAL
             Y TYPE i OPTIONAL,
ImprimeSB.

ENDCLASS.

Class SOBRECARGA IMPLEMENTATION.

 METHOD CONSTRUCTOR.
     me->X = X.
     me->Y = Y.
 ENDMETHOD.

 METHOD ImprimeSB.
     WRITE: / 'X=', me->X, 'Y=', me->Y.
 ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

DATA SB1 TYPE REF TO SOBRECARGA.
DATA SB2 TYPE REF TO SOBRECARGA.

* Cria Objetos Construtor Default e Overload
CREATE OBJECT SB1.
CREATE OBJECT SB2 EXPORTING X = 10 Y = 20.

WRITE: / 'Construtor Default:'.
SB1->IMPRIMESB( ).
WRITE: / 'Construtor Overload:'.
SB2->IMPRIMESB( ).

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# sobrecarga.py

class SobreCarga:
      x = 0
      y = 0
      def __init__(Self,x= None, y = None):
          if (x is not None) and (y is not None):
              Self.x = x
              Self.y = y
      def ImprimeSb(Self):
          print "X=", Self.x, "Y=", Self.y

sc1 = SobreCarga();
sc2 = SobreCarga(10,20);
print "Construtor Default"
sc1.ImprimeSb();
print "Construtor Overload"
sc2.ImprimeSb();
raw_input()