Question

关于这个概念，我有些空白。

我有一个名为User（）的抽象类。
RegisteredUser类（）
OfficerUser类（）
一个AdminUser类（）

OfficerUser（）和AdminUser（）类扩展到RegisteredUser（）。

我如何获得不是OfficerUser（）和AdminUser（）的注册用户列表？因为我的实例可以带AdminUser（）或OfficerUser（）..但我不能带其他用户！感谢您的支持。

这是代码：

package elezione.eco.shared;

import java.io.Serializable;

public abstract class User implements Serializable 
{

    private static final long serialVersionUID = 1L;

    protected String username;
    protected String password;
    protected String email;
    protected String name;
    protected String surname;
    protected String telephone;
    protected String fiscal_code;

    public User(){}

    public String getName() {
        return name;
    }

    public String getSurname() {
        return surname;
    }

    public String getfiscal_code() {
        return fiscal_code;
    }
    public String getTelephone() {
        return telephone;
    }

    public String getUsername(){
        return username;
    }

    public String getPassword(){
        return password;
    }

    public String getEmail(){
        return email;
    }
}

package elezione.eco.shared;

import java.io.Serializable;

public class RegisteredUser extends User implements Serializable
{
    private static final long serialVersionUID = 1L;

    protected String type;
    protected String number;
    protected String sender;
    protected String date_sender;
    protected String date_limit;

    public RegisteredUser() {
        this.username = null;
        this.password = null;
        this.email = null;
        this.name = null;
        this.surname = null;
        this.fiscal_code = null;
        this.telephone = null;
        this.type = null;
        this.number = null;
        this.sender = null;
        this.date_sender = null;
        this.date_limit = null;
    }

    public RegisteredUser(String username, String password, String email, String name, String surname, String fiscal_code, String telephone, String type, String number, String sender, String date_sender, String date_limit)
    {
        this.username = username;
        this.password = password;
        this.email = email;
        this.name = name;
        this.surname = surname;
        this.fiscal_code = fiscal_code;
        this.telephone = telephone;
        this.type = type;
        this.number = number;
        this.sender = sender;
        this.date_sender = date_sender;
        this.date_limit = date_limit;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getSender() {
        return sender;
    }

    public void setSender(String sender) {
        this.sender = sender;
    }

    public String getDate_sender() {
        return date_sender;
    }

    public void setDate_sender(String date_sender) {
        this.date_sender = date_sender;
    }

    public String getDate_limit() {
        return date_limit;
    }

    public void setDate_limit(String date_limit) {
        this.date_limit = date_limit;
    }
}

package elezione.eco.shared;

import java.io.Serializable;
import elezione.eco.shared.RegisteredUser;

public class OfficerUser extends RegisteredUser implements Serializable 
{
    private static final long serialVersionUID = 1L;

    public OfficerUser() {}

    public OfficerUser (RegisteredUser user)
    {
        this.username = user.username;
        this.password = user.password;
        this.email = user.email;
        this.name = user.name;
        this.surname = user.surname;
        this.fiscal_code = user.fiscal_code;
        this.telephone = user.telephone;
        this.type = user.type;
        this.number = user.number;
        this.sender = user.sender;
        this.date_sender = user.date_sender;
        this.date_limit = user.date_limit;
    }
}

package elezione.eco.shared;

import java.io.Serializable;

public class AdminUser extends RegisteredUser implements Serializable {
    private static final long serialVersionUID = 1L;

    public AdminUser(){}

    public AdminUser(String username, String password, String email )
    {
        super(username, password, email, "",  "", "",  "",  "",  "",  "",  "",  "");
    }

}

package elezione.eco.server;

import elezione.eco.shared.AdminUser;
import elezione.eco.shared.DuplicatedUserNameException;
import elezione.eco.shared.RegisteredUser;
import elezione.eco.shared.OfficerUser;
import elezione.eco.shared.User;
import elezione.eco.shared.UserNotFoundException;
import elezione.eco.shared.WrongPasswordException;

import java.util.ArrayList;
import java.util.concurrent.ConcurrentMap;
import org.mapdb.DB;

public class LoginServiceImpl {

