PRA QUE SERVE A INTERFACE NA PRATICA???
Ola,Pessoal!
Eu sei que não sou obrigado a usar interfaces em um projeto OO.
Mas, não entendo é porque ele é útil?????
Os colegas estão me explicando que em aplicações mais elaboradas, faz sentido usar Interfaces.
Mas, isto só diz [Ô]QUANDO[Ô] usar ( Em aplicações elaboradas) !
O que gostaria de saber, é PORQUE usar???
Ou seja, porque não criar a classe direto, com os métodos que preciso. Eu não estou conseguindo
enxergar a vantagem de criar uma classe ( Interface), com métodos que não fazem nada (Sem corpo).
Acho que o que esta faltando, é um exemplo [Ô]PRATICO[Ô]. Algum colega conhece????
Eu sei que não sou obrigado a usar interfaces em um projeto OO.
Mas, não entendo é porque ele é útil?????
Os colegas estão me explicando que em aplicações mais elaboradas, faz sentido usar Interfaces.
Mas, isto só diz [Ô]QUANDO[Ô] usar ( Em aplicações elaboradas) !
O que gostaria de saber, é PORQUE usar???
Ou seja, porque não criar a classe direto, com os métodos que preciso. Eu não estou conseguindo
enxergar a vantagem de criar uma classe ( Interface), com métodos que não fazem nada (Sem corpo).
Acho que o que esta faltando, é um exemplo [Ô]PRATICO[Ô]. Algum colega conhece????
Oi Marcos,
Vou colocar aqui a resposta do Victor de Alencar Jesus (do fórum Javafree), achei a explicação dele bem clara e com exemplos (é a quinta resposta da pergunta):
As interfaces servem para flexionar seu programa. Pela sua última pergunta, acho que vc ainda não entendeu bem como funcionam. Vou te dar um exemplo, de repente esse conceito fica mais claro pra vc.
Vamos supor que eu esteja fazendo um jogo de corrida, onde eu tenha apenas dois modelos para escolher: um Fusca e um Fiat Uno. E digamos que apenas no Fusca eu possa [Ô]implementar[Ô] um turbo compressor. Provavelmente para um jogo desse porte, eu teria um classe chamada automovel, onde eu teria os principais métodos (acelerar e freiar), e depois eu iria herdando as outras classes (fusca e uno).
public interface Turbo
{
public void AtivarTurbo();
}
public class Automovel
{
public void acelerar();
{
}
public void freiar;
{
}
}
public class Uno extends Automovel
{
}
public class Fusca extends Automovel implements Turbo
{
public void AtivarTurbo()
{
// Código implementando turbo de fusca
}
}
Então, agora eu tenho um carro que tem turbo (fusca) e outro que não tem (uno), mas herdam da mesma classe (automovel).
A qualquer momento no meu código eu posso ter:
Fusca f = new Fusca();
f.AtivarTurbo();
Entendeu?
Além disso, as interfaces dão um poder extra no polimorfismo. Vamos supor que eu tenha uma classe chamada Oficina, responsável por consertar os carros. Então, eu teria:
public class Oficina
{
public void ConsertarLataria(Automovel a)
{
}
public void ConsertarMotor(Automovel a)
{
}
public void ConsertarTurbo(Turbo t)
{
}
}
Para o método ConsertarTurbo eu poderia passar QUALQUER carro que implemente a classe turbo.
Então, se amanhã ou depois eu quiser colocar mais um carro no meu jogo. Digamos, um Celta e, se eu quisesse que este carro pudesse ter turbo, eu faria:
public class Celta extends Automovel implements Turbo
{
public void AtivarTurbo()
{
// Codigo de turbo para Celta
}
}
E depois eu até poderia ter um código assim:
Fusca f = new Fusca();
Celta c = new Celta();
Oficina o = new Oficina();
o.ConsertarTurbo(f);
o.ConsertarTurbo(c);
Viu? Eu não precisei implementar um método pra consertar turbo de celta e outro pra fusca.
Espero ter ajudado.
Valeu!
_________________
Atenciosamente,
Victor de Alencar Jesus.
Vou colocar aqui a resposta do Victor de Alencar Jesus (do fórum Javafree), achei a explicação dele bem clara e com exemplos (é a quinta resposta da pergunta):
As interfaces servem para flexionar seu programa. Pela sua última pergunta, acho que vc ainda não entendeu bem como funcionam. Vou te dar um exemplo, de repente esse conceito fica mais claro pra vc.
Vamos supor que eu esteja fazendo um jogo de corrida, onde eu tenha apenas dois modelos para escolher: um Fusca e um Fiat Uno. E digamos que apenas no Fusca eu possa [Ô]implementar[Ô] um turbo compressor. Provavelmente para um jogo desse porte, eu teria um classe chamada automovel, onde eu teria os principais métodos (acelerar e freiar), e depois eu iria herdando as outras classes (fusca e uno).
public interface Turbo
{
public void AtivarTurbo();
}
public class Automovel
{
public void acelerar();
{
}
public void freiar;
{
}
}
public class Uno extends Automovel
{
}
public class Fusca extends Automovel implements Turbo
{
public void AtivarTurbo()
{
// Código implementando turbo de fusca
}
}
Então, agora eu tenho um carro que tem turbo (fusca) e outro que não tem (uno), mas herdam da mesma classe (automovel).
A qualquer momento no meu código eu posso ter:
Fusca f = new Fusca();
f.AtivarTurbo();
Entendeu?
Além disso, as interfaces dão um poder extra no polimorfismo. Vamos supor que eu tenha uma classe chamada Oficina, responsável por consertar os carros. Então, eu teria:
public class Oficina
{
public void ConsertarLataria(Automovel a)
{
}
public void ConsertarMotor(Automovel a)
{
}
public void ConsertarTurbo(Turbo t)
{
}
}
Para o método ConsertarTurbo eu poderia passar QUALQUER carro que implemente a classe turbo.
Então, se amanhã ou depois eu quiser colocar mais um carro no meu jogo. Digamos, um Celta e, se eu quisesse que este carro pudesse ter turbo, eu faria:
public class Celta extends Automovel implements Turbo
{
public void AtivarTurbo()
{
// Codigo de turbo para Celta
}
}
E depois eu até poderia ter um código assim:
Fusca f = new Fusca();
Celta c = new Celta();
Oficina o = new Oficina();
o.ConsertarTurbo(f);
o.ConsertarTurbo(c);
Viu? Eu não precisei implementar um método pra consertar turbo de celta e outro pra fusca.
Espero ter ajudado.
Valeu!
_________________
Atenciosamente,
Victor de Alencar Jesus.
Citação::
Ola,Pessoal!
Eu sei que não sou obrigado a usar interfaces em um projeto OO.
Mas, não entendo é porque ele é útil?????
Os colegas estão me explicando que em aplicações mais elaboradas, faz sentido usar Interfaces.
Mas, isto só diz [Ô]QUANDO[Ô] usar ( Em aplicações elaboradas) !
O que gostaria de saber, é PORQUE usar???
Ou seja, porque não criar a classe direto, com os métodos que preciso. Eu não estou conseguindo
enxergar a vantagem de criar uma classe ( Interface), com métodos que não fazem nada (Sem corpo).
Acho que o que esta faltando, é um exemplo [Ô]PRATICO[Ô]. Algum colega conhece????
Cara vou fazer um exemplo bem simples a vc.
Imagine que quer criar um método para Ler e escrever texto ao mesmo tempo.
Vai precisar de usar 3 processos que irão funcionar para todos os programas que vc desenvolver e assim o seu tempo para voltar a criar restante código será bem + rápido.
Na Classe :
Imports System.IO
Public Class Procedimentos
Public Enum OpcaoFicheiro
Ler = 0
Gravar = 1
End Enum
Public Property FazTrabalho As OpcaoFicheiro
Public Shared Function ExisteFicheiro(ByRef Caminho_Ficheiro As String) As Boolean
If IO.File.Exists(Caminho_Ficheiro) Then
ExisteFicheiro = True
Else
ExisteFicheiro = False
End If
End Function
Public Function Ficheiro(ByRef IndicarCaminho As String, ByRef FazTrabalho As OpcaoFicheiro, ByRef Opcional As String) As String
Dim Ler_Documento As StreamReader
Dim Grava_Documento As StreamWriter
If ExisteFicheiro(IndicarCaminho) = True Then
If FazTrabalho = OpcaoFicheiro.Ler Then
Ler_Documento = New StreamReader(IndicarCaminho)
Opcional = Ler_Documento.ReadLine()
Ler_Documento.Close()
Return Opcional
End If
If FazTrabalho = OpcaoFicheiro.Gravar Then
Grava_Documento = New StreamWriter(IndicarCaminho)
Grava_Documento.WriteLine(Opcional)
Grava_Documento.Close()
End If
End If
Return Opcional
End Function
End class
Ora bem na Classe acima vc desenvolveu uma função que Grava e Lê na mesma função (Logo aà vc poupa trabalho e o acesso é + rápido ao dados)
Mas precisa de canalizar esse procedimento para uma só palavra de ordem (Isto porque (acho eu) quando a máquina intrepretar o código saber exactamente ao que nos estamos a referir e o que pretendemos da função previamente desenvolvida, assim vamos colocar á disposição uma palavra chave para que todos os formularios acessem através desse ponto ao objecto função que queremos.
No módulo.
Module Module1
Public ObjProcedimentos As New Procedimentos
End Module
Por último no seu formulário só terá que escrever 1 linha de código para Ler ou Gravar ficando o seu formulário bem + leve , porque toda a vez que vc necessitar da função, ela encontra-se em memória será muito + rápida o acesso bem como o seu formulário fica + limpo e melhor estroturado.
Public Class Form1
Private Sub Abrir_Click(sender As System.Object, e As System.EventArgs) Handles Abrir.Click
Textbox1.text=ObjProcedimentos.Ficheiro(Application.StartupPath & [Ô]\Testamento.txt[Ô], Procedimentos.OpcaoFicheiro.Ler, [Ô][Ô])
End Sub
End Class
Até+
Programadorvb6
O último post do ALTAFIN está excelente. MARCOS, vc não acessou o link que passei na primeira página?
Olá Marcus.
Não feche ainda o tópico, pois acho que encontrei uma resposta melhor para sua questão.
Hoje fui a uma Reunião que abordava +- esse tema , se tiver tempo eu lhe passo depois o video.
Até+
Programadorvb6
Não feche ainda o tópico, pois acho que encontrei uma resposta melhor para sua questão.
Hoje fui a uma Reunião que abordava +- esse tema , se tiver tempo eu lhe passo depois o video.
Até+
Programadorvb6
Tudo bem Prohramador VB6, Vou aguardar ........
Só uma pergunta Marcus.
Vc já trabalhou com Project Templates Item ? ou wizard ?
Vc já trabalhou com Project Templates Item ? ou wizard ?
O exemplo do PROGRAMADOR acima aplica-se bem em programação estruturada. Em POO, os métodos não podem possuir mais de um comportamento.
Olá,Laia!
Você pode explicar melhor, esta questão do Comportamento???
Você pode explicar melhor, esta questão do Comportamento???
Tópico encerrado , respostas não são mais permitidas