J'ai une petite idée des classes utilitaires avec un léger doute sur la demande.
Si j'utilise une classe d'utilité dans ma demande que d'utiliser cette classe dans mon activité principale Dois-je créer l'objet de cette classe ou que je peux importer directement cette classe dans mon activité principale?
Je suis désolé si je ne fais pas de sens clair.
En écreut, tout ce que je veux être clair, c'est que c'est que fondamentalement, comment puis-je utiliser la classe de services publics dans mon activité principale?
merci, David
7 Réponses :
Si votre classe utilitaire est créée dans votre application, vous pouvez en créer une première création d'un getMethod dans la classe d'application, puis en allant
application mc = (application) context.getaplicationContext ();
mc.getutiltilyclass (). SOMEMETHOD ()
Si les méthodes de votre classe utilitaire sont statiques, vous pouvez les appeler de votre activité principale. EG:
Utility u = new Utility(); int i = u.randInt();
Cela dépend principalement de ce que fait votre classe de services publics. Mais, la plupart du temps, si vous créez une classe d'utilité, vous souhaiterez créer des méthodes statiques et les appelerez sans créer d'instance: puis, sur votre activité: P> MyUtilities.foo("baz");
C'est ce que j'utilise et semble être la meilleure mise en œuvre de la plupart des cas.
Une meilleure approche pour cela est de rendre la classe finale et d'ajouter un constructeur privé .
Faire la finale de la classe n'est pas recommandée cependant. Et si vous voulez prolonger cette classe?
Je ne sais pas quelle est votre question exacte. Mais voici un code où j'ai utilisé la classe d'utilité dans mon activité. L'utilisation de l'animation est utilisée pour charger l'animation sur une vue d'écran.
Désolé, cela ne répond pas à la question
Il dépend fortement du type d'utilité que vous parlez. Il y a
1) classes utilitaires qui mettent en œuvre des méthodes statiques. Dans ce cas, vous venez de les appeler directement à l'aide de votre nom de classe
2) Les méthodes de classes utilitaires qui ne sont pas statiques - nécessitent de créer et éventuellement d'initialiser une instance de cette classe. Ensuite, l'instance est utilisée pour appeler ces méthodes.
3) classes utilitaires accessibles au contexte . Ensuite, vous pouvez appeler getApplicationContext () et puis vous pouvez Obtenez Accès aux classes utilitaires
public final class Utils
{
private Utils()
{
}
public static void makeToast(Context context, String text){
Toast.makeText(context, text, Toast.LENGTH_SHORT).show();
}
}
It's usually a class which only has static methods (possibly with a private constructor and marked abstract/final to prevent instantiation/subclassing). It only exists to make other classes easier to use - for example, providing a bunch of static methods to work with String values, performing extra actions which String itself doesn't support.Utility classes generally don't operate on classes you have control over, as otherwise you'd usually put the behaviour directly within that class. They're not terribly neat in OO terms, but can still be jolly useful.as answered by Jon Skeet
Classe publique 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;
}
Une autre réponse: Stackoverflow.com/a/4158902/1414809