    // Database
    private DB db;

    // Lista utenti registrati
    private ConcurrentMap<String, RegisteredUser> userMap;

    public LoginServiceImpl( DB db){

        this.db = db;
        this.userMap = this.db.getTreeMap("user");

        if( userMap.get("admin") == null){ // l'admin deve essere sempre presente nel db
            addAdmin();
        }
    }

    // Agigunge un utente al db, se gia' presente lancia eccezione 
    public User addUser( String username, String password, String email, String name, String surname, String telephone, String fiscal_code, String doc, String number, String sender, String date_sender, String date_limit ) throws DuplicatedUserNameException {
        if( userMap.get( username ) != null ){
            throw new DuplicatedUserNameException( username );
        }
        else{
            RegisteredUser user = new RegisteredUser(username,password,email,name,surname,telephone,fiscal_code,doc,number,sender,date_sender,date_limit);
            this.userMap.put( username, user );
            this.db.commit();
            return user;
        }
    }

    // Metodo che azzera la collezione utenti
    public void clear(){
        userMap.clear();
    }

    public void remove( String userName){
        userMap.remove( userName );
    }


    // Aggiunge l'utente admin
    public void addAdmin(){
        AdminUser admin = new AdminUser("admin", "admin", "admin@admin.com");
        userMap.put("admin", admin);
        this.db.commit();
    }

    // Controlla username e password, se l'utente non e' presente o la password e' sbagliata lancia eccezioni
    public RegisteredUser login(String userName, String password) throws WrongPasswordException, UserNotFoundException {
        RegisteredUser user = this.userMap.get( userName );
        if( user != null ){
            if( !user.getPassword().equals(password) ){
                throw new WrongPasswordException();
            }
        }
        else{
            throw new UserNotFoundException();
        }
        return user;
    }

    // Tutti gli utenti ( funzionalità  admin )
        public ArrayList<RegisteredUser> getAllUsers(){
            ArrayList<RegisteredUser> res = new ArrayList<RegisteredUser>(userMap.values());
            res.trimToSize();
            return res;
        }

        // Tutti gli utenti non funzionari o admin ( funzionalità  admin )
        public ArrayList<RegisteredUser> getRegistered(){
            ArrayList<RegisteredUser> users = new ArrayList<RegisteredUser>( userMap.values() );
            ArrayList<RegisteredUser> res = new ArrayList<RegisteredUser>();
            for( RegisteredUser u : users ){
                if( u instanceof RegisteredUser ){
                    res.add( u );
                }
            }
            System.out.println(users);
            res.trimToSize();
            return res;
        }

        // Nomina un funzionario sostituendo l'istanza di utente registrato(normale) 
        // con quella di utente funzionario, associandola allo stesso nome
        public ArrayList<RegisteredUser> nominateOfficer( String userName){     
            RegisteredUser registeredOfficer =  (RegisteredUser) userMap.get(userName);
            RegisteredUser officer = new OfficerUser(registeredOfficer);

            // faccio diventare 
            userMap.replace(userName, registeredOfficer, officer);
            this.db.commit();
            System.out.println("Sono dentro metodo nominateOfficerAfter");
            System.out.println(officer);
            return getRegistered();
        }

