Maison > Article > Java > La dernière méthode de distinction entre les classes et les objets en Java, supprimez-la maintenant.

La dernière méthode de distinction entre les classes et les objets en Java, supprimez-la maintenant.

php是最好的语言original: 2018-07-24 09:40:351438parcourir

En tant que passionné de Java senior, j'ai spécialement résumé ce document, et j'espère que le partager pourra aider tout le monde. Après l'avoir lu, vous n'êtes toujours pas clair sur les objets et les classes ? L'objet ici ne recherche pas de petite amie, c'est une instance d'une classe, avec un état et un comportement, et une classe est un modèle qui décrit le comportement et l'état d'un type d'objet ;

Objets et classes Java

Java est un langage orienté objet. Prend en charge les concepts de base suivants :

Polymorphisme
Héritage
Encapsulation
Résumé
Classe
Objet
Instance
Méthodes
Surcharge

Dans cette section, nous nous concentrons sur les concepts d'objets et de classes.

Objet : L'objet est une instance d'une classe (L'objet n'est pas Trouver une petite amie), a un état et un comportement. Par exemple, un chien est un objet. Son statut comprend : sa couleur, son nom et sa race ; ses comportements incluent : remuer la queue, aboyer, manger, etc.
Classe : Une classe est un modèle qui décrit le comportement et l'état d'une classe d'objets.

Dans l'image ci-dessous, les garçons et les filles sont des classes, et chaque personne spécifique est un objet de la classe :

Objets Java dans

Voyons maintenant ce qu'est un objet. Si vous regardez le monde réel qui vous entoure, vous constaterez qu'il y a de nombreux objets autour de vous, comme des voitures, des chiens, des personnes, etc. Tous ces objets ont leur propre état et comportement.

Prenons l'exemple d'un chien. Son statut comprend : son nom, sa race et sa couleur. Ses comportements incluent : aboyer, remuer la queue et courir.

Comparez les objets réels et les objets logiciels, ils sont très similaires.

Les objets logiciels ont également un état et un comportement. L'état d'un objet logiciel est son attribut et son comportement se reflète à travers les méthodes.

Dans le développement de logiciels, les méthodes opèrent sur les changements dans l'état interne des objets, et les appels mutuels entre les objets sont également effectués via des méthodes.

Classes en Java

Les classes peuvent être considérées comme des modèles pour créer des objets Java.

Comprendre la définition d'une classe en Java à travers la classe simple suivante :

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

Une classe peut contenir les variables de type suivantes :

Variables locales : Les variables définies dans les méthodes, les constructeurs ou les blocs d'instructions sont appelées variables locales. La déclaration et l'initialisation des variables sont toutes dans les méthodes. Une fois la méthode terminée, les variables seront automatiquement détruites.
Variables membres : Les variables membres sont des variables définies dans la classe et en dehors du corps de la méthode. Ces variables sont instanciées lors de la création de l'objet. Les variables membres sont accessibles par les méthodes, les constructeurs et les blocs d'instructions d'une classe spécifique.
Variable de classe : Les variables de classe sont également déclarées dans la classe, en dehors du corps de la méthode, mais doivent être déclarées comme type statique.

Une classe peut avoir plusieurs méthodes : barking(), faim() et sleep() sont toutes des méthodes de la classe Dog.

Méthode constructeur

Chaque classe a une méthode constructeur. Si aucun constructeur n'est explicitement défini pour une classe, le compilateur Java fournira un constructeur par défaut pour la classe.

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

Ce qui suit est un exemple de méthode constructeur :

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

Création d'objets

Les objets sont créés à partir de classes. En Java, utilisez le mot-clé new pour créer un nouvel objet. La création d'un objet nécessite les trois étapes suivantes :

Déclaration : Déclarez un objet, y compris le nom de l'objet et le type d'objet.
Instanciation : Utilisez le mot-clé new pour créer un objet.
Initialisation : Lors de l'utilisation de new pour créer un objet, la méthode constructeur est appelée pour initialiser l'objet.

Ce qui suit est un exemple de création d'un objet :

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

Compilez et exécutez le programme ci-dessus, les résultats suivants seront imprimés :

小狗的名字是 : tommy

Accéder aux variables et méthodes d'instance

Accéder aux variables membres et aux méthodes membres via l'objet créé, comme indiqué ci-dessous :

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

Instance

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

public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
 
   public void setAge( int age ){
       puppyAge = age;
   }
 
   public int getAge( ){
       System.out.println("小狗的年龄为 : " + puppyAge ); 
       return puppyAge;
   }
 
   public static void main(String []args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("变量值 : " + myPuppy.puppyAge ); 
   }
}

Compilez et exécutez le programme ci-dessus pour produire les résultats suivants :

小狗的名字是 : tommy
小狗的年龄为 : 2
变量值 : 2

Règles de déclaration du fichier source

Dans la dernière partie de cette section, nous apprendrons les règles de déclaration des fichiers sources. Portez une attention particulière à ces règles lors de la définition de plusieurs classes dans un fichier source et lorsqu'il existe des instructions d'importation et des instructions de package.

Il ne peut y avoir qu'une seule classe publique dans un fichier source
Un fichier source peut avoir plusieurs classes non publiques
Le nom du fichier source doit être cohérent avec le nom de la classe publique. Par exemple : le nom de la classe publique dans le fichier source est Employee, alors le fichier source doit être nommé Employee.java.
Si une classe est définie dans un package, l'instruction du package doit figurer sur la première ligne du fichier source.
Si le fichier source contient une instruction d'importation, elle doit être placée entre l'instruction du package et la définition de la classe. S'il n'y a pas d'instruction package, l'instruction import doit figurer en premier dans le fichier source.
import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

类有若干种访问级别，并且类也分不同的类型：抽象类和final类等。这些将在访问控制章节介绍。

除了上面提到的几种类型，Java还有一些特殊的类，如：内部类、匿名类。

Java包

包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

Import语句

在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

例如，下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类

import java.io.*;

Employee.java 文件代码：
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 );
      System.out.println("年龄:" + age );
      System.out.println("职位:" + designation );
      System.out.println("薪水:" + salary);
   }
}

程序都是从main方法开始执行。为了能运行这个程序，必须包含main方法并且创建一个实例对象。

下面给出EmployeeTest类，该类实例化2个 Employee 类的实例，并调用方法设置变量的值。

将下面的代码保存在 EmployeeTest.java文件中。

EmployeeTest.java 文件代码：
import java.io.*;
public class EmployeeTest{
 
   public static void main(String []args){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("RUNOOB1");
      Employee empTwo = new Employee("RUNOOB2");
 
      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("高级程序员");
      empOne.empSalary(1000);
      empOne.printEmployee();
 
      empTwo.empAge(21);
      empTwo.empDesignation("菜鸟程序员");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

编译这两个文件并且运行 EmployeeTest 类，可以看到如下结果：

$ javac EmployeeTest.java
$ java EmployeeTest 
名字:RUNOOB1
年龄:26
职位:高级程序员
薪水:1000.0
名字:RUNOOB2
年龄:21
职位:菜鸟程序员
薪水:500.0

Articles Liés

Voir plus