Quelles sont les caractéristiques et l'utilisation de Java orienté objet

La différence entre orienté processus et orienté objet

Orienté processus : lorsque l'événement est relativement simple, utilisez une approche orientée processus, en vous concentrant sur les étapes et les processus spécifiques de l'événement, en vous concentrant sur les comportements spécifiques du processus, en prenant fonctionne comme la plus petite unité, réfléchissez à la façon de le faire.

Orienté objet : concentrez-vous sur la recherche de « participants », encapsulant des fonctions dans des objets, en mettant l'accent sur les objets dotés de fonctions, en prenant la classe/l'objet comme la plus petite unité et en considérant qui le fera.

Cas : Xiao Ming prend quelque chose dans le réfrigérateur

Orienté processus :

Orienté objet :

Orienté processus—> l'exécuteur Transition

La relation entre les classes et les objets

Tout est un objet

Objets : choses spécifiques, entités spécifiques, instances spécifiques, produits spécifiques sous le modèle

Classe : extraire la partie image vers le haut de l'objet, publier la partie, Formez une classe. Une classe est abstraite et un modèle. Généralement, lorsque vous écrivez du code, vous écrivez d'abord la classe, puis créez l'objet correspondant basé sur la classe. instanciation de la classe. Création de classe et d'objet

Création de classe

1. Attributs (variables membres du champ)

Les attributs sont utilisés pour définir les données ou caractéristiques statiques contenues dans cette classe ou objet de cette classe. La portée des attributs correspond à l'ensemble du corps de la classe.

Format de définition d'attribut :

[modificateur] nom d'attribut de type d'attribut = [valeur par défaut];

2 Méthode

La méthode est utilisée pour définir les caractéristiques comportementales et l'implémentation fonctionnelle de cette classe ou instance de cette classe. Les méthodes sont des abstractions des caractéristiques comportementales des classes et des objets. Les méthodes sont très similaires aux fonctions de la programmation orientée procédures. Dans l'orientation processus, la fonction est l'unité la plus basique et l'ensemble du programme est composé d'appels de fonction. En mode orienté objet, l'unité de base de l'ensemble du programme est une classe et les méthodes sont subordonnées aux classes et aux objets.

Format de définition de la méthode :

[Modificateur] Nom de la méthode du type de retour de la méthode (liste formelle des paramètres) {

//Déclaration Java

}

Nous prenons comme exemple la création ci-dessus de la classe de héros King of Glory :

//创建英雄类
public class Hero {
    //属性
    String Name;//英雄姓名
    int Survive;//生存能力
    int Attack;//攻击伤害
    int Skill;//技能效果
    int Difficulty;//上手难度

    //技能
    public void Kill(int number){
        //根据输入的数字释放几技能
        System.out.println(Name+"释放"+number+"技能！！！");
    }
    //输出该英雄的属性
    public void print(){
        System.out.println("英雄："+Name);
        System.out.println("生存能力："+Survive);
        System.out.println("攻击伤害："+Attack);
        System.out.println("技能效果："+Skill);
        System.out.println("上手难度："+Difficulty);
    }

}

Création d'objets

Ensuite, nous créons des objets pour les classes que nous avons créées

public class TestCode01 {
    //main方法，程序的入口
    public static void main(String[] args) {
        //创建一个对象(英雄)-->马克波罗
        Hero make = new Hero();
        make.Name = "马克波罗";
        make.Survive = 4;
        make.Attack = 6;
        make.Skill = 6;
        make.Difficulty = 5;
        //再创建一个英雄-->澜
        Hero lan = new Hero();
        lan.Name = "澜";
        lan.Survive = 3;
        lan.Attack = 5;
        lan.Skill = 4;
        lan.Difficulty = 6;
        lan.Kill(1);
        //输出两个英雄的属性
        make.print();
        System.out.println("-------------");
        lan.print();
        //释放技能
        make.Kill(3);
        System.out.println("-------------");
        lan.Kill(2);
    }
}

Résultat : Chaque héros a les mêmes attributs, et chaque attribut a une valeur différente. Grâce à la classe, nous pouvons créer de nombreux objets, chacun. l'objet a des valeurs d'attribut différentes.

Par exemple : Il y a plus d'une centaine de héros dans King of Kings, chacun avec des caractéristiques différentes.

Le processus de création d'un objet :

(1) Lorsque vous rencontrez une classe pour la première fois, la classe doit être chargée, une seule fois.

(2) Créez un objet et ouvrez de l'espace dans le tas

(3) Initialisez l'objet et les attributions d'attributs sont toutes des valeurs initiales par défaut.

(4) Le mot-clé new appelle le constructeur, exécute la méthode de construction et réaffecte les propriétés dans le constructeur

Constructeur

Les objets sont tous nouveaux. Le nouveau mot-clé appelle en fait une méthode. Cette méthode s'appelle un constructeur (. constructeur)

Lors de l'appel du constructeur, s'il n'y a pas de constructeur écrit dans votre classe, le système vous attribuera un constructeur (constructeur vide) par défaut

Format de la méthode constructeur :

[Modificateur] Nom du constructeur () {

}

La différence entre les constructeurs et les méthodes :

Il n'y a pas de valeur de retour de la méthode

Il ne peut pas y avoir d'instruction return à l'intérieur du corps de la méthode