        // Tutti gli utenti funzionari ( funzionalità  admin )
        public ArrayList<RegisteredUser> getOfficer(){
            ArrayList<RegisteredUser> users = new ArrayList<RegisteredUser>( userMap.values() );
            ArrayList<RegisteredUser> res = new ArrayList<RegisteredUser>();
                for( RegisteredUser u : users){
                    if( u instanceof OfficerUser ){
                        res.add( u );
                    }
                }
                res.trimToSize();
                return res;
            }
}

我对接口GWT客户端有问题。为什么不工作刷新列表用户？我不知道为什么不起作用..有eclipse和java错误的问题。

package elezione.eco.client;

import java.util.ArrayList;

import com.google.gwt.core.client.GWT;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.DialogBox;
import com.google.gwt.user.client.ui.HTMLPanel;
import com.google.gwt.user.client.ui.Widget;

import elezione.eco.client.Controller;
import elezione.eco.client.OfficerNominationBoard;
import elezione.eco.client.SingleUser;
import elezione.eco.shared.RegisteredUser;
import elezione.eco.shared.User;

/**
 * Classe che gestisce la sezione dell'interfaccia grafica dell'Amministratore per
 * la visualizzazione della finestra di gestione delle promozioni degli utenti.
 */
public class OfficerNominationBoard extends DialogBox
{
  interface OfficerNominationBoardBinder extends UiBinder<Widget, OfficerNominationBoard> {}
  private static OfficerNominationBoardBinder uiBinder = GWT.create(OfficerNominationBoardBinder.class);

  @UiField HTMLPanel registeredUsersListContainer;

  private Controller controller;  

  public OfficerNominationBoard(Controller controller, ArrayList<User> registeredUsersList) 
  {
    this.controller = controller;

    setWidget(uiBinder.createAndBindUi(this));

    showUsers(registeredUsersList);

    setStyleName("dialog");

    this.setAutoHideEnabled(true);
    this.show();
    centerDialog();
  }


//Metodo per centrare orizzontalmente la finestra
  private void centerDialog()
  {
    this.setPopupPosition(((Window.getClientWidth() - getOffsetWidth())/2), 100);
  }

  //Metodo che visualizza l'elenco degli utenti registrati, ma non funzionari comunali
  private void showUsers(ArrayList<User> registeredUsersList)
  {
    for(User u:registeredUsersList)
    {

      SingleUser user = new SingleUser(this, u.getUsername());
      registeredUsersListContainer.add(user);
    }
  }

  //Metodo che aggiorna l'elenco degli utenti registrati, ma non funzionari comunali
  public void refreshOfficer(ArrayList<User> registered)
  {

    registeredUsersListContainer.clear();
    showUsers(registered);
  }

  //Metodo che richiede la nomina di un nuovo funzionario comunale
  public void nominateOfficer(String username)
  {

      controller.nominateOfficer(username);
  }

}

package elezione.eco.client;

import com.google.gwt.core.client.GWT;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.uibinder.client.UiHandler;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.HTMLPanel;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.Widget;

import elezione.eco.client.AdminFunctionSelection;
import elezione.eco.client.Controller;


/**
 * Classe che gestisce la sezione dell'interfaccia grafica dell'Amministratore per
 * la visualizzazione delle finestre di gestione delle categorie e di gestione delle promozioni
 */
public class AdminFunctionSelection extends Composite
{
  interface AdminFunctionSelectionBinder extends UiBinder<Widget, AdminFunctionSelection> {}
  private static AdminFunctionSelectionBinder uiBinder = GWT.create(AdminFunctionSelectionBinder.class);

  @UiField HTMLPanel functionContainer;
  @UiField Label box_title;
  @UiField Button officerManagement;

  private Controller controller;

  public AdminFunctionSelection(Controller controller) 
  {
    this.controller = controller;

    initWidget(uiBinder.createAndBindUi(this));

    box_title.setStyleName("box_title");
    officerManagement.setStyleName("rightBoxElem");
    functionContainer.setStyleName("rightBox");
  }

  //Associo il clickHandler ai Button attraverso l'UiHandler
  @UiHandler("officerManagement")
  void handleClick(ClickEvent event) {
         controller.getRegisteredUsersBoard(); //Visualizzazione della finestra di gestione delle promozioni
  }
}

package elezione.eco.client;

import java.util.ArrayList;

import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;

import elezione.eco.shared.AdminUser;
import elezione.eco.shared.DuplicatedUserNameException;
import elezione.eco.shared.RegisteredUser;
import elezione.eco.shared.User;
import elezione.eco.shared.UserNotFoundException;
import elezione.eco.shared.WrongPasswordException;



/**
 * Classe che gestisce la comunicazione con il server e 
 * le conseguenti richieste di modifica all'interfaccia grafica
 */
public class Controller {

