Abaixo, usarei dois exemplos para ilustrar completamente a escalabilidade do polimórfico em Java. Como um excelente programador, você deve entender a escalabilidade dos programas, que é muito propício ao desenvolvimento subsequente de programas.
O primeiro exemplo:
Use a placa -mãe do computador como exemplo. Para a placa -mãe do computador com a qual estamos familiarizados, existem muitos módulos, cartões de rede e cartões de som? Se você deseja usar essas funções, só pode usar a placa -mãe para executar e, em seguida, alimentar os cartões de rede e os cartões de som. Mas como isso pode ser alcançado na linguagem do software? Você tem que executar a placa -mãe primeiro e, em seguida, a placa de som ou a rede de rede é executada? Mas, dessa maneira, a expansão não é alta e a operação de executar a placa de som e a execução da placa de rede é repetida. Além disso, muitos módulos também têm essas funções, para que você possa simplesmente executar o módulo na placa -mãe. Este é um deles. Se, naquele dia, quando a tecnologia for atualizada e um novo módulo aparecer, você precisa criar o objeto do módulo e depois executar novamente? Obviamente, isso não é propício ao desenvolvimento. No entanto, para esse problema, depois que os fabricantes da placa -mãe discutem com a placa de som e os fabricantes de cartões de rede, eles usarão uma interface PCI para conectar a placa -mãe e o módulo no futuro, o que resolve completamente o problema da incapacidade de usar ou reutilizar atualizações. Isso corresponde ao polimorfismo em nosso Java. Usando o polimorfismo, podemos melhorar bastante a escalabilidade do programa!
O código específico é o seguinte!
/*Requisitos: Exemplos de execução do computador, Computador em execução com base na placa -mãe. */interface PCI {public void Open (); public void close ();} placa principal da classe {public void run () {System.out.println ("Run Run"); } public void usepci (pci p) // pci p = new netcard () // pontos de referência de interface pontos para seu próprio objeto de subclasse. {if (p! = null) {p.open (); p.close (); }}} classe NetCard implementa PCI {public void Open () {System.out.println ("netcard Open"); } public void Close () {System.out.println ("NetCard Close"); método(); }} classe Soundcard implementa PCI {public void Open () {System.out.println ("Soundcard Open"); } public void Close () {System.out.println ("Soundcard Close"); }}/*placa principal da classe {public void run () {System.out.println ("Run Run"); } public void useNetCard (netcard c) {c.open (); c.close (); }} classe netcard {public void Open () {System.out.println ("netcard Open"); } public void Close () {System.out.println ("NetCard Close"); }}*/classe duotaidemo5 {public static void main (string [] args) {mainboard mb = new mainboard (); mb.run (); mb.Usepci (nulo); mb.Usepci (new NetCard ()); mb.Usepci (new Soundcard ()); }}O segundo exemplo:
Use bancos de dados comuns para explicar o polimorfismo. Quanto aos bancos de dados com os quais estamos familiarizados, atualmente existem dois modos de conexão com o banco de dados: JDBC e conexão hibernateliana. Ao usar bancos de dados, existem duas operações essenciais: conexão e fechamento. No momento, use a interface para encapsular essas duas operações e você precisa usar o modo de conexão para alterar diretamente o nome da classe!
O código específico é o seguinte!
/*Requisitos: Operação do banco de dados. Os dados são: informações do usuário. 1. Conecte -se ao banco de dados. JDBC Hibernate2, opera o banco de dados. c Crie r leia u update d Delete3, feche a conexão do banco de dados. */interface userInfodao {public void add (usuário do usuário); public void Delete (usuário do usuário);} classe UserInfobyjdbc implementa UserinOfdao {public void add (usuário do usuário) {1, JDBC se conecta ao banco de dados. ; 2. Use o SQL para adicionar instrução para adicionar dados. ; 3, feche a conexão. } public void Delete (usuário do usuário) {1, JDBC se conecta ao banco de dados. ; 2. Use a instrução SQL Add para excluir dados. ; 3, feche a conexão. }} classe UserInfobyHibernate implementa o userInfodao {public void add (usuário do usuário) {1, hibernate se conecta ao banco de dados. ; 2. Use o SQL para adicionar instrução para adicionar dados. ; 3, feche a conexão. } public void Delete (usuário do usuário) {1, Hibernate se conecta ao banco de dados. ; 2. Use a instrução SQL Add para excluir dados. ; 3, feche a conexão. }} classe dBoPerouTe {public static void main (string [] args) {// userInfobyjdbc ui = new userInfobyjdbc (); // userInfobyHibernate ui = novo userInfobyhibernate (); UserInfodao ui = novo userInfobyHibernate (); ui.add (usuário); ui.delete (usuário); }}Resumir:
1. Ambos os exemplos usam interfaces para abstrair algumas operações repetitivas. Para permitir que diferentes módulos usem essas operações direta e rapidamente, podemos usar diretamente a transformação polimórfica para cima (consulte meu blog anterior) e depois usar a referência da classe pai para chamá -la. De qualquer forma, não importa se a tecnologia é atualizada e novos módulos estão disponíveis ou os módulos existentes são substituídos, podemos usar a referência da classe pai para chamar diretamente suas operações comuns!
2. Você não precisa usar interfaces, também pode usar classes abstratas. No entanto, o uso de interfaces será mais escalável. Se você os atualizar no futuro, poderá alterar diretamente a interface sem alterar as classes abstratas. Em segundo lugar, o uso de interfaces pode ser mais herdado! Este também é um lugar conveniente.
O artigo acima Java usa dois exemplos para ilustrar completamente a escalabilidade dos polimorfismos. Este é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.