Latest web development tutorials

des objets et des classes Java

Java comme un langage orienté objet. Il prend en charge les concepts de base suivants:

  • polymorphisme
  • hériter
  • paquet
  • résumé
  • catégorie
  • Objets
  • Exemples
  • manière
  • Surchargé

Dans cette section, nous nous concentrons sur le concept des objets et des classes.

  • Objet: L'objet est une instance d'une classe (objet est de ne pas trouver une petite amie), il y a état et le comportement. Par exemple, un chien est un objet dont les états sont: la couleur, le nom, la race, le comportement: remuant la queue, appelé, manger et ainsi de suite.
  • Classe: La classe est un modèle qui décrit le comportement d'une classe d'objets et de statut.

Les garçons et les filles sous la figure de la classe, et spécifiques à chaque classe d'objets artificiels:

Les objets Java

Maintenant, laissez-nous comprendre ce qui est un objet. Regardez autour le monde réel, vous trouverez autour d'un lot d'objets, les voitures, les chiens, les gens, et ainsi de suite. Tous ces objets ont leur propre état et le comportement.

Pour prendre le chien par exemple, il est dit sont: le nom, la race, la couleur, le comportement: appelé, remue sa queue et a couru.

Comparer des objets réels et des objets logiciels sont très similaires entre eux.

Les objets logiciels ont l'état et le comportement. objet logiciel de l'État est d'attribuer le comportement par la méthode d'expression.

Dans le développement de logiciels, appelez l'autre pour changer le mode de fonctionnement de l'état interne d'un objet, l'objet est réalisé par la méthode.

Classes Java

Classe peut être considérée comme un modèle pour créer des objets Java.

En suivant une définition de classe simple à comprendre Java en classe: 

public class Dog{
   String breed;
   int age;
   String color;
   void barking(){
   }
   
   void hungry(){
   }
   
   void sleeping(){
   }
}

Une classe peut contenir les types de variables suivants:

  • Les variables locales: variable dans une méthode, constructeur ou déclaration des définitions de bloc est appelé variables locales. Les variables sont déclarées et initialisées dans le procédé, après la fin du procédé, les variables seront automatiquement détruites.
  • Les variables membres: les variables membres de classe sont définis, la variable en dehors du corps de la méthode. Cette variable est créé lorsque l'objet est instancié. Les variables membres peuvent être consultées dans la classe de bloc de déclaration des méthodes, des constructeurs et des méthodes d'une classe particulière.
  • Les variables de classe: variables de classe déclarées dans une classe, une méthode autre que le corps, mais doivent être déclarés comme type statique.

Une classe peut avoir plusieurs méthodes, dans l'exemple ci-dessus: aboyer (), faim () et de dormir () sont la classe Dog.

constructeur

Chaque classe a un constructeur. Si vous ne définissez pas explicitement le constructeur de la classe, le compilateur Java fournira un constructeur par défaut pour la classe.

Création d'un objet, au moins, d'être appelé un constructeur. Le nom du constructeur doit être le même nom que la classe, une classe peut avoir plusieurs constructeurs.

Voici un exemple du constructeur: 

public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
      // 这个构造器仅有一个参数：name
   }
}

Créer un objet

Les objets sont créés sur la base de la classe. En Java, utilisez le mot-clé new pour créer un nouvel objet. Créer un objet nécessite les trois étapes suivantes:

  • Avertissement: déclarer un objet, y compris le nom de l' objet et le type d'objet.
  • Exemples: le nouveau mot - clé pour créer un objet.
  • Initialisation: Créer un nouvel objet à l' aide du constructeur par défaut pour initialiser l'objet sera appelé.

Voici un exemple de création d'un objet: 

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("Passed Name is :" + name ); 
   }
   public static void main(String []args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

Compiler et exécuter le programme ci-dessus permet d'imprimer les résultats suivants: 

Passed Name is :tommy

variables et méthodes d'instance d'accès

Pour accéder aux variables membres et des méthodes de membres à travers un objet a été créé, comme suit: 

/* 实例化对象 */
ObjectReference = new Constructor();
/* 访问其中的变量 */
ObjectReference.variableName;
/* 访问类中的方法 */
ObjectReference.MethodName();

Exemples

L'exemple suivant montre comment accéder aux variables d'instance et les méthodes membres d'appel: 

public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("Passed Name is :" + name ); 
   }

   public void setAge( int age ){
       puppyAge = age;
   }

   public int getAge( ){
       System.out.println("Puppy's age is :" + puppyAge ); 
       return puppyAge;
   }

   public static void main(String []args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("Variable Value :" + myPuppy.puppyAge ); 
   }
}