  private ECOServiceAsync service;
  private GUIHandler guiHandler;
  private User user;

    /*
     * Costruttore della classe: quando invocato
     * L'istanza del Server (DRService Async)
     * L'istanza della classe adibita alla gestione dell'interfaccia utente (GUIHandler)
     */
    public Controller()
    {
      service = GWT.create(ECOService.class);
      guiHandler = new GUIHandler(this);
    }

    /* 
     * Metodo per gestire l'avvio dell'applicazione:
     * Creazione dell'header dell'applicazione
     * Richiesta al server dell'elenco delle domande
     */
    public void init()
    {
        System.out.println("Sono in controller init");
      guiHandler.createHeader();
    }

  //Metodo per creare una finestra di avvertimento
  public void alertFailure(String alertMessage)
  {
    guiHandler.createWidget("alert",alertMessage);
  }

  //Metodo per gestire l'evento di login e logout
  public void setLogged(User user)
  {
      if(user != null) //Evento di login
      {
        guiHandler.handleLogRequest(true); //Viene mostrato solo il bottone di logout

            if(user instanceof AdminUser) //Creazione dell'interfaccia utente in funzione del ruolo dell'utente
            {
                createAdminUI();
            } else  {
                createRegisteredUI();
            }
      }
      this.user = user;
  }

  private void createAdminUI() {

        //Creazione pannello per la gestione del ruolo degli utenti
        guiHandler.createWidget("admin", null); 
  }

  private void createRegisteredUI() {
    alertFailure("Entrato");
  }

/*
     * Metodo per gestire la richiesta di login:
     * Se la richiesta va a buon fine, viene avvertito l'utente dell'avvenuto login e richiamato il metodo per gestire l'evento di login
     * Se le richiesta non va a buon fine, viene avvertito l'utente del problema riscontrato
     */
  public void login( String username, String password )
    {

      //Richiesta di login al server 
          service.login(username, password, new AsyncCallback<User>() //Invocazione del metodo di Login del server

        {
          @Override
          public void onFailure(Throwable caught)

          {
              System.out.println("Sono in failure");
            try
            {
              throw caught; //Viene lanciata l'eccezione restituita dal server per poter evidenziare quale è stato il problema
            } catch (WrongPasswordException wp)
            {
              guiHandler.cleanFields("login");
              alertFailure("Password inserita errata");
            } catch(UserNotFoundException e)
            {
              guiHandler.cleanFields("login");
              alertFailure("Utente non trovato nel database");
            }
            catch( Throwable e) //Problema generico
            {
              guiHandler.hideDialog();
              alertFailure("Non e' stato possibile effettuare il login");
            }
          }

          @Override
          public void onSuccess(User returnedUser) 
          {

            System.out.println("Sono in success");
            guiHandler.hideDialog();
            guiHandler.createWidget("notify", "Login effettuato con successo"); //Viene avvertito l'utente che il login è stato effettuato con successo
            setLogged(returnedUser);
          }
        });
          System.out.println("Sono arrivato al termine di login");
    }

      /*
       * Metodo per gestire la richiesta di registrazione:
       * Se la richiesta va a buon fine, viene avvertito l'utente dell'avvenuta registrazione e richiamato il metodo per gestire l'evento di login
       * Se le richiesta non va a buon fine, viene avvertito l'utente del problema riscontrato
       */
    public void registration
        (
          String username, 
          String password, 
          String email, 
          String name, 
          String lastname,
          String Telephone,
          String FiscalCode,
          String gender,
          String Sender,
          String Number, 
          String dateSender, 
          String dateLimit
        )
      {
        //Richiesta al server della registrazione del nuovo utente
    service.addUser(username, password, email, name, lastname, Telephone, FiscalCode, gender, Sender, Number, dateSender, dateLimit, new AsyncCallback<User>()
    {
      @Override
      public void onFailure(Throwable caught)
      {
        try
        { 
          throw caught; //Viene lanciata l'eccezione restituita dal server per poter evidenziare quale è stato il problema
        } catch ( DuplicatedUserNameException du )
        {
          guiHandler.cleanFields("registration");
          alertFailure("Attenzione l'username " + du.getUserName() + " non puo' essere scelto");
        } catch(Throwable e) //Problema generico
        {
          guiHandler.hideDialog(); 
          alertFailure("Non e' stato possibile effettuare la registrazione");
        }
      }

      @Override
      public void onSuccess(User returnedUser)
      {
        guiHandler.hideDialog();
        guiHandler.createWidget("notify", "Registrazione effettuata con successo"); //Viene avvertito l'utente che la registazione è stata effettutata con successo

      }
     });
    }

