Comment Java définit-il la classe Union pour réaliser la coexistence des corps de données ?

Définir la classe Union pour implémenter la coexistence de corps de données

Dans le langage C/C++, une union (union), également appelée union, est une structure de données similaire à une structure (structure). L'union, comme la structure, peut contenir de nombreux types de données et variables. La différence entre les deux est la suivante :

1. Toutes les variables dans la structure (struct) "coexistent", toutes les variables sont efficaces en même temps, et chaque variable occupe un espace mémoire différent est en vigueur en même temps et toutes les variables occupent le même espace mémoire.

2. Lorsque plusieurs données doivent partager la mémoire ou qu'une seule parmi plusieurs données doit être prise à la fois, une union peut être utilisée.

Dans le langage Java, il n'y a pas de notion d'union et de structure (struct), seulement la notion de classe (class). Comme nous le savons tous, les structures peuvent être implémentées à l’aide de classes. En fait, les unions peuvent également être mises en œuvre à l’aide de classes. Cependant, cette classe n'a pas la fonction de « plusieurs données doivent partager la mémoire », mais seulement la fonction de « une seule parmi plusieurs données doit être prise à la fois ».

Ici, prenons comme exemple le message client du protocole WeChat. Sur la base de mes nombreuses années d'expérience dans l'encapsulation de protocoles d'interface, il existe principalement deux méthodes d'implémentation.

1. Utiliser la fonction pour implémenter Union

Implémentation de la classe Union :

/** 客户消息类 */@ToStringpublic class CustomerMessage {    /** 属性相关 */
    /** 消息类型 */
    private String msgType;    /** 目标用户 */
    private String toUser;    /** 共用体相关 */
    /** 新闻内容 */
    private News news;
    ...    /** 常量相关 */
    /** 新闻消息 */
    public static final String MSG_TYPE_NEWS = "news";
    ...    /** 构造函数 */
    public CustomerMessage() {}    /** 构造函数 */
    public CustomerMessage(String toUser) {        this.toUser = toUser;
    }    /** 构造函数 */
    public CustomerMessage(String toUser, News news) {        this.toUser = toUser;        this.msgType = MSG_TYPE_NEWS;        this.news = news;
    }    /** 清除消息内容 */
    private void removeMsgContent() {        // 检查消息类型
        if (Objects.isNull(msgType)) {            return;
        }        // 清除消息内容
        if (MSG_TYPE_NEWS.equals(msgType)) {
            news = null;
        } else if (...) {
            ...
        }
        msgType = null;
    }    /** 检查消息类型 */
    private void checkMsgType(String msgType) {        // 检查消息类型
        if (Objects.isNull(msgType)) {            throw new IllegalArgumentException("消息类型为空");
        }        // 比较消息类型
        if (!Objects.equals(msgType, this.msgType)) {            throw new IllegalArgumentException("消息类型不匹配");
        }
    }    /** 设置消息类型函数 */
    public void setMsgType(String msgType) {        // 清除消息内容
        removeMsgContent();        // 检查消息类型
        if (Objects.isNull(msgType)) {            throw new IllegalArgumentException("消息类型为空");
        }        // 赋值消息内容
        this.msgType = msgType;        if (MSG_TYPE_NEWS.equals(msgType)) {
            news = new News();
        } else if (...) {
            ...
        } else {            throw new IllegalArgumentException("消息类型不支持");
        }
    }    /** 获取消息类型 */
    public String getMsgType() {        // 检查消息类型
        if (Objects.isNull(msgType)) {            throw new IllegalArgumentException("消息类型无效");
        }        // 返回消息类型
        return this.msgType;
    }    /** 设置新闻 */
    public void setNews(News news) {        // 清除消息内容
        removeMsgContent();        // 赋值消息内容
        this.msgType = MSG_TYPE_NEWS;        this.news = news;
    }    /** 获取新闻 */
    public News getNews() {        // 检查消息类型
        checkMsgType(MSG_TYPE_NEWS);        // 返回消息内容
        return this.news;
    }
    
    ...
}

Utilisation de la classe Union :

String accessToken = ...;
String toUser = ...;
List<Article> articleList = ...;
News news = new News(articleList);
CustomerMessage customerMessage = new CustomerMessage(toUser, news);
wechatApi.sendCustomerMessage(accessToken, customerMessage);

Main Avantages et inconvénients :

Avantages : Plus proche de l'union du langage C/C++

• Inconvénients : La logique de mise en œuvre est plus complexe et il existe de nombreuses vérifications de types de paramètres.

• 2. Utilisez l'héritage pour implémenter Union

Implémentation de la classe Union :

/** 客户消息类 */@Getter@Setter@ToStringpublic abstract class CustomerMessage {    /** 属性相关 */
    /** 消息类型 */
    private String msgType;    /** 目标用户 */
    private String toUser;    /** 常量相关 */
    /** 新闻消息 */
    public static final String MSG_TYPE_NEWS = "news";
    ...    /** 构造函数 */
    public CustomerMessage(String msgType) {        this.msgType = msgType;
    }    /** 构造函数 */
    public CustomerMessage(String msgType, String toUser) {        this.msgType = msgType;        this.toUser = toUser;
    }
}/** 新闻客户消息类 */@Getter@Setter@ToString(callSuper = true)public class NewsCustomerMessage extends CustomerMessage {    /** 属性相关 */
    /** 新闻内容 */
    private News news;    /** 构造函数 */
    public NewsCustomerMessage() {        super(MSG_TYPE_NEWS);
    }    /** 构造函数 */
    public NewsCustomerMessage(String toUser, News news) {        super(MSG_TYPE_NEWS, toUser);        this.news = news;
    }
}

Utilisation de la classe Union : #🎜 🎜#

String accessToken = ...;
String toUser = ...;
List<Article> articleList = ...;
News news = new News(articleList);
CustomerMessage customerMessage = new NewsCustomerMessage(toUser, news);
wechatApi.sendCustomerMessage(accessToken, customerMessage);

Principaux avantages et inconvénients :

Avantages : utilisez des classes de base et des sous-classes virtuelles pour le fractionnement, et les concepts de chaque objet de sous-classe sont clairs ;# 🎜 🎜#

Inconvénients : C'est très différent de l'union du langage C/C++, mais les fonctions sont généralement les mêmes.
En langage C/C++, l'union n'inclut pas le type de données actuel de l'union. Cependant, l'union Java implémentée ci-dessus contient déjà le type de données correspondant à l'union. Par conséquent, à proprement parler, l'union Java n'est pas une véritable union, mais une classe avec la fonction "une seule parmi plusieurs données est prise à la fois".

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!