• Le nom du constructeur Très spécial, doit être cohérent avec le nom de la classe

• Le rôle du constructeur : ne pas créer d'objet, car l'objet a déjà été créé avant l'appel du constructeur, et les attributs ont des valeurs d'initialisation par défaut.
• Le but de l'appel du constructeur est d'attribuer des valeurs aux propriétés.
  Remarque : nous n'initialisons généralement pas dans un constructeur vide, car alors les propriétés de chaque objet seront les mêmes.

L'exemple suivant :

class Hero{
    //属性
    String Name;//英雄姓名
    int Survive;//生存能力
    int Attack;//攻击伤害
    int Skill;//技能效果
    int Difficulty;//上手难度

    public Hero(){
        Survive=4;
        Attack=5;
        Skill=6;
        Difficulty=7;
    }
    public void print(){
        System.out.println("英雄："+Name);
        System.out.println("生存能力："+Survive);
        System.out.println("攻击伤害："+Attack);
        System.out.println("技能效果："+Skill);
        System.out.println("上手难度："+Difficulty);
    }
}
public class TestCode01 {
    public static void main(String[] args) {
        //创建两个英雄对象
        Hero make = new Hero();
        make.Name="马克";
        Hero lan=new Hero();
        lan.Name="澜";
        //输出两个属性
        make.print();
        lan.print();
    }
}

Parce que nous avons attribué la valeur dans le constructeur, les propriétés seront les mêmes lorsque nous créons l'objet

En fait, il suffit de s'assurer de l'existence du constructeur vide, et le contenu à l'intérieur Pas besoin d'écrire, si on veut utiliser l'affectation de constructeur, il faut surcharger le constructeur

Surcharge du constructeur

Assurer généralement l'existence d'un constructeur vide, les opérations d'affectation d'attributs ne sont généralement pas effectuées

.

Généralement, nous allons surcharger le constructeur et effectuer des opérations d'affectation d'attributs dans le constructeur surchargé

在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。所以我们重载构造器时，一般要保留默认构造器

当形参名字和属性名字重名的时候，会出现就近原则：在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象

this的使用

this就是指当前的对象

this可以修饰属性

当属性名字和形参发生重名的时候，或者 属性名字 和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰（如果不发生重名问题的话，实际上你要是访问属性也可以省略this.）

this修饰方法

在同一个类中，方法可以互相调用，this.可以省略不写。

this可以修饰构造器

同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行

static修饰

static可以修饰：属性、方法、代码块、内部类

static修饰属性

在类加载的时候，会将静态内容也加载到方法区的静态域中，静态的内容先于对象存在，并且这个静态内容被所有该类的对象共享。

• 在类加载的时候一起加载入方法区中的静态域中

• 先于对象存在

• 访问方式： 对象名.属性名 类名.属性名（推荐）

static修饰属性的应用场景：某些特定的数据想要在内存中共享，只有一块 -->这个情况下，就可以用static修饰的属性。

static修饰方法：

• static和public都是修饰符，并列的没有先后顺序，先写谁后写谁都行

• 在静态方法中不能使用this关键字

• 在静态方法中不能访问非静态的方法

• 在静态方法中不能访问非静态的属性

• 静态的方法可以用 对象名.方法名去调用 也可以 用 类名.方法名 （推荐）

• 在同一个类中可以直接调用静态方法

代码块

代码块的分类： 普通块、构造块、静态块、同步块（多线程）

代码块执行顺序： 最先执行静态块–>再执行构造块，（不常用）–>再执行构造器–>再执行方法中的普通块

public class Test {
    //属性
    int a;
    static int sa;
    //方法
    public void a(){
        System.out.println("-----a");
        {
            //普通块限制了局部变量的作用范围
            System.out.println("这是普通块");
            System.out.println("----000000");
            int num = 10;
            System.out.println(num);
        }

    }
    public static void b(){
        System.out.println("------b");
    }
    //构造块
    {
        System.out.println("------这是构造块");
    }
    //静态块
    static{
        System.out.println("-----这是静态块");
        //在静态块中只能方法：静态属性，静态方法
        System.out.println(sa);
        b();
    }
    //构造器
    public Test(){
        System.out.println("这是空构造器");
    }
    public Test(int a){
        this.a = a;
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Test t = new Test();
        t.a();
        Test t2 = new Test();
        t2.a();
    }
}

包（import）

包的作用： 为了解决重名的作用，解决权限问题

包名的定义：

• 名字全部小写

• 中间用.隔开

• 一般都是公司域名倒着写：com.jd 、com.taobao

• 加上模块名字 ：com.taobao.login

• 不能使用系统中的关键字：null

• 包声明的位置一般都在非注释代码的第一行

导包：

（1）使用不同包下的类要需要导包， 例如：import java.util.Date;

（2）在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。

（3）同一个包下的类想使用不需要导包，可以直接使用。

（4）在java.lang包下的类，可以直接使用无需导包

（5）可以直接导入*：

静态导入：

//静态导入：
import static java.lang.Math.*;
//导入：java.lang下的Math类中的所有静态的内容

public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
        System.out.println(round(5.6));
    }
    //在静态导入后，同一个类中有相同的方法的时候，会优先走自己定义的方法。
    public static int round(double a){
        return 1000;
    }
}

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!