      /*
       * Metodo per richiedere l'elenco degli utenti registrati ma non giudici
       * Se la richiesta va a buon fine viene creata la finestra di gestione delle promozioni
       * Se la richiesta non va a buon fine viene avvertito l'Amministratore del problema
       */
      public void getRegisteredUsersBoard()
      {
        AsyncCallback<ArrayList<User>> getRegisteredUsersCallback = new AsyncCallback<ArrayList<User>>()
        {
          @Override
          public void onFailure(Throwable caught)
          {
            alertFailure("Non è stato possibile ottenere l'elenco degli utenti registrati");
          }

          @Override
          public void onSuccess(ArrayList<User> registeredUsers)
          {
            if(registeredUsers.size() != 0)
            {
              guiHandler.createWidget("officer", registeredUsers);
            } else
            {
              alertFailure("Attenzione tutti gli utenti registrati sono dei funzionari comunali");
            }
          }
        };
        service.getRegistered(getRegisteredUsersCallback); //Richiesta al server dell'elenco degli utenti registrati, ma non giudici
      }

      /*
       * Metodo per nominare un nuovo giudice:
       *Se la richiesta va a buon fine viene aggiornato l'elenco degli utenti registrati, ma non giudici
       * Se la richiesta non va a buon fine viene avvertito l'Amministratore del problema
       */
      public void nominateOfficer(String username)
      {
        final String user = username;
        AsyncCallback<ArrayList<User>> nominateOfficerCallback = new AsyncCallback<ArrayList<User>>()
        {
          @Override
          public void onFailure(Throwable caught)
          {
            alertFailure("Non è stato possibile rendere "+ user +" un nuovo funzionario comunale");
          }

          @Override
          public void onSuccess(ArrayList<User> registered)
          {
            if(registered.size() != 0)
            {
              guiHandler.updateOfficer(registered);
            } else
            {
              guiHandler.hideDialog();
              alertFailure("Attenzione tutti gli utenti registrati sono dei funzionari comunali");
            }
          }
        };
        service.nominateOfficer(username, nominateOfficerCallback); //Richiesta al server di nomina del giudice
      }
}

package elezione.eco.client;

import java.util.ArrayList;

import com.google.gwt.user.client.ui.DialogBox;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.Widget;

import elezione.eco.client.OfficerNominationBoard;
import elezione.eco.client.AdminFunctionSelection;

import elezione.eco.shared.RegisteredUser;
import elezione.eco.shared.User;
import elezione.eco.client.Controller;






/**
 * Classe adibita alla gestione degli elementi dell'interfaccia grafica
 */
public class GUIHandler
{
  private Controller controller;
  private Header header;
  private Widget widget;

  public GUIHandler(Controller controller)
  {
    this.controller = controller;
  }

  /*
   * Metodo per la creazione dell'header della pagina
   */
  public void createHeader()
  {
    header = new Header(this);
  }

  /*
   * Metodo per la gestione dell'evento di login/logout
   */
  public void handleLogRequest(boolean isLogin)
  {
    header.swapLogButtons(isLogin);
    if(!isLogin)
    {
     clearHP();
     controller.setLogged(null);
    }
  }

  public void clearHP() {
      RootPanel.get("RightSideBar").clear();
  }

   /*
   * Metodo per la creazione dei vari componenti dell'interfaccia
   */
  @SuppressWarnings ( "unchecked")
public void createWidget(String type, Object object)
  {
    switch (type)
    {
    case "login": //Creazione della finestra di login
      widget = new LoginDialog(controller);
      break;
    case "registration": //Creazione della finestra di registrazione
      widget = new RegistrationDialog(controller);
      break;
    case "admin": //Creazione della sezione delle funzioni dell'Amministratoref
        RootPanel.get("RightSideBar").add(new AdminFunctionSelection(controller));
        break;
    case "officer": //Creazione della finestra di gestione delle promozioni
        widget = new OfficerNominationBoard(controller, (ArrayList<User>)object);
        break;
    default: //Creazione di una finestra di dialogo generica (alert/notify)
        new Dialog(type, (String)object);
        break;
    }
  }

  /*
   * Metodo per ripulire i campi di testo dei vari widget
   */
  public void cleanFields(String piece)
  {
    switch (piece)
    {
      case "loging":
        ((LoginDialog) widget).cleanFields();
        break;
      case "registration":
        ((RegistrationDialog) widget).cleanFields();
        break;

    }
  }

  public void hideDialog()
  {
    ((DialogBox)widget).hide();
  }

  public void updateOfficer(ArrayList<User> registered) {


     ((OfficerNominationBoard)widget).refreshOfficer(registered);

}


}

package elezione.eco.client;


import com.google.gwt.core.client.GWT;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.uibinder.client.UiHandler;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.HorizontalPanel;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.Widget;

/**
 * Classe che gestisce la sezione dell'interfaccia grafica dell'Amministratore per
 * la visualizzazione del singolo utente registrato, ma non funzionario comunale, nella finestra
 * di gestione delle promozioni
 */
public class SingleUser extends Composite
{
  interface SingleOfficerBinder extends UiBinder<Widget, SingleUser> {}
  private static SingleOfficerBinder uiBinder = GWT.create(SingleOfficerBinder.class);

  private OfficerNominationBoard owner;


  @UiField Label username;
  @UiField Button promote;
  @UiField HorizontalPanel userContainer;

  public SingleUser(OfficerNominationBoard owner, String username)
  {
    this.owner = owner;

    initWidget(uiBinder.createAndBindUi(this));

    this.username.setText(username);

    userContainer.setStyleName("managerDiv");
    promote.getElement().setId("promotionButton");
    this.username.getElement().setId("label");
  }

  //Associo il clickHandler al Button attraverso l'UiHandler
  @UiHandler("promote")
  void handleClick(ClickEvent event)
  {

    owner.nominateOfficer(username.getText()); //Richiesta di promozione dell'utente
  }
}

Answer 1

您可以通过两种方式实现它。

第一种方式：

public class TestClass {
    public static void main(String[] args) {
        User base = new Registered();
        User base2 = new Officer();

        System.out.println(isOnlyRegisteredUser(base));
        System.out.println(isOnlyRegisteredUser(base2));
    }

    static boolean isOnlyRegisteredUser(User user){
        return user instanceof Registered && !(user instanceof Officer) && !(user instanceof Admin);
    }
}

第二种方式： 创建UserEnum.java

在User.java中列出所有类型的用户并创建方法

UserEnum getUserType(User user){
    // impl for every class
}

当然可以在扩展User的类中实现。

Answer 2

您可以简单地验证其距离：

public static void main(String [] args) 
{
    AdminUser a1 = new AdminUser("admin1");
    AdminUser a2 = new AdminUser("admin2");

    OfficerUser o1 = new OfficerUser("officer1");
    OfficerUser o2 = new OfficerUser("officer2");

    RegisteredUser u1 = new RegisteredUser("generic1");
    RegisteredUser u2 = new RegisteredUser("generic2");


    List<RegisteredUser> list = Arrays.asList(a1, a2, o1, o2, u1, u2);

    int counter = 0;

    for (RegisteredUser reg : list) {
        if (!(reg instanceof AdminUser || reg instanceof OfficerUser)) {
            System.out.println(reg.getName());
            counter++;
        }
    }

    System.out.println(counter);

}

如何在另一个类中获取Java类的值

2 个答案: