Introduction à l'apprentissage orienté objet Java

Mots clés : orienté objet, classe, constructeur, this, statique, classe interne

Le concept d'orienté objet : résoudre le problème Le le problème est divisé en plusieurs objets indépendants en installant certaines règles, puis le problème est résolu en appelant la méthode de l'objet. Ses caractéristiques peuvent être résumées comme l’encapsulation, l’héritage et le polymorphisme.

1. Encapsulation : faire face au cœur de l'objet, encapsuler les propriétés et les comportements de l'objet sans que le monde extérieur connaisse les détails spécifiques de la mise en œuvre. C'est l'idée de l'encapsulation.

2. Héritage : Il décrit principalement la relation entre les classes. Grâce à l'héritage, les fonctions de la classe d'origine peuvent être étendues sans réécrire la classe d'origine.

3. Polymorphisme : la duplication de noms est autorisée dans le programme. Cela signifie qu'une fois que les attributs et les méthodes définis dans une classe sont hérités par d'autres classes, ils peuvent avoir des types de données différents ou se comporter différemment. permet aux mêmes propriétés et méthodes d'avoir une sémantique différente dans différentes classes.

2. Classes et objets

1. Une classe est l'abstraction d'un objet Elle est utilisée pour décrire les caractéristiques et les comportements communs d'un groupe d'objets. Les variables membres et les méthodes membres peuvent être définies dans une classe. Les variables membres sont utilisées pour décrire les caractéristiques de l'objet, également appelées attributs, et les méthodes membres sont utilisées pour décrire le comportement de l'objet, qui peuvent être appelées méthodes.

Comment créer une classe :

1 class Person{
2      //定义int 类型的变量
3       int age;
4      //定义speak（）方法
5       void speak （）{
6             System.out.println(“***”)
7       }
8 } //Person 类名，age 是成员变量，speak（）成员方法

2. Création et utilisation des objets :

Création : nom de classe nom d'objet = nouvelle classe name ( ); //Objet d'instance

Utilisation : Object reference.Object member

Lors de l'instanciation d'un objet, la machine virtuelle Java initialise automatiquement les variables membres et attribue différentes valeurs à différentes types de variables membres.

表：成员变量的初始值

成员变量类	初始值	成员变量类	初始值
byte	0	double	0.0D
short	0	char	空字符，‘u0000'
int	0	boolean	false
long	0L	引用数据类型	null
float	0.0F

在Java中，null是一种特殊的常量，当一个变量的值为null时，则表示该变量不指向任何一个对象，变成垃圾被回收。 

 

3、所谓的类的封装是指定义一个类时，将类中的属性私有化，即利用private 关键字来修饰，私有属性只能在它所在类中被访问。为了能让外界访问私有属性，需要提供一些使用public 修饰的公用方法，其中包括用于获得属性值得getXXX（）方法和设置属性值得setXXX（）方法。

 

 1 class Student{
 2     private String name;    //将name属性私有化
 3     private int age;        //将age属性私有化
 4     //下面是公有的getXXX（）和setXXX（）方法
 5     public String getName (){
 6         return name;
 7     }
 8     public void setName(String stuName){
 9         name = stuName ;
10     }
11     public int getAge (){
12         return age ;
13     }
14     public void setAge(int stuAge){
15         //下面是对传入的参数进行检查
16         if(stuAge<=0){
17             System.out.println("年龄不合法");
18         }else {
19             age = stuAge ;        //对属性赋值
20         }
21     }
22     public void introduce(){
23         System.out.println("大家好，我叫"+name+",我今年"+age+"岁!");
24     }
25 }
26 public class Example01{
27     public static void main(String[] args){
28         Student stu  = new Student();
29         stu.setAge(-30);
30         stu.setName("李芳");
31         stu.introduce();
32     }
33 }

 

三、构造方法

1、构造方法：构造方法是类中一个特殊成员，它会在实例化对象时被自动调用。

