Qual è l'idea dietro l'accesso agli attributi privati ​​all'interno di main? Java x C++

Question

Quando si utilizza C++ non è consentito accedere a un attributo privato all'interno di una funzione principale. Esempio:

#include <iostream> 
using namespace std; 
class Test { 
    private: int a; 
    public: 
     Test(int value) { a = value; } 
     int getValue() { return a; } 
}; 
int main (int argc, char *argv[]) { 
    Test test2(4); 
    cout << test2.a; // Compile error! Test::a is private within this context 
    cout << test2.getValue(); // OK! 
    return 0; 
} 

E 'chiaro il motivo per cui v'è un errore durante l'accesso attributi privati ​​al di fuori metodi di classe, visto che il C++ non hanno funzioni principali all'interno delle classi.

Tuttavia, in Java è consentito:

public class Test { 
    private int a; 
    public Test(int value) { a = value; } 
    public int getValue() { return a; } 
    public static void main (String args[]) { 
     Test test1 = new Test(4); 
     System.out.println(test1.a); 
    } 
} 

capisco in questo caso principale è all'interno della classe di test. Tuttavia, non riesco a capire l'idea PERCHÉ è permesso, e qual è l'impatto di questo nello sviluppo/gestione del codice.

Durante l'apprendimento del C++, ho sentito una volta "Le classi non dovrebbero avere un main, Main agisce con o usa istanze di classi".

Qualcuno può far luce su questa domanda?

Answer 1

si sta guardando questo dal punto di vista sbagliato.La domanda non è perché principale può accedere alla classe interna. Non c'è uno "main" in Java. L'importante differenza a questo proposito è che per C++ c'è un singolo punto di accesso nell'applicazione che è principale, mentre in Java una singola applicazione può avere più punti di ingresso, tanti quanti uno per classe. Il punto di ingresso deve essere un metodo statico (funzione membro in gergo C++) di una classe con una firma particolare e il comportamento è esattamente lo stesso di altri metodi statici della stessa classe.

Il motivo per cui Java può avere più punti di ingresso è che tu dici alla VM all'avvio dove (in che classe) vuoi avviare l'applicazione. Questa è una funzionalità che non è disponibile in C++ (e in molte altre lingue)

Answer 2

si può effettivamente fare lo stesso in C++:

class Test { 
    private: int a; 
    public: 
     Test(int value) { a = value; } 
     int getValue() { return a; } 
     static void Main() 
     { 
      Test t(10); 
      cout << t.a; 
     } 
}; 

E 'così semplice: in entrambe le lingue, private variabili sono accessibili solo dall'interno della classe.

Tuttavia, non riesco a capire l'idea PERCHÉ è permesso.

È solo una funzione di lingua. Se non eri in grado di accedere ai privati ​​all'interno della classe, cosa potresti fare con loro?

Inoltre, non che i livelli di accesso siano a livello di classe, non a livello di istanza. Potrebbe essere buttarti fuori. Ciò significa che puoi accedere ai dati privati ​​di un'istanza diversa da un'istanza della stessa classe. Inoltre, in C++, c'è la parola chiave friend che ti offre gli stessi privilegi.

Answer 3

L'intuizione è corretta. Il secondo codice è valido in Java perché main si trova nella classe Test. Per rendere equivalente al codice try C++ per accedere al membro privato di una classe diversa, che non riuscirà a compilare:

class Test2 { 

    private int a; 
    public Test(int value) { a = value; } 
    public int getValue() { return a; } 

} 

public class Test { 

    public static void main (String args[]) { 
     Test2 test2 = new Test2(4); 
     System.out.println(test2.a); // does not compile 
    } 
} 

La differenza di fondo reale è il fatto che in C++ possono esistere funzioni classi esterne, mentre in Java qualsiasi metodo deve essere parte di una classe.

Answer 4

Questo motivo è: Java è un modello completamente Object Oriented Programming, quindi in esso tutte le cose devono essere definite in classe o l'unità più piccola in java è di classe.

Answer 5

private in Java può essere considerato "file locale" c.f. pacchetto locale. Ad esempio è possibile accedere a membri privati ​​di una classe definita nella stessa classe esterna.

AFAIK, l'ipotesi è che non è necessario proteggersi dal codice nello stesso file.

public interface MyApp { 
    class Runner { 
     public static void main(String... args) { 
      // access a private member of another class 
      // in the same file, but not nested. 
      SomeEnum.VALUE1.value = "Hello World"; 
      System.out.println(SomeEnum.VALUE1); 
     } 
    } 

    enum SomeEnum { 
     VALUE1("value1"), 
     VALUE2("value2"), 
     VALUE3("value3"); 
     private String value; 

     SomeEnum(final String value) { 
      this.value = value; 
     } 
     public String toString() { 
      return value; 
     } 
    } 
} 

http://vanillajava.blogspot.com/#!/2012/02/outer-class-local-access.html