En Java, le classe est un plan à partir duquel nous pouvons créer un objet individuel. Java fournit un mot-clé classe nommée par laquelle nous pouvons déclarer une classe. A l'intérieur de la classe, nous définissons classe membres et fonctions. Il n'est pas possible de créer Programmes Java sans classe. Nous pouvons également désigner une classe comme un défini par l'utilisateur Types de cours
Il existe sept types de classes en Java :
Classe statique
Nous pouvons faire un cours statique si et seulement s'il s'agit d'une classe imbriquée. On peut également dire que les classes statiques sont appelées classes imbriquées. Cela signifie qu’une classe déclarée comme statique dans une autre classe est appelée classe statique. La classe statique imbriquée ne nécessite pas de référence à la classe externe. Le but d’une classe statique est de fournir les grandes lignes de sa classe héritée.
Les propriétés de la classe statique sont :
- La classe n'a que des membres statiques.
- Il ne peut pas accéder au membre (non statique) de la classe externe.
- Nous ne pouvons pas créer un objet de la classe statique.
Comprenons le concept de classe statique à travers un programme.
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(); } } Sortir:
Javatpoint
Dans la classe externe du programme ci-dessus, nous avons déclaré une variable str comme statique car nous accédons à cette variable à partir d'un contexte statique. Si nous déclarons cette variable comme non statique, le compilateur affiche une erreur car une classe statique imbriquée ne peut pas accéder aux membres non statiques de la classe externe.
La deuxième chose à remarquer dans le programme ci-dessus est que pour créer l'objet de la classe imbriquée, nous n'avons pas besoin de créer une instance de la classe externe. Si la classe imbriquée n'est pas une classe statique, nous devons créer une instance de la classe externe.
Classe finale
Le mot final signifie que cela ne peut pas être modifié. Le final la classe en Java peut être déclarée en utilisant le mot-clé final . Une fois que nous déclarons une classe comme finale, les valeurs restent les mêmes tout au long du programme. Le but du cours final est de faire en sorte que le cours immuable comme la classe String. C'est seulement un moyen de rendre la classe immuable. N'oubliez pas que le Le cours final ne peut pas être prolongé . Ça aussi empêche la classe d'être sous-classée .
Comprenons le concept du cours final à travers un programme.
normalisation rdbms
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(); } } Sortir:
/FinalClassExample.java:11: error: cannot inherit from final A class B extends A
Classe abstraite
Un classe abstraite est un qui est déclaré avec le mot-clé abstrait . La classe peut contenir ou non des méthodes abstraites. Nous ne pouvons pas créer une instance d'une classe abstraite mais il peut s'agir d'une sous-classe. Ces classes sont incomplètes, donc pour compléter la classe abstraite, nous devons étendre les classes abstraites à une classe concrète. Lorsque nous déclarons une sous-classe comme abstraite alors il est nécessaire de prévoir l'implémentation de méthodes abstraites. Par conséquent, la sous-classe doit également être déclarée abstraite. Nous pouvons masquer les données en utilisant la classe abstraite. Un exemple de classe abstraite est Carte abstraite classe qui fait partie du framework Collections.
Comprenons le concept de classe abstraite à travers un programme.
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(); } } Sortir:
Sum of a and b is: 70
Classe de béton
Ce sont les classes Java habituelles. Une classe dérivée qui fournit les implémentations de base pour toutes les méthodes qui ne sont pas déjà implémentées dans la classe de base est appelée classe dérivée. béton classe. En d’autres termes, il s’agit de classes Java classiques dans lesquelles toutes les méthodes d’une classe abstraite sont implémentées. Nous pouvons créer directement un objet de la classe concrète. N'oubliez pas que la classe concrète et la classe abstraite ne sont pas identiques. Une classe concrète peut étendre sa classe parent. Il est utilisé pour des besoins spécifiques.
Comprenons le concept de classe concrète à travers un programme.
ConcreteClassExample.java
la chaîne java contient
//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); } } Sortir:
Product of a and b is: 48
Classe Singleton
Une classe qui n'a qu'un objet à la fois est appelée une classe unique . Néanmoins, si nous essayons de créer une instance une deuxième fois, cette instance nouvellement créée pointe vers la première instance. Si nous apportons une modification à l’intérieur de la classe via n’importe quelle instance, la modification affecte également la variable de l’instance unique. Il est généralement utilisé pour contrôler l’accès lors de la gestion de la connexion à la base de données et de la programmation des sockets. Si nous voulons créer une classe singleton, procédez comme suit :
- Créer un privé constructeur .
- Créez une méthode statique (en utilisant l'initialisation paresseuse) qui renvoie l'objet de la 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; } } Sortir:
Javatpoint
Cours POJO
En Java, POJO signifie Ancien objet Java simple. Une classe Java qui contient uniquement des variables privées, un setter et un getter est appelée POJO classe. Il est utilisé pour définir des objets Java qui augmentent la réutilisabilité et la lisibilité d'un programme Java. La classe fournit l'encapsulation. Il est largement utilisé en Java car il est facile de comprendre ces classes. La classe POJO a les propriétés suivantes :
- Il n'étend pas les classes prédéfinies telles que Arrays, HttpServlet, etc.
- Il ne peut pas contenir d'annotations prédéfinies.
- Il ne peut pas implémenter des paramètres prédéfinis interfaces .
- Il n’est pas nécessaire d’ajouter un constructeur.
- Toutes les variables d'instance doivent être privées.
- Le getter/setter méthodes doit être public.
Comprenons le concept de classe POJO à travers un programme 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.'); } } Sortir:
The price of an article is 89764.34 Rs.
Classe interne
Java nous permet de définir une classe au sein d'une classe et ces classes sont appelées classes imbriquées . Il sert à regrouper logiquement les classes et à réaliser encapsulation . Les membres de la classe externe (y compris privés) sont accessibles par le classe intérieure . La syntaxe générale de déclaration de la classe imbriquée est la suivante :
class OuterClass { //code class NestedClass { //code } } Les classes imbriquées sont de deux types :
1. Classe imbriquée statique : Une classe qui est statique et imbriqué est appelé une classe imbriquée statique . Il interagit avec le membre d'instance de sa classe externe. Nous pouvons créer un objet de la classe imbriquée statique en utilisant la syntaxe suivante :
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
2. Classe imbriquée non statique : Les classes imbriquées non statiques sont appelées classes intérieures .
La syntaxe générale pour déclarer la classe imbriquée statique et la classe interne est la suivante :
class OuterClass { ... static class StaticNestedClass { ... } class InnerClass { ... } } Comprenons le concept de classe interne à travers un programme Java.
InnerClassExample.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.'); } } } Types de classes internes
Java fournit les deux types de classes internes suivantes :
- Classes locales ou méthode Classe interne locale
- Cours anonymes ou Classe interne anonyme
Classe interne locale
C'est un type de classe interne définie à l'intérieur d'un bloc. Ici, block désigne un corps de méthode (un groupe d'instructions entouré d'une paire d'accolades). En raison de la définition à l’intérieur d’un bloc, elle est également connue sous le nom de classe interne locale de méthode. Ce sont des classes non statiques car elles peuvent accéder aux membres d'instance du bloc. Nous pouvons définir les classes internes locales dans le corps d'une méthode. Ces classes doivent être instanciées dans le bloc dans lequel elles sont définies.
Lorsque nous compilons un programme Java (un programme qui contient une classe interne), le compilateur génère les deux fichiers de classe à savoir Classe.extérieure et Classe externe 1 $ Inner. Un pour la classe externe et l’autre pour la classe interne qui contient une référence à la classe externe.
Comprenons le concept de classe interne locale via un programme Java.
ClasseExterne.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(); } } Sortir:
Divisor = 4 Remainder = 0 We are inside the inner class Quotient = 5
Classe interne anonyme
Il s'agit d'un type de classe interne identique aux classes locales, mais la seule différence est que la classe n'a pas de nom de classe et qu'un seul objet est créé à partir de la classe. Cela rend le code plus concis. Il est utilisé si nous voulons utiliser la classe locale une fois. Nous pouvons créer des classes anonymes des deux manières suivantes :
- En utilisant une interface
- En déclarant la classe concrète et abstraite
Syntaxe:
pas de signal d'entrée
// the class may an interface, abstract or concrete class DemoClass obj = new DemoClass() { //methods //data members public void demomethod() { //statements } }; En regardant la syntaxe ci-dessus, nous voyons que c'est la même chose que l'invocation d'un constructeur sauf que la classe a une définition contenue dans le bloc.
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(); } } Sortir:
Score is 321
Java fournit également un autre type de classe Java appelé classe wrapper. Discutons-en en détail.
Classe d'emballage
En Java, le terme classe d'emballage représente une collection de classes Java qui objectivent le type primitif de Java. Cela signifie que pour chaque type primitif, il existe une classe wrapper correspondante. Les classes wrapper sont utilisées pour effectuer la conversion d’un type primitif en objet et vice versa. La figure suivante illustre la hiérarchie des classes wrapper.
Le tableau suivant représente le type primitif et la classe wrapper correspondante.
| Type primitif | Classe d'emballage |
|---|---|
| booléen | Booléen |
| int | Entier |
| carboniser | Personnage |
| double | Double |
| flotter | Flotter |
| long | Long |
| octet | Octet |
| court | Court |
Comprenons la classe wrapper via un programme 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); } } Sortir:
Byte object byteobj: 0 Integer object intobj: 23 Character object charobj: m