Objets et classes Java

Javaen tant que Langage orienté objet. Les concepts de base suivants sont pris en charge :

Héritage
Forfait
Résumé
Cours
Objet
Instance
Méthode
Recharger

Dans cette section, nous nous concentrons sur les concepts de objets et classes :

Objet : L'objet est une instance de la 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 : la couleur, le nom, la race ; les comportements incluent : remuer la queue, aboyer, manger, etc.
Classe : Une classe est un modèle qui décrit le comportement et le statut d'une classe de objets.

Objets en Java

Maintenant, passons regardez de plus près 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, et 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 des méthodes.

Dans le développement logiciel, 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.
public class Dog{
   String breed; 
   int age;
   String color;  //颜色  
   public void barking(){
   }  
   public void hungry(){
   }  
   public void sleeping(){
   }
}
Copier après la connexion
Une classe peut contenir des variables des types suivants :

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 : La variable de classe est également déclarée dans la classe, en dehors du corps de la méthode, mais doit être déclaré comme type statique.

Une classe peut avoir plusieurs méthodes, dans ce qui précède. l'exemple : 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 Yang{
    public Yang(){
    }
 
    public Yang(String name){
        // 这个构造器仅有一个参数：name
    }
}
Copier après la connexion

创建对象

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。

下面是一个创建对象的例子：
public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String []args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}
Copier après la connexion
编译并运行上面的程序，会打印出下面的结果：
小狗的名字是 : tommy
Copier après la connexion

访问实例变量和方法

通过已创建的对象来访问成员变量和成员方法，如下所示：
/* 实例化对象 */
ObjectReference = new Constructor();
/* 访问其中的变量 */
ObjectReference.variableName;
/* 访问类中的方法 */
ObjectReference.MethodName();
Copier après la connexion

实例

下面的例子展示如何访问实例变量和调用成员方法：

public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   
   public void setAge( int age ){//get set
       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 ); 
   }
}

Copier après la connexion

编译并运行上面的程序，产生如下结果：

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

Copier après la connexion

源文件声明规则

在本节的最后部分，我们将学习源文件的声明规则。当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

一个源文件中只能有一个public类
一个源文件可以有多个非public类
源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
如果一个类定义在某个包中，那么package语句应该在源文件的首行。
如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

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

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

Java包

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

Import语句

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

例如，下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类
import java.io.*;
Copier après la connexion

一个简单的例子

在该例子中，我们创建两个类：Employee 和 EmployeeTest。

首先打开文本编辑器，把下面的代码粘贴进去。注意将文件保存为 Employee.java。

Employee类有四个成员变量：name、age、designation和salary。该类显式声明了一个构造方法，该方法只有一个参数。
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);
   }
}
Copier après la connexion
程序都是从main方法开始执行。为了能运行这个程序，必须包含main方法并且创建一个实例对象。
下面给出EmployeeTest类，该类实例化2个 Employee 类的实例，并调用方法设置变量的值。
将下面的代码保存在 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();
   }
}
Copier après la connexion
编译这两个文件并且运行 EmployeeTest 类，可以看到如下结果：
$ javac-> EmployeeTest.java
$ java-> EmployeeTest 名字:RUNOOB1年龄:26职位:高级程序员薪水:1000.0名字:RUNOOB2年龄:21职位:菜鸟程序员薪水:500.0
Copier après la connexion