Buona pratica di codifica rispetto all'interfaccia rispetto alla classe rispetto alla super classe

2

Attualmente sto leggendo il seguente tutorial e sono arrivato da qui link

Forse non dovrei pensare a questa domanda ora perché il tutorial non lo ha portato, ma ho una questione di buone pratiche. Secondo il tutorial fino a questo punto, se voglio definire un oggetto e i suoi metodi, posso farlo all'interno di una classe, o posso prenderne alcune parti che mi aspetto che condividano in comune con altri oggetti e metterlo in una super classe. Oppure, da quello che capisco, posso fare il primo ma ritarda definire il mio metodo fino a MAIN usando invece la parola chiave interface. Ho due domande.

Se ho una struttura di classe superclass- >, è anche possibile utilizzare una sorta di "superinterfaccia" invece di ritardare parti della definizione di metodi fino al metodo MAIN? (Si prega di correggere la mia terminologia se sapete cosa intendo, e sapere che non sto parlando correttamente.)

Qualunque cosa sia possibile, quando è opportuno utilizzare ognuno dal punto di vista dell'efficienza e anche di qualcuno che leggerebbe il mio codice?

Sono un principiante. Grazie!

Modifica: codice "Esempio" incluso (come scritto nell'IDE di Netbeans) per il completamento.

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication3;

/**
 *
 * @author Jeff
 */
class percolation{
    int site1 = 1;
    int site2 = 0;
    int site3 = 1;

    void changesite1(int newValue){
        site1 = newValue;
    }

    void changesite2(int newValue){
        site2 = newValue;


    }

    void changesite3(int newValue){
        site3 = newValue;
    }

    void printStates(){
        System.out.println("site1:" + site1 + " site2:" + site2 + " site3:" + site3);
    }
}

class extendedpercolation extends percolation{
    int site4 = 0;

    void changesite4(int newValue){
        site4 = newValue;
    }            
        void printStates1(){
            System.out.println("site1:" + site1 + " site2:" + site2 + " site3:" + site3 + " site4:" + site4);
        }          
}


class percolationdemo{
    public static void main(String[] args) {

        extendedpercolation perc1 = new extendedpercolation();
        extendedpercolation perc2 = new extendedpercolation();
        // Invoke methods on 
        // those objects
        perc1.changesite1(0);
        perc1.changesite2(0);
        perc1.changesite3(0);
        perc1.changesite4(0);
        perc1.printStates1();

        perc2.changesite1(1);
        perc2.changesite2(0);
        perc2.changesite3(1);
        perc2.changesite4(1);
        perc2.printStates1();
    }
}
    
posta Jeff 29.07.2015 - 04:14
fonte

1 risposta

1

L'hai praticamente inchiodato con il tuo commento

Maybe I should not be thinking about this question now because the tutorial hasn't brought it up

Sembra che tu sia sopra o vicino alla lezione 5, Che cos'è un'interfaccia . Penso che la tua risposta potrebbe essere trovata nella o vicino alla lezione 67, Interfacce . (Sto osservando il indice e contando solo ogni riga)

Citando da quella risposta,

There are a number of situations in software engineering when it is important for disparate groups of programmers to agree to a "contract" that spells out how their software interacts. Each group should be able to write their code without any knowledge of how the other group's code is written. Generally speaking, interfaces are such contracts.

For example, imagine a futuristic society where computer-controlled robotic cars transport passengers through city streets without a human operator. Automobile manufacturers write software (Java, of course) that operates the automobile—stop, start, accelerate, turn left, and so forth. Another industrial group, electronic guidance instrument manufacturers, make computer systems that receive GPS (Global Positioning System) position data and wireless transmission of traffic conditions and use that information to drive the car.

The auto manufacturers must publish an industry-standard interface that spells out in detail what methods can be invoked to make the car move (any car, from any manufacturer). The guidance manufacturers can then write software that invokes the methods described in the interface to command the car. Neither industrial group needs to know how the other group's software is implemented. In fact, each group considers its software highly proprietary and reserves the right to modify it at any time, as long as it continues to adhere to the published interface.

Come puoi vedere, le interfacce sono utilizzate per promettere che certe classi avranno sempre determinate proprietà e / o metodi.

Per rendere più concreto l'esempio del tutorial, basta capire che tutte le classi (ad es. Tesla, BMW, Mercedes, Toyota ecc.) che implementano l'interfaccia IAutonomousControls sono garantite per avere tutte le proprietà e i metodi (stop (), start (), turnLeft (), honk ()) definiti in tale interfaccia.

Il modo esatto in cui tali proprietà e metodi sono implementati non sono definiti e possono essere diversi da classe a classe.

    
risposta data 29.07.2015 - 05:24
fonte

Leggi altre domande sui tag