2、构造方法的特点：

 ①方法名与类名相同；

 ②在方法名前面没有返回值类型的声明；

 ③在方法中不能使用return语句返回一个值；

 1 class Person{
 2       //构造方法
 3      public Person(){
 4           //无参构造方法
 5       }
 6      public Person(int age){
 7           age = a;   //有参构造方法
 8      }
 9      public void speak(){
10           System.out.println(“I am” +age+”years old !");
11      }
12 }
13 public  class Example{
14      public  static void main (String [] args){
15          Person p = new Person(20);  //实例化Person对象
16          p.speak();
17      }
18 }

 

3、构造方法的重载：与普通方法一样，方法名相同，只需要参数类型或参数个数不同即可。

     一般情况下，构造方法通常会使用public来修饰。

 

 

四、this 关键字

1、this关键字三种常用方法：

①通过this关键字可以明确地访问一个类的成员变量，解决与局部变量名称冲突问题。

 1 class Person{
 2      int age ;
 3      public Person(int age){
 4           this.age = age ;   //访问成员变量
 5      }
 6      public int getAge(){
 7          return this .age;
 8     }
 9  }

②通过this关键字调用成员方法。

③构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this（【参数1，参数2……】）”的形式来调用其他的构造方法。

注意点：

①只能在构造方法中使用this 调用其他的构造方法，不能在成员方法中使用。

②在构造方法中，使用this 调用构造方法的语句必须位于第一行，且只能出现一次。

③不能在一个类的两个构造方法中使用this互相调用。

 

五、static关键字

1、使用static关键字来修饰成员变量，该变量被作静态变量。静态变量被所有实例共享，可以使用“类名.变量”的形式来访问。

    注意：static关键字只能用于修饰成员变量，不能用于修饰局部变量。

2、静态方法：在类中定义的方法前加上static关键字，可在不创建对象的情况下调用某方法。可使用“类名.方法名”的形式访问。

     注意：在一个静态方法中只能访问static修饰的成员，静态方法在被调用时可以创建任何对象。

3、静态代码块：用static关键字修饰的代码块称为静态代码块，当类被加载时，静态代码块会被执行，由于类只加载异常，因此静态代码块只能执行一次。

 

4、单例模式：

 1 class Single{
 2      private static Single INSTANCE = new Single();
 3      private Single(){}
 4      public static Single getInstance(){  
 5          return INSTANCE ; 
 6        }
 7 }
 8 //上面单例又可写成以下形式
 9 class Single{
10      private Single(){}
11      public static final Single INSTANCE = new Single()；
       /*变量名INSTANCE的前面有三个修饰符，其中，public的作用是允许外部直接访问该变量，static 的作用是 让外部可以使用
         “类名.变量名“的方式来访问变量，final的作用是禁止外部对该变量进行修改。*/
12 }
13 
14 class Example {
15     public static void main(String[] args){
16          Single s = Single.getInstance();    //   getInstance()方法是获得Single类实例对象的唯一途径，Single 类是一个单例的类    
17      }
18 }

被关键字final修饰的变量为常量,其值不可变。

 

六、内部类：根据内部类的位置、修饰符和定义的方式可分为成员内部类、静态内部类、方法内部类。

1、创建内部类对象的具体语法格式：

    外部类名.内部类名 变量名 = new 外部类名（）.new 内部类（）；

 1 class Outer{
 2     private int num = 4;              //定义类的成员变量
 3     //下面的代码定义了一个成员方法，方法中访问内部类
 4     public void test(){
 5         Inner inner = new Inner();
 6         inner.show();
 7     }
 8     //下面的代码定义了一个成员内部类
 9     class Inner{
10         void show(){
11             //在成员内部类的方法中访问外部类的成员变量
12             System.out.println("num = "+num);
13         }
14     }
15 }
16 public class Example16 {
17     public static void main(String[] args){
18         Outer outer = new Outer();               //创建外部类对象
19         outer.test();                                 //调用test（）方法
20     }
21 }
22 //直接创建内部类对象示例
23 public class Example16 {
24     public static void main(String[] args){
25         Outer.Inner inner = new Outer().Inner() ;               //创建内部类对象
26         inner.show();                                 //调用show（）方法
27     }
28 }
29 //当内部类被声明为私有，外界将无法访问。

2、创建静态内部类对象的具体语法格式：

     外部类名.内部类名 变量名 = new 外部类名.内部类名（）；

 1 class Outer{
 2     private static int num = 6;              //定义类的成员变量
 3     //下面的代码定义了一个静态内部类
 4     static class Inner{
 5         void show(){
 6             System.out.println("num = "+num);
 7         }
 8     }
 9 }
10 public class Example16 {
11     public static void main(String[] args){
12         Out.Inner inner = new Out.Inner();             //创建内部类对象
13             inner.show();                                 //调用内部类的方法
14     }
15 }

     注意：①在静态内部类中只能访问外部类的静态成员。

              ②在静态内部类中可以定义静态成员，而在非静态的内部类中不允许定义静态的成员。

 

3、方法内部类：是指在成员方法中定义的类，它只能在当前方法中被使用。方法内部类可以访问外部类的成员变量。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!