如何使用java8的CompletableFuture和功能接口？

我想将类

CompteBancaire

替换为函数接口，有人能告诉我怎么做吗

下面是代码片段，我想在

verserArgent

和

retirerArgent

中为异步任务使用

CompletableFuture

方法

package myclasses;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;

public class CompteBancaire {

    private int numC;
    private int nbTraces;
    public static int nbComptes;
    public double solde;
    private String nom;
    private String prenom;

    private List<Double> tracesComptes = new ArrayList<>();

    /**
     * @Constructeur non pramétré
     */
    public CompteBancaire() {
        this.tracesComptes = new ArrayList<>();
        nbComptes++;

    }

    /**
     *
     * @param numC
     * @param solde
     * @param nom
     * @param prenom
     *
     * @Constructeur pramétré
     */
    public CompteBancaire(int numC, double solde, String nom, String prenom) {
        this.numC = numC;
        this.solde = solde;
        this.nom = nom;
        this.prenom = prenom;
        this.tracesComptes = new ArrayList<>();
        nbComptes++;
    }

    /**
     *
     * @return @getters && setters
     *
     *
     */
    public int getNumC() {
        return numC;
    }

    public void setNumC(int numC) {
        this.numC = numC;
    }

    public int getNbTraces() {
        return nbTraces;
    }

    public void setNbTraces(int nbTraces) {
        this.nbTraces = nbTraces;
    }

    public double getSolde() {
        return solde;
    }

    public void setSolde(double solde) {
        this.solde = solde;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getPrenom() {
        return prenom;
    }

    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }

    /**
     *
     * @param tracesCompte
     */
    public void setTracesCompte(List<Double> tracesCompte) {
        this.tracesComptes = tracesCompte;
    }

    /**
     *
     * @param montant
     * @return
     * @throws tp3.ErreurNegatif
     * @Methode qui depose de l'argent au compte (versement)
     *
     */

    public void verserArgent(double montant) throws ErreurNegatif, Throwable {
        if (montant > 0) {
            solde += montant;
            tracesComptes.add(nbTraces, solde);
            nbTraces++;
        } else {
            throw new ErreurNegatif();
        }

    }

    /**
     *
     * @Methode qui retire de l'argent du compte
     *
     */
    void retirerArgent(double montant) throws ErreurNegatif {
        if (solde - montant > 0) {
            solde -= montant;
            tracesComptes.add(nbTraces, solde);
            nbTraces++;
        } else {
            throw new ErreurNegatif();
        }

    }

    /**
     *
     * @return @Methode qui affiche les informations relatives au compte
     *
     *
     */
    public String description() {

        return "Titulaire du compte:" + nom + " " + prenom + ", Numéro compte:" + numC + ", Solde:" + solde;
    }
}

package-myclass；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.Future；
公营公司{
私有int numC；
私人内部跟踪；
公共静态公司；
公共双索尔德；
私有字符串名称；
私有字符串prenom；
private List tracesComptes=new ArrayList（）；
/**
*@Constructeur非婴儿车©tr©
*/
公共公司（）{
this.tracesComptes=新的ArrayList（）；
nbComptes++；
}
/**
*
*@param numC
*@param-solde
*@param-nom
*@param prenom
*
*@constructureur pramétrÃ）
*/
公共密码（整数、双索、字符串名称、字符串前缀）{
this.numC=numC；
this.solde=solde；
this.nom=nom；
this.prenom=prenom；
this.tracesComptes=新的ArrayList（）；
nbComptes++；
}
/**
*
*@return@getter&&setter
*
*
*/
public int getNumC（）{
返回numC；
}
公共无效setNumC（int numC）{
this.numC=numC；
}
公共int getNbTraces（）{
返回轨迹；
}
公共无效setNbTraces（int nbTraces）{
this.nbTraces=nbTraces；
}
公共双getSolde（）{
回流焊；
}
公共无效固定资产（双索尔德）{
this.solde=solde；
}
公共字符串getNom（）{
返回名称；
}
公共无效集合名（字符串名）{
this.nom=nom；
}
公共字符串getPrenom（）{
返回prenom；
}
公共void setPrenom（字符串prenom）{
this.prenom=prenom；
}
/**
*
*@param tracesCompte
*/
公共无效setTracesCompte（列表tracesCompte）{
this.tracesComptes=tracesCompte；
}
/**
*
*@param montant
*@返回
*@throws tp3.erreur如果
*@Methode qui depose de l'argent au compte（versement）
*
*/
公共无效或紧急（双重蒙塔特）抛出错误，如果，可丢弃{
如果（蒙塔特>0）{
索尔德+=蒙塔特；
tracesComptes.add（nbTraces，solde）；
nbc++；
}否则{
抛出新的erreurif（）；
}
}
/**
*
*@Methode qui退银公司
*
*/
void retirerArgent（双蒙塔特）抛出错误{
如果（solde-montant>0）{
索尔德-=蒙坦特；
tracesComptes.add（nbTraces，solde）；
nbc++；
}否则{
抛出新的erreurif（）；
}
}
/**
*
*@return@Methode qui affiche les informations亲属公司
*
*
*/
公共字符串描述（）{
返回“公司名称：”+nom+“+prenom+”，编号：“+numC+”，索尔德：”+Solde；
}
}

功能接口是一种只有一种方法的接口。您的类有（1）多个方法，并且（2）包含带有主体的方法，这意味着它不能转换为函数接口。当然，您可以创建一个接口，然后实现它

请用英语重写您的代码并编辑您的答案

public void verserArgent(double montant) throws ErreurNegatif, Throwable {
   if (montant > 0) {
       solde += montant;
       tracesComptes.add(nbTraces, solde);
       nbTraces++;
   } else {
       throw new ErreurNegatif();
   }
}

这是要执行异步的方法。（我不完全理解你，但我认为这就是你想要做的）。异步执行此方法没有多大意义，因为它并不昂贵

CompletableFuture可以简单地实例化并使用其方法完成

complete（T result）

例如：

    public CompletableFuture<Void> verserArgent(double montant) throws ErreurNegatif, Throwable {
   CompletableFuture<Void> future = new CompletableFuture<>();
   if (montant > 0) {
       solde += montant;
       tracesComptes.add(nbTraces, solde);
       nbTraces++;
       future.complete(null);
   } else {
       throw new ErreurNegatif();
   }
   return future;
}

public CompletableFuture-verserArgent（双蒙塔特）抛出erreurnaif，可丢弃{
CompletableFuture=新的CompletableFuture（）；
如果（蒙塔特>0）{
索尔德+=蒙塔特；
tracesComptes.add（nbTraces，solde）；
nbc++；
future.complete（空）；
}否则{
抛出新的erreurif（）；
}
回归未来；
}

---

同样，这是可行的，但没有意义。

我应该在我的方法中使用CompletableFuture，即使它们并不昂贵，任何帮助plzI都已经回答了您的问题并编写了一个使用CompletableFuture的函数。