Esempio Java con incapsulamento, polimorfismo ed ereditarietà?

Question

Ho bisogno di produrre un progetto con le caratteristiche elencate della programmazione orientata agli oggetti usando Java.

Qualcuno potrebbe consultare il mio rapido programma di esempio per confermare che capisco come queste caratteristiche siano implementate e che siano tutte presenti e fatte correttamente?

package Example; 

public class Parent { 

    private int a; 
    public void setVal(int x){ 
     a = x; 
    } 
    public void getVal(){ 
     System.out.println("value is "+a); 
    } 
} 

public class Child extends Parent{ 

    //private fields indicate encapsulation 
    private int b; 
    //Child inherits int a and getVal/setVal methods from Parent 
    public void setVal2(int y){ 
     b = y; 
    } 
    public void getVal2(){ 
     System.out.println("value 2 is "+b); 
    } 
    //having a method with the same name doing different things 
    //for different parameter types indicates overloading, 
    //which is an example of polymorphism 
    public void setVal2(String s){ 
     System.out.println("setVal should take an integer."); 
    } 
} 

Answer 1

tuo polimorfismo esempio è semplicemente metodo sovraccarico e che non è in realtà ciò che gli Object Oriented persone intendono con il polimorfismo. Significa come puoi avere un'interfaccia che espone un metodo, e le varie classes che implementano tale interface possono implementare il metodo per avere comportamenti diversi.

Vedere this. Ultimo paragrafo dell'introduzione in particolare.

Inoltre, suggerirei che il modo migliore per dimostrare la conoscenza del polimorfismo nel codice includa necessariamente un codice client che utilizza gli oggetti polimorfici per dimostrare che possono avere comportamenti diversi, cioè poli.

Answer 2

Un paio di cose:

• metodo getter deve restituire valori.
• Il sovraccarico è diverso dall'override. Probabilmente si vorrà sovrascrivere setVal() (o forse qualche altro metodo più appropriato) nella classe figlia per dimostrare il polimorfismo.

---

vedere l'esempio seguente. Il genitore implementa fooMethod(). Il padre sovraccarica fooMethod() aggiungendo fooMethod (String str). Pensa a questi due metodi separati, completamente non correlati: hanno solo dei nomi molto simili. Il sovraccarico non ha nulla a che fare con il polimorfismo.

Quindi Child estende Parent. Inizialmente, Child eredita fooMethod da Parent, ma vuole una funzionalità diversa quando viene chiamato fooMethod(). So Child sovrascrive fooMethod() con la propria implementazione. Ora quando un oggetto di Child chiama fooMethod(), verrà eseguita la versione Child di fooMethod(), stampando "bar", non "foo".

public class Parent { 
    public void fooMethod() { 
    System.out.println("foo"); 
    } 

    public void fooMethod(String str) { // overloading Parent.fooMethod() 
    System.out.println("foo " + str); 
    } 
} 


public class Child extends Parent { 
    public void fooMethod() { 
    System.out.println("bar"); // overriding Parent.fooMethod() 
    } 
} 

Answer 3

l'esempio di sovrascrittura non è corretto (come in, non dimostra il polimorfismo).

vengono visualizzate due funzioni con diverse firme (i tipi di argomenti fanno parte della firma della funzione). solo perché hanno lo stesso nome non li rende un esempio di override.

primario sarebbe se figlio di classe aveva qualcosa come

public void setVal(int x){ 
    a = x+10; 
} 

che l'override del metodo SETVAL (int) nella sua super (genitore) class.

comunque un modo migliore per dimostrare il polimorfismo sarebbe qualcosa sulla falsariga di

Parent guy = new Child(); 
guy.getVal(); 

Answer 4

/* 
* To change this template, choose Tools | Templates 
* and open the template in the editor. 
*/ 
class Parent_1 
{ 
    private int i;//encap 
    private int j; 

    public void display() {    
     System.out.println("these are the 2 answer"); 
    } 
} 

class child extends Parent_1 //inher 
{ 
    public void display() //method overiding 
    { 
     System.out.println("this is for method overriding"); 
    } 

    public void mul(int i, int j) 
    { 
     int k=i*j; 
     System.out.println("mul of 2 int val is:"+k); 
    } 

    public void mul(double i,double j) //poly 
    { 
     double z=i*j; 
     System.out.println("mul val of 2 double is:"+z); 
    } 
} 

class Son 
{ 
    public static void main(String args[]) 
    { 
     Parent_1 p=new Parent_1(); 

     Parent_1 pt=new child(); 
     child cd=new child(); 
     p.display(); 
     cd.mul(2, 20); 
     cd.mul(2.2, 1.1); 
     pt.display(); 
    } 
}