Compiler et exécuter le programme ci-dessus donne les résultats suivants: 

Passed Name is :tommy
Puppy's age is :2
Variable Value :2

règles de déclaration du fichier source

Dans la dernière partie de cette section, nous allons apprendre les règles déclarent le fichier source. Lorsque vous définissez plusieurs classes dans un seul fichier source, et il y a des déclarations d'importation et la déclaration de forfait, accorder une attention particulière à ces règles.

  • Un fichier source peut avoir qu'une seule classe publique
  • Un fichier source peut avoir plusieurs classes non publiques
  • Le nom du fichier source et le nom de classe public class devraient être compatibles. Par exemple: nom de classe dans le fichier source public class est employé, le fichier source doit être nommé Employee.java.
  • Si une classe est définie dans un paquet, l'instruction package doit être la première ligne du fichier source.
  • Si le fichier source contenant la déclaration d'importation, la déclaration doit être placé entre les définitions de paquet et de classe. S'il n'y a pas de déclaration de l'emballage, des instructions d'importation devraient être avant tout dans le fichier source.
  • importation déclarations et les déclarations de toutes les classes définies dans le fichier source de paquets sont valides. Dans le même fichier source, et non pas aux différentes classes de différents énoncé des paquets.

Il y a plusieurs niveaux de classe d'accès, et la classe peuvent être divisés en différents types: les classes abstraites et les classes finales et similaires. Ceux-ci sont décrits dans la section de contrôle d'accès.

En plus des types mentionnés ci-dessus, Java il y a quelques catégories spéciales, telles que: les classes internes, classes anonymes.

package Java

Package est principalement utilisé pour classer les classes et les interfaces. Lorsque vous développez un programme Java pourrait écrire des centaines de classes, il est donc nécessaire de classer les classes et les interfaces.

importation Déclaration

En Java, si on leur donne un nom complet, y compris le nom du paquet, le nom de la classe, le compilateur Java peut facilement localiser le code source ou de la catégorie. déclaration d'importation est utilisé pour fournir un chemin raisonnable, de sorte que le compilateur peut trouver une classe.

Par exemple, la commande du compilateur de ligne de commande suivante va charger toutes les classes java_installation / java / path io de 

import java.io.*;

Un exemple simple

Dans cet exemple, nous créons deux classes: employés et EmployeeTest.

Tout d'abord, ouvrez un éditeur de texte pour coller le code suivant dedans. Remarque Enregistrez le fichier en tant Employee.java.

classe d'employés a quatre variables membres: nom, âge, désignation et de salaire. Classe déclarer explicitement une méthode constructeur, qui est un seul paramètre. 

import java.io.*;
public class Employee{
   String name;
   int age;
   String designation;
   double salary;
   // Employee 类的构造器
   public Employee(String name){
      this.name = name;
   }
   // 设置age的值
   public void empAge(int empAge){
      age =  empAge;
   }
   /* 设置designation的值*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* 设置salary的值*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* 打印信息 */
   public void printEmployee(){
      System.out.println("Name:"+ name );
      System.out.println("Age:" + age );
      System.out.println("Designation:" + designation );
      System.out.println("Salary:" + salary);
   }
}

L'exécution du programme commence à partir de la méthode principale. Pour exécuter le programme, et doit contenir une méthode principale crée une instance d'un objet.

Voici la classe EmployeeTest, instancier deux instances de la classe des employés, et appeler la méthode pour définir la valeur de la variable.

Le code suivant est enregistré dans le fichier EmployeeTest.java. 

import java.io.*;
public class EmployeeTest{

   public static void main(String args[]){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("James Smith");
      Employee empTwo = new Employee("Mary Anne");

      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("Senior Software Engineer");
      empOne.empSalary(1000);
      empOne.printEmployee();

      empTwo.empAge(21);
      empTwo.empDesignation("Software Engineer");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

Compiler les deux fichiers et exécuter la classe EmployeeTest, vous pouvez voir les résultats suivants: 

C :> javac Employee.java
C :> vi EmployeeTest.java
C :> javac  EmployeeTest.java
C :> java EmployeeTest
Name:James Smith
Age:26
Designation:Senior Software Engineer
Salary:1000.0
Name:Mary Anne
Age:21
Designation:Software Engineer
Salary:500.0