Question

我是android的新手，我正在尝试为我的应用程序找到一个好的结构，但我不知道该怎么做。

我有一个活动和一个页面只收集信息并用它做一些事情（推送到API，计算等......）。但我只是不想把所有内容都放在MainActivity.java中，因为它会变成一个包含如此多函数的长文件。所以我希望能够从MainActivity.java调用这些函数，并在其他类中执行它们。

是否有特定的名称或方式？如果我为同一个Main Activity创建一个新的类来预先形成从那里调用的函数，并保持MainActivity.java短而干净

，我将扩展哪个类

Answer 1

您可以阅读有关MVC或MVP的一些知识。简而言之，尝试将UI模块与Logic Module分开。您可以参考以下几种常用方法：

将您的公共api写入***Util.java（使用静态函数），例如：FileUtil.java是一个处理文件管理的工具类，您可以编写
- public static void saveFile（String path）
- public static void deleteFile（String path）
- public static void saveJpeg（String path，Bitmap b）
- public static void delAllFiles（String folder）等等。

您可以编写PreferenceUtil.java来处理Android首选项管理。

如果许多活动具有相同的功能，您想要使用。例如：showWaitingDialog()。然后您可以撰写BaseActivity.java，并在其中实现showWaitingDialog()。
有时您需要使用SinglePattern来实现您的代码。例如，您希望有一个User.java来管理所有用户的事情，包括登录，注销，检查是否登录。确定何时使用SinglePattern，如果您的User.java必须在许多活动中使用，并且您的记忆中必须只有一个实例。

以下示例LocationManager.java由SinglePattern编写。在我的应用中，许多活动需要呼叫位置模块，并且必须是一个实例。

public class LocationManager implements AMapLocationListener {
    public interface OnLocationCallback{
        public void onLocateSuccess(double lng, double lat, String addr);
        public void onLocateFail(int code, String info);
    }
    private static volatile LocationManager mInstance = null;
    private Context context;
    public AMapLocationClient mLocationClient = null;
    private OnLocationCallback mCallback;

    private LocationManager(Context context){
        this.context = context;
        init(this.context);
    }

    public static LocationManager getInstance(Context context){
        if(mInstance == null){
            synchronized (LocationManager.class){
                if(mInstance == null){
                    mInstance = new LocationManager(context);
                }
            }
        }
        return mInstance;
    }

    private void init(Context context){
        mLocationClient = new AMapLocationClient(context);
        mLocationClient.setLocationListener(this);
        initLocationParams();

    }
    private void initLocationParams(){
        AMapLocationClientOption mLocationOption = null;
        mLocationOption = new AMapLocationClientOption();
        mLocationOption.setLocationMode(AMapLocationClientOption.AMapLocationMode.Hight_Accuracy);
        mLocationOption.setNeedAddress(true);
        mLocationOption.setOnceLocation(true);
        mLocationOption.setWifiActiveScan(true);
        mLocationOption.setMockEnable(false);
        mLocationOption.setInterval(2000);
        mLocationClient.setLocationOption(mLocationOption);
    }

    public void startLocation(OnLocationCallback callback){
        this.mCallback = callback;
        mLocationClient.startLocation();
    }
    public void stopLocation(){
        this.mCallback = null;
        mLocationClient.stopLocation();
    }


    @Override
    public void onLocationChanged(AMapLocation amapLocation) {
        if (amapLocation != null) {
            if (amapLocation.getErrorCode() == 0) {
                amapLocation.getLocationType();
                amapLocation.getLatitude();
                amapLocation.getLongitude();
                amapLocation.getAccuracy();
                SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date date = new Date(amapLocation.getTime());
                df.format(date);
                amapLocation.getAddress();
                amapLocation.getCountry();
                amapLocation.getProvince();
                amapLocation.getCity();
                amapLocation.getDistrict();
                amapLocation.getRoad();
                amapLocation.getCityCode();
                amapLocation.getAdCode();

                if(mCallback != null){
                    mCallback.onLocateSuccess(amapLocation.getLongitude(), amapLocation.getLatitude(), amapLocation.getAddress());
                }
            } else {

                Log.e("AmapError", "location Error, ErrCode:"
                        + amapLocation.getErrorCode() + ", errInfo:"
                        + amapLocation.getErrorInfo());
                if(mCallback != null){
                    mCallback.onLocateFail(amapLocation.getErrorCode(), amapLocation.getErrorInfo());
                }
            }
        }
    }
}

通过以下方式调用：LocationManager.getInstance(getApplicationContext()).startLocation(new LocationManager.OnLocationCallback(){})

在某些情况下，你可以写一个***Manager.java类来实现一些逻辑事物。正如您提到的Calculations，您可以编写CalculationManager实现ICalculationInterface。以下是一些示例代码：

ICalculateInterface.java：

public interface ICalculateInterface {
    int add(int a, int b);
    int sub(int a, int b);
}

CalculateManager.java

public class CalculateManager implements ICalculateInterface {
    @Override
    public int add(int a, int b) {
        return 0;
    }

    @Override
    public int sub(int a, int b) {
        return 0;
    }
}

Answer 2

我建议您创建一个Utils类，您可以在其中放置适用于您的数据的所有方法。

一个Utils类的示例：

public class StringUtils {

  public static boolean isEmpty(String text) {
        return text == null || text.isEmpty() || text.trim().isEmpty();
    }
}

遵循理智模式并“外包”您可以重复使用的所有功能。

此外，如果可能，请尝试使用MVP结构，以备将来使用。

Answer 3

您可以使用abstract。

您的基地活动。

public abstract class BaseActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        activityCreated();
    }

    public abstract void activityCreated();

    protected void myMethod() {}
    protected void myMethod2() {}
    protected void Log(String txt) {}
}

MainActivity

public class MainActivity extends BaseActivity {

    @Override
    public void activityCreated() {
        myMethod2();
    }
}

Android结构：一个活动有两个类

3 个答案: