Utilizzo di classi di utilità nella programmazione Android

Question

Ho una piccola idea delle classi di utilità con un leggero dubbio su richiesta.

Se utilizzo la classe di utilità nella mia applicazione piuttosto che utilizzare tale classe nella mia attività principale, devo creare l'oggetto di quella classe o posso importare direttamente tale classe nella mia attività principale?

Mi dispiace se non sto dando un senso.

In poche parole, tutto quello che voglio essere chiaro è che in pratica come posso utilizzare la classe di utilità nella mia attività principale?

Grazie, David

Answer 1

Dipende pesantemente su che tipo di programma di utilità ti riferisci. Ci sono

1) classi di utilità che implementano metodi statici. In tal caso basta chiamarli direttamente usando il nome della classe

2) i metodi delle classi di utilità che non sono statici - richiede la creazione e probabilmente l'inizializzazione di un'istanza di quella classe. Quindi l'istanza viene utilizzata per chiamare tali metodi.

3) classi di utilità a cui è possibile accedere tramite Context.quindi è possibile chiamare getApplicationContext() e poi si può get l'accesso alle classi di utilità

Answer 2

Se la classe software è stato creato nell'applicazione allora si può fare riferimento ad esso creando prima un getMethod nella classe di applicazione, poi andando

Application mc = (Application) contesto .getApplicationContext();

mc.getUtilityClass(). SomeMethod()

Answer 3

Se i metodi nella vostra classe di utilità sono statici allora si può chiamare dalla vostra attività principale. ad esempio:

int i = Utility.RandInt(); 

Se non sono statici, allora è necessario creare un oggetto:

Utility u = new Utility(); 
int i = u.randInt(); 

Answer 4

Dipende principalmente su ciò che la vostra classe di utilità fa. Ma, il più delle volte, se si crea una classe di utilità, si vuole creare metodi statici e richiamare senza creare un'istanza:

class MyUtilities{ 
    public static String foo(String bar){ 
     return bar.toUppercase; 
    } 
} 

Poi, sulla vostra attività:

MyUtilities.foo("baz"); 

Di Certo, ci sono casi in cui vorrete creare un'istanza di una classe di utilità. Ad esempio, se hai creato un adattatore globale che verrà utilizzato da tutti i tuoi ListViews.

Answer 5

Non so quale sia la tua domanda esatta. Ma qui c'è un codice in cui ho usato la classe Utility nella mia attività. AnimationUtil viene utilizzato per caricare l'animazione su un ImageView.

ImageView waitImg = (ImageView) findViewById(R.id.ImageView02); 

    Animation waitAnim = AnimationUtils.loadAnimation(this, R.anim.wait_rotate); 

    waitImg.startAnimation(waitAnim); 
    waitAnim.cancel(); 
    waitAnim.reset(); 

Answer 6

public final class Utils 
    { 
    private Utils() 
    { 
    } 

    public static void makeToast(Context context, String text){ 
     Toast.makeText(context, text, Toast.LENGTH_SHORT).show(); 
    } 
} 

Di solito è una classe che ha solo static methods (possibilmente con un costruttore privato e codificato abstract/final per prevenire instantiation/subclassing). Esiste solo per fare altre classi più facile da usare -., ad esempio, fornendo una serie di static methods di lavorare con valori String, compiere azioni extra che stringa stessa non supporta

classi di utilità genere non fare operate on classes si ha il controllo, altrimenti si di solito metteva lo behaviour directly all'interno di quello class. Non sono terribly neat in OO terms, ma possono comunque essere utili.

come answered by Jon Skeet

Answer 7

public class Utils {

public static boolean isNetworkAvailable(Context context) { 
    ConnectivityManager connectivityManager = (ConnectivityManager) context 
      .getSystemService(Context.CONNECTIVITY_SERVICE); 
    NetworkInfo activeNetworkInfo = connectivityManager 
      .getActiveNetworkInfo(); 
    return activeNetworkInfo != null && activeNetworkInfo.isConnected(); 
} 

public static void unlockScreenOrientation(Activity activity) { 
    activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR); 
} 

public static void lockScreenOrientation(Activity activity) { 
    int currentOrientation = activity.getResources().getConfiguration().orientation; 
    if (currentOrientation == Configuration.ORIENTATION_PORTRAIT) 
    { 
     activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); 
    } 
    else 
    { 
     activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); 
    } 
} 
// Get Http Post response 
@Nullable 
public static String getHttpResponse(String url, List<NameValuePair> nameValuePairs) { 
    HttpClient httpClient = new DefaultHttpClient(); 

    HttpPost httpPost = new HttpPost(url); 
    UrlEncodedFormEntity entity; 
    try { 
     entity = new UrlEncodedFormEntity(nameValuePairs); 
     httpPost.setEntity(entity); 
     HttpResponse response = httpClient.execute(httpPost); 

     HttpEntity resEntity = response.getEntity(); 
     String res = EntityUtils.toString(resEntity); 
     return res; 
    } catch (UnsupportedEncodingException e) { 
     e.printStackTrace(); 
    } catch (ClientProtocolException e) { 
     e.printStackTrace(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
    return null; 
} 

public static void CopyStream(InputStream is, OutputStream os) { 
    final int buffer_size=1024; 
    try 
    { 
     byte[] bytes=new byte[buffer_size]; 
     for(;;) 
     { 
      int count=is.read(bytes, 0, buffer_size); 
      if(count==-1) 
       break; 
      os.write(bytes, 0, count); 
     } 
    } 
    catch(Exception ex){} 
} 

public static JSONObject getJsonObjectFromXmlResponse(String xmlString) { 
    JSONObject objectJson = new JSONObject(); 
    //JSONArray arrayJson = new JSONArray(); 

    XmlPullParser parser = Xml.newPullParser(); 
    try { 
     parser.setInput(new StringReader(xmlString)); 
     int eventType = parser.getEventType(); 

     while (eventType != XmlPullParser.END_DOCUMENT) { 
      String name; 
      switch (eventType) { 
       case XmlPullParser.START_TAG: 
        name = parser.getName(); 
        if (name.equalsIgnoreCase("string")) { 
         String yourValue = parser.nextText(); 
         //arrayJson = new JSONArray(yourValue); 
         objectJson = new JSONObject(yourValue); 
        } 
        break; 
      } 
      eventType = parser.next(); 
     } 
    } catch (XmlPullParserException e) { 
     e.printStackTrace(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } catch (JSONException e) { 
     e.printStackTrace(); 
    } 
    return objectJson; 
} 

}