In Giava, il classe è un progetto da cui possiamo creare un singolo oggetto. Java fornisce a parola chiave classe denominata con la quale possiamo dichiarare una classe. All'interno della classe definiamo classe membri e funzioni. Non è possibile creare Programmi Java senza classe. Possiamo anche riferirci ad una classe come a definito dall'utente Tipi di classi
In Java esistono sette tipi di classi:
Classe statica
Possiamo fare una lezione statico se e solo se è una classe annidata. Possiamo anche dire che le classi statiche sono conosciute come classi nidificate. Significa che una classe dichiarata come statica all'interno di un'altra classe è nota come classe statica. La classe statica nidificata non richiede riferimento alla classe esterna. Lo scopo di una classe statica è fornire la struttura della sua classe ereditata.
Le proprietà della classe statica sono:
- La classe ha solo membri statici.
- Non può accedere al membro (non statico) della classe esterna.
- Non possiamo creare un oggetto della classe statica.
Capiamo il concetto di classe statica attraverso un programma.
programmazione cobol
StaticClassExample.java
public class StaticClassExample { private static String str = 'Javatpoint'; //nested class which is a Static class public static class StaticDemo { //non-static method of Static class public void show() { System.out.println(str); } } public static void main(String args[]) { StaticClassExample.StaticDemo obj = new StaticClassExample.StaticDemo(); obj.show(); } } Produzione:
Javatpoint
Nella classe esterna del programma precedente, abbiamo dichiarato una variabile stra come statico perché stiamo accedendo a quella variabile da un contesto statico. Se dichiariamo quella variabile come non statica, il compilatore mostra un errore perché una classe statica nidificata non può accedere ai membri non statici della classe esterna.
La seconda cosa da notare nel programma sopra è che per creare l'oggetto della classe nidificata non è necessario creare un'istanza della classe esterna. Se la classe nidificata non è una classe statica, dobbiamo creare un'istanza della classe esterna.
Lezione finale
La parola finale significa che non può essere modificata. IL finale La classe in Java può essere dichiarata utilizzando il file parola chiave finale . Una volta dichiarata una classe come finale, i valori rimangono gli stessi in tutto il programma. Lo scopo della lezione finale è creare la lezione immutabile come la classe String. È solo un modo per rendere immutabile la classe. Ricorda che il la lezione finale non può essere estesa . Anche impedisce che la classe venga sottoclassata .
Comprendiamo il concetto della lezione finale attraverso un programma.
FinalClassExample.java
//base class declared as final final class A { void printmsg() { System.out.print('Base class method is executed.'); } } //derived class //extending a final class which is not possible //it shows the error cannot inherit final class at compile time class B extends A { void printmsg() { System.out.print('Derived class method is executed.'); } } //main class public class FinalClassExample { public static void main(String[] arg) { B obj = new B(); obj.printmsg(); } } Produzione:
/FinalClassExample.java:11: error: cannot inherit from final A class B extends A
Classe astratta
UN classe astratta è un oggetto dichiarato con la parola chiave astratto . La classe può contenere o meno metodi astratti. Non possiamo creare un'istanza di una classe astratta ma può essere una sottoclasse. Queste classi sono incomplete, quindi per completare la classe astratta dovremmo estendere le classi astratte a una classe concreta. Quando dichiariamo una sottoclasse astratta allora è necessario prevedere l'implementazione di metodi astratti. Pertanto anche la sottoclasse deve essere dichiarata astratta. Possiamo ottenere l'occultamento dei dati utilizzando la classe astratta. Un esempio di classe astratta è AbstarctMap classe che fa parte del framework Collections.
Comprendiamo il concetto di classe astratta attraverso un programma.
AbstractClassExample.java
//abstract class abstract class MathematicalOperations { int a=30, b=40; //abstract method public abstract void add(); } public class Operation extends MathematicalOperations { //definition of abstract method public void add() { System.out.println('Sum of a and b is: 'a+b); } public static void main(String args[]) { MathematicalOperations obj = new Operation(); obj.add(); } } Produzione:
Sum of a and b is: 70
Classe concreta
Queste sono le normali classi Java. Una classe derivata che fornisce le implementazioni di base per tutti i metodi che non sono già implementati nella classe base è nota come a calcestruzzo classe. In altre parole, si tratta di normali classi Java in cui sono implementati tutti i metodi di una classe astratta. Possiamo creare direttamente un oggetto della classe concreta. Ricorda che la classe concreta e la classe astratta non sono la stessa cosa. Una classe concreta può estendere la sua classe genitore. Viene utilizzato per esigenze specifiche.
Comprendiamo il concetto di classe concreta attraverso un programma.
ConcreteClassExample.java
elenco in Java
//Concrete Class public class ConcreteClassExample { //method of the concreted class static int product(int a, int b) { return a * b; } public static void main(String args[]) { //method calling int p = product(6, 8); System.out.println('Product of a and b is: ' + p); } } Produzione:
Product of a and b is: 48
Classe Singleton
Una classe che ha solo un oggetto alla volta è conosciuta come a classe singleton . Tuttavia, se stiamo tentando di creare un'istanza una seconda volta, l'istanza appena creata punta alla prima istanza. Se apportassimo qualche modifica all'interno della classe attraverso una qualsiasi istanza, la modifica influenzerebbe anche la variabile della singola istanza. Di solito viene utilizzato per controllare l'accesso mentre si gestisce la connessione al database e la programmazione del socket. Se vogliamo creare una classe singleton, procediamo come segue:
- Crea un privato costruttore .
- Creare un metodo statico (utilizzando l'inizializzazione lazy) che restituisca l'oggetto della classe singleton.
SingletonClassExample.java
public class Singleton { private String objectState; private static Singleton instance = null; private Singleton() throws Exception { this.objectState = 'Javatpoint'; } public static Singleton getInstance() { if(instance==null) { try { instance=new Singleton(); } catch(Exception e) { e.printStackTrace(); } } return instance; } public String getObjectState() { return objectState; } public void setObjectState(String objectState) { this.objectState = objectState; } } Produzione:
Javatpoint
Classe POJO
In Java, POJO sta per Vecchio oggetto Java semplice. Una classe Java che contiene solo variabili private, setter e getter è nota come POJO classe. Viene utilizzato per definire oggetti Java che aumentano la riusabilità e la leggibilità di un programma Java. La classe fornisce l'incapsulamento. È ampiamente utilizzato in Java perché è facile comprendere queste classi. La classe POJO ha le seguenti proprietà:
- Non estende le classi predefinite come Arrays, HttpServlet, ecc.
- Non può contenere annotazioni predefinite.
- Non può implementare valori predefiniti interfacce .
- Non è necessario aggiungere alcun costruttore.
- Tutte le variabili di istanza devono essere private.
- Il getter/setter metodi deve essere pubblico.
Capiamo il concetto di classe POJO attraverso un programma Java.
PojoClassExample.java
class PojoDemo { //private variable private double price=89764.34; //getter method public double getPrice() { return price; } //setter method public void setPrice(int price) { this.price = price; } } //main class public class PojoClassExample { public static void main(String args[]) { PojoDemo obj = new PojoDemo(); System.out.println('The price of an article is '+ obj.getPrice()+' Rs.'); } } Produzione:
parametri predefiniti di Java
The price of an article is 89764.34 Rs.
Classe interiore
Java ci consente di definire una classe all'interno di una classe e tali classi sono conosciute come classi annidate . Viene utilizzato per raggruppare le classi in modo logico e per raggiungere incapsulamento . È possibile accedere ai membri della classe esterna (compresi quelli privati) tramite il file classe interiore . La sintassi generale per dichiarare la classe nidificata è la seguente:
class OuterClass { //code class NestedClass { //code } } Le classi nidificate sono di due tipi:
1. Classe nidificata statica: Una classe che lo è statico E nidificato è chiamata classe nidificata statica. Interagisce con il membro istanza della sua classe esterna. Possiamo creare un oggetto della classe nidificata statica utilizzando la seguente sintassi:
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
2. Classe annidata non statica: Vengono chiamate classi nidificate non statiche classi interiori .
La sintassi generale per dichiarare la classe nidificata statica e la classe interna è la seguente:
class OuterClass { ... static class StaticNestedClass { ... } class InnerClass { ... } } Comprendiamo il concetto di classe interna attraverso un programma Java.
EsempioClasseInterna.java
public class InnerClassExample { public static void main(String[] args) { System.out.println('This is outer class.'); } class InnerClass { public void printinner() { System.out.println('This is inner class.'); } } } Tipi di classi interne
Java fornisce i due tipi di classi interne come segue:
- Classi locali o metodo Classe interna locale
- Classi anonime o Classe interna anonima
Classe interna locale
È un tipo di classe interna definita all'interno di un blocco. Qui block denota il corpo del metodo (un gruppo di istruzioni racchiuse tra una coppia di parentesi graffe). A causa della definizione all'interno di un blocco, è anche noto come metodo classe interna locale. Queste sono le classi non statiche perché possono accedere ai membri di istanza del blocco. Possiamo definire le classi interne locali nel corpo di un metodo. Queste classi devono essere istanziate nel blocco in cui sono definite.
Quando compiliamo un programma Java (un programma che contiene una classe interna), il compilatore genera i due file di classe vale a dire Classe.esterna E EsternoInterno.classe. Uno per la classe esterna e l'altro per la classe interna che contiene un riferimento alla classe esterna.
Comprendiamo il concetto di classe interna locale attraverso un programma Java.
OuterClass.java
public class OuterClass { private void getValue() { //if you are using Java 7 make the variable final //if you are using Java 8 the code runs successfully int sum = 20; //declaring method local inner class class InnerClass { public int divisor; public int remainder; public InnerClass() { divisor = 4; remainder = sum%divisor; } private int getDivisor() { return divisor; } private int getRemainder() { return sum%divisor; } private int getQuotient() { System.out.println('We are inside the inner class'); return sum / divisor; } } //creating an instance of inner class InnerClass ic = new InnerClass(); System.out.println('Divisor = '+ ic.getDivisor()); System.out.println('Remainder = ' + ic.getRemainder()); System.out.println('Quotient = ' + ic.getQuotient()); } public static void main(String[] args) { //creating an instance of outer class OuterClass oc = new OuterClass(); oc.getValue(); } } Produzione:
Divisor = 4 Remainder = 0 We are inside the inner class Quotient = 5
Classe interna anonima
È un tipo di classe interna uguale alle classi locali ma l'unica differenza è che la classe non ha un nome di classe e dalla classe viene creato un singolo oggetto. Rende il codice più conciso. Viene utilizzato se vogliamo utilizzare la classe locale una volta. Possiamo creare classi anonime nei due modi seguenti:
- Utilizzando un'interfaccia
- Dichiarando la classe concreta e astratta
Sintassi:
// the class may an interface, abstract or concrete class DemoClass obj = new DemoClass() { //methods //data members public void demomethod() { //statements } }; Osservando la sintassi precedente, vediamo che è uguale all'invocazione del costruttore tranne per il fatto che la classe ha una definizione contenuta nel blocco.
AnonymousClassExample.java
interface Score { int run = 321; void getScore(); } public class AnonymousClassExample { public static void main(String[] args) { // Myclass is hidden inner class of Score interface // whose name is not written but an object to it // is created. Score s = new Score() { @Override public void getScore() { //prints score System.out.print('Score is '+run); } }; s.getScore(); } } Produzione:
Harald Baldr
Score is 321
Java fornisce anche un altro tipo di classe Java nota come classe wrapper. Discutiamolo in dettaglio.
Classe wrapper
In Java, il termine classe involucro rappresenta una raccolta di classi Java che oggettivano il tipo primitivo di Java. Ciò significa che per ogni tipo primitivo esiste una classe wrapper corrispondente. Le classi wrapper vengono utilizzate per eseguire la conversione da un tipo primitivo a un oggetto e viceversa. La figura seguente mostra la gerarchia delle classi wrapper.
La tabella seguente rappresenta il tipo primitivo e la classe wrapper corrispondente.
| Tipo primitivo | Classe wrapper |
|---|---|
| booleano | Booleano |
| int | Numero intero |
| car | Carattere |
| Doppio | Doppio |
| galleggiante | Galleggiante |
| lungo | Lungo |
| byte | Byte |
| corto | Corto |
Comprendiamo la classe wrapper attraverso un programma Java.
WrapperClassExample.java
public class WrapperClassExample { public static void main(String args[]) { byte x = 0; //wrapping byte primitive type into Byte object Byte byteobj = new Byte(x); int y = 23; //wrapping int primitive type into Integer object Integer intobj = new Integer(y); char c='m'; //wrapping char primitive type into Character object Character charobj=c; //printing values from objects System.out.println('Byte object byteobj: ' + byteobj); System.out.println('Integer object intobj: ' + intobj); System.out.println('Character object charobj: ' + charobj); } } Produzione:
Byte object byteobj: 0 Integer object intobj: 23 Character object charobj: m