我怎么能说我在静态Methid具有MainActivity中的Android

Question

我有这个类，并与简单的静态{}方法的问题：

package com.example.tabletapp1.dummy; 

import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 

import org.json.JSONArray; 
import org.json.JSONException; 
import org.json.JSONObject; 

import android.os.StrictMode; 
import android.util.Log; 

public class DummyContent { 

    public static List<DummyItem> ITEMS = new ArrayList<DummyItem>(); 
    public static Map<String, DummyItem> ITEM_MAP = new HashMap<String, DummyItem>(); 
    public static ArrayList<HashMap<String, String>> stireList = new ArrayList<HashMap<String, String>>(); 

    static { /////// THIS FUNCTION 
     StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder() 
       .permitAll().build(); 

     StrictMode.setThreadPolicy(policy); 

     String url = "http://kosalis.beclenar.ro/stiri.txt"; 

     // JSON Node names 
     String TAG_STIRE = "stire"; 
     String TAG_ID = "ID"; 
     String TAG_NUME = "Nume"; 
     String TAG_DESCRIERE = "Descriere"; 
     String TAG_POZA = "Poza"; 
     String TAG_CORP_STIRE_HTML = "Corp_stire_html"; 

     // contacts JSONArray 
     JSONArray news = null; 

     // Creating JSON Parser instance 
     JSONParser jParser = new JSONParser(); 

     // getting JSON string from URL 
     JSONObject json = jParser.getJSONFromUrl(url); 

     try { 
      // Getting Array of Contacts 
      news = json.getJSONArray(TAG_STIRE); 

      // looping through All Contacts 
      for (int i = 0; i < news.length(); i++) { 
       JSONObject c = news.getJSONObject(i); 

       // Storing each json item in variable 
       String id = c.getString(TAG_ID); 
       String name = c.getString(TAG_NUME); 
       String description = c.getString(TAG_DESCRIERE); 
       String poza = c.getString(TAG_POZA); 
       String body_html = c.getString(TAG_CORP_STIRE_HTML); 

       // creating new HashMap 
       HashMap<String, String> map = new HashMap<String, String>(); 

       // adding each child node to HashMap key => value 
       map.put(TAG_ID, id); 
       map.put(TAG_NUME, name); 
       map.put(TAG_DESCRIERE, description); 
       map.put(TAG_POZA, poza); 

       // adding HashList to ArrayList 
       stireList.add(map); 
       addItem(new DummyItem(id, name, description, poza, body_html)); 

      } 
     } catch (JSONException e) { 
      Log.e("Error2", TAG_CORP_STIRE_HTML); 
      e.printStackTrace(); 
     } 
    } 

    private static void addItem(DummyItem item) { 
     ITEMS.add(item); 
     ITEM_MAP.put(item.id, item); 
    } 

    public static class DummyItem { 
     public String id; 
     public String title; 
     public String description; 
     public String content; 
     public String photo; 

     public DummyItem(String id, String title, String description, 
       String photo, String content) { 
      this.id = id; 
      this.title = title; 
      this.description = description; 
      this.photo = photo; 
      this.content = content; 
     } 

     @Override 
     public String toString() { 
      return title; 
     } 
    } 
} 

但我不知道怎么办是什么MainActivity的静态{}函数。 我想，因为每一个我的应用程序启动时，用户界面冻结从我mainactivity调用的AsyncTask，我敢肯定，这是因为它创建了一个JSONPArser类的静态函数：

package com.example.tabletapp1.dummy; 

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.InputStreamReader; 
import java.io.UnsupportedEncodingException; 

import org.apache.http.HttpEntity; 
import org.apache.http.HttpResponse; 
import org.apache.http.client.ClientProtocolException; 
import org.apache.http.client.methods.HttpGet; 
import org.apache.http.impl.client.DefaultHttpClient; 
import org.json.JSONException; 
import org.json.JSONObject; 

import android.util.Log; 

public class JSONParser { 

    static InputStream is = null; 
    static JSONObject jObj = null; 
    static String json = ""; 

    // constructor 
    public JSONParser() { 
    } 

    public JSONObject getJSONFromUrl(String url) { 
     // Making HTTP request 
     try { 
      // defaultHttpClient 
      DefaultHttpClient httpClient = new DefaultHttpClient(); 
      HttpGet httpGet = new HttpGet(url); 
      HttpResponse httpResponse = httpClient.execute(httpGet); 
      HttpEntity httpEntity = httpResponse.getEntity(); 
      is = httpEntity.getContent(); 

     } catch (UnsupportedEncodingException e) { 
      e.printStackTrace(); 
     } catch (ClientProtocolException e) { 
      e.printStackTrace(); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 

     try { 
      BufferedReader reader = new BufferedReader(new InputStreamReader(
        is, "ISO-8859-2"), 8); 
      StringBuilder sb = new StringBuilder(); 
      String line = null; 
      while ((line = reader.readLine()) != null) { 
       sb.append(line + "\n"); 
      } 
      is.close(); 
      json = sb.toString(); 
     } catch (Exception e) { 
      Log.e("Buffer Error", "Error converting result " + e.toString()); 
     } 

     // try parse the string to a JSON object 
     try { 
      jObj = new JSONObject(json); 
     } catch (JSONException e) { 
      Log.e("JSON Parser", "Error parsing data " + e.toString()); 
     } 
     // return JSON String 
     return jObj; 
    } 
} 

而且我还有一个问题： 可以说我有一个AsyncTask，并且在doInBackground（）中我调用了JSONParser类，是否会冻结UI？请帮忙！

Answer 1

您需要将static {替换为static void staticMethod() {。然后你可以拨打电话DummyContent.staticMethod()。

编辑：@Mah对多个问题提出了一个很好的观点。请让我知道如果你创建一个新的，我可以为你移动我的答案的一部分。

对于Asynctask来说，这对于像这样的工作确实很好，因为在doInBackground()中完成的任何操作都不会阻塞UI线程。对我而言，它有一些学习曲线，但我发现它是一个非常有用的课程。使用下面的例子中，你会打电话new myAsyncTask().execute(url)

class myAsyncTask extends AsyncTask<String, Integer, Boolean> { 

    @Override 
    protected Boolean doInBackground(String... url) { 
     // This will receive the String you passed into it and return a boolean to onPostExecute() 
     // Put all your CPU intensive stuff here 

     // publishProgress can be used update the UI thread 
     Integer progress = 1; 
     publishProgress(progress); 

     return true; 
    } 

    @Override 
    protected void onProgressUpdate(Integer... doInBackgroundResult) { 
     super.onProgressUpdate(doInBackgroundResult); 
     // Anything done here can update the UI but will block 
    } 

    @Override 
    protected void onPostExecute(Boolean doInBackgroundResult) { 
     super.onPostExecute(doInBackgroundResult); 
     // Runs after doInBackground finishes 
     // Anything done here will block the UI 
    } 
} 

Answer 2

您没有定义静态方法，您定义了一个静态初始化程序;它会在实例化对象时自动运行。使其成为一种实际的方法（使用static关键字），并且可以调用它。

至于你的另一个问题：它与第一个无关;为它创建一个单独的问题。