Le parti di questo capitolo
Inizio pag 1 fine pag 68, teoria fino a pag 83 esercizi
- Identifiers & JavaBeans (Objectives 1.3 and 1.4)
- Declare Classes (Exam Objective 1.1)
- Declare Interfaces (Exam Objectives 1.1 and 1.2)
- Declare Class Members (Objectives 1.3 and 1.4)
Identifiers & JavaBeans (Objectives 1.3 and 1.4)
Questo paragrafo si divide in tre parti
- Legal Identifiers
- Sun's Java Code Conventions
- JavaBeans Naming Standards
All the Java components we just talked about—classes, variables, and methods need names. In Java these names are called identifiers.
it's a good idea to make your classes cohesive. Cioè classi che trattano cose simili.
Legal Identifiers
Identifiers must start with a letter, a currency character ($), or a connecting character such as the underscore ( _ ). Identifiers cannot start with a number!
Sun's Java Code Conventions
La convenzione per la spaziatura (tabulazione) di indentazione di sun sono 4 spazi.
Classes and interfaces
The first letter should be capitalized, and if several words are linked together to form the name, the first letter of the inner words should be uppercase (a format that's sometimes called "camelCase"). For classes, the names should typically be nouns.
For example: Dog, Account, PrintWriter
For interfaces, the names should typically be adjectives like Runnable, Serializable
Methods
The first letter should be lowercase, and then normal camelCase rules should be used. In addition, the names should typically be verb-noun pairs. For example: getBalance, doCalculation, setCustomerName
Variables
Like methods, the camelCase format should be used, starting with a lowercase letter. Sun recommends short, meaningful names, which sounds good to us. Some examples: buttonWidth, accountBalance, myString
Constants
Java constants are created by marking variables static and final. They should be named using uppercase letters with underscore characters as separators: MIN_HEIGHT
JavaBeans Standards
By using naming rules, the JavaBeans spec helps guarantee that tools can recognize and use components built by different developers.
If the property is a boolean, the getter method's prefix is either get or is. For example, getStopped() or isStopped() are both valid.
The objects that receive the information that an event occurred are called listeners.
JavaBean Listener Naming Rules:
- I metodi di listener usati per registra un evento devono avere come prefisso add per esempio addActionListener()
- Quelli per deregistre un evento invece remove
- Il tipo di listener che deve essere aggiunto o rimosso deve essere passato come argomento del metodo.
- I listener devono finire con la keyword Listener
per esempio public void addMyListener(MyListener m)
Declare Classes (Exam Objective 1.1)
Questo paragrafo si divide in due parti
- Source File Declaration Rules
- Class Declarations and Modifiers
Source File Declaration Rules
Rivediamo un po' di regole che non guasta mai:
- per file sorgente può esserci una sola classe public , se c'è il file si deve chiamare con il nome della classe
- se la classe fa parte di un package questo va indicato prima di qualsiasi cosa
- l'ordine delle cose è questo package, import, dichiarazione di classe
- import e package vengono applicati a tutte le classi dichiarate dentro il sorgente
- le classi non pubbliche possono essere molteplici
Class Declarations and Modifiers
Prima della dichiarazione di una classe class MyClass { } possono esserci i seguenti modificatori
- Access modifiers: public, protected, private.
- Non-access modifiers (including strictfp, final, and abstract).
Ci sono tre access modifiers ma i livelli di accesso sono 4 , c'è quello di default
Java è un linguaggio package-centric tutte le classi devono stare in un package questo permette di evitare errori derivati da classi con lo stesso nome, se le classi non stanno in un package non c'è modo di dire alla JVM quali classi usare se più di una con lo stesso nome sta nel classpath del programma. Bisogna evitare anche la collisione dei package ma è più semplice rispetto alle classi, è consigliato usare nomi di package lunghi
Class Access
Accesso significa visibilità se una classe A ha accesso a B, di questa può instanziarla, estenderla e avere accesso ad alcuni suoi metodi e variabili.
Se una classe usa il modificatore di accesso di default (cioè non ne ha specificato nessuno), il suo livello di accesso vale solo per il package. Vediamo un esempio
package cert; class Beverage { } package exam.stuff; import cert.Beverage; class Tea extends Beverage { }
La classe Beverage compilerà correttamente mentre la classe Tea a compilazione darà questo messaggio di errore.
Can't access class cert.Beverage. Class or interface must be
public, in same package, or an accessible member class.
import cert.Beverage;
Public Access
L'unica limitazione che si può imporre a una classe con modificatore public è quella dell'estenzione che può essere inibita usando il modificatore final.
Other (Nonaccess) Class Modifiers
Sono tre final, abstract, or strictfp. Non si possono usare in contemporanea tranne per il caso di strictfp e final. Marcare una classe con strictfp significa che ogni metodo nella classe deve essere conforme alle regole dello standard IEEE 754 per i floating points. Senza questo modificatore i floating points saranno dipendenti dalla piattaforma, se non si dichiara la classe come strinctfp si possono ancora dichiarare alcuni dei metodi in modo da applicare lo standard solo a quelli.
Final Classes
Una classe viene dichiarata final perchè si vuole evitare che i metodi siano overridded. Molte classi in java hanno la caratteristica final per esempio la classe String. Il final distrugge i benefici dell' OO a meno di problemi di sicurezza.
Abstract Classes
I metodi marcati con abstract public abstract void goFast(); non hanno le parentisi ma il ; se un metodo è marcato come abstract allora tutta la classe deve esserlo
Declare Interfaces (Exam Objectives 1.1 and 1.2)
Questo paragrafo si divide in:
- Declaring an Interface
- Declaring Interface Constants
Declaring an Interface
Un interfaccia è come una classe astratta al 100%. Ma mentre una classe astratta può anche avere metodi concreti un'interfaccia no.
L'interfaccia segue alcune regole:
- i metodi non hanno modificatori ma è come se fossero tutti public e abstract
- tutte le variabili devono essere public , static e final in altre parole si possono dichiarare solo costanti e non variabili di istanza.
- i metodi non possono essere static
- dato che i metodi sono abstract non possono essere marcati con final, strictfp, or native
- un interfaccia può estendere una o più interfacce
- un interfaccia non può estendere nient'altro che un interfaccia
- un interfacci non può implementare un altra interfaccia o una classe
public abstract interface Rollable { }
È legale scrivere così anche se è ridondante, conviene omettere la keyword abstract. Il public è richiesto per l'interfaccia se si vuole avere un accesso di tipo public invece che quello di default. Metterlo invece nei metodi è ridondante
Declaring Interface Constants
Dichiarare una costante in un interfaccia se si vuole che questa sia sempre la stessa in tutte le classi che estendano l'interfaccia. Una costante è sempre public & static & final anche se non viene indicato. Ovviamente non può essere sovrascritta nell'implementazione.
interface Foo { int BAR = 42; void go(); }
Declare Class Members (Objectives 1.3 and 1.4)
Questo paragrafo si divide in:
- Access Modifiers
- Nonaccess Member Modifiers
- Constructor Declarations
- Variable Declarations
- Declaring Enums
Access Modifiers
Una classe può usare solo public o default come modificatore, un membro invece può usarli tutti e 4 public, private, protected, default (quando non si specifica altrimenti).
Default e protected sono quasi identiche tranne per un comportamento che vedremo dopo.
Public Members
Quando si accede a un membro di una classe senza utilizzare come prefisso l'operatore . vuol dire che si accede usando this. perché è un metodo della stessa classe. Quando si utilizzano metodi della stessa classe o della classe ereditata non è necessario mettere prefisso, alcune volte si usa ugualmente this. per facilitare la lettura del codice.
Private Members
Se proviamo ad accedere a un membro privato di una classe otterremo a compilazione uqesto errore cannot find symbol . Rimane inaccessibile anche per le classi che ereditano.
Si possono definire variabili public ma è sconsigliato conviene definirle sempre private e protected e accedervi tramite dei metodi accessori di tipo pubblic (come già visto nei bean con quella sintassi isNome setNome getNome).
Un metodo privato non può essere override da una sottoclasse perchè non viene visto da questa. Se si definisce un metodo con lo stesso nome non segue le regole dell'override.
Protected and Default Members
La differenza tra i due sta in questo.
Con default si può accedere al membro della superclasse solo se è definita nello stesso package della sottoclasse. Al contrario se si accede un membro protected della superclasse si può accedervi indipendentemente dal package.
È importante capire che per accedere ai membri protected si deve passare attraverso l'ereditarietà. Per esempio se una sottoclasse eredita la superclasse e poi al suo interno utilizza una istanza della superclasse e prova ad accedere a un membro protected riceverà un errore perchè non sta passando attraverso l'ereditarietà.
Protected Details
C'è un esempio di quello appena detto.
Default Details
Se un membro è senza modificatore sarà possibile accedervi solo da classi definite nello stesso package per tutte le altre il membro è come se fosse private.
Local Variables and Access Modifiers
Non si possono applicare modificatori a variabili locali eccetto che il modificatore final.
Sotto una tabella riassuntiva utile
Nonaccess Member Modifiers
continuare da pag 39
