Android结构:一个活动的两个类

我是Android的新手，我正在尝试找到一个良好的应用程序结构，但我不确定该怎么做。

我有一项活动，只有一个页面收集信息并使用信息（将其推到API，计算等）。但是我根本不想将所有内容都放在MainActivity.java中，因为它会变成一个具有许多功能的长文件。因此，我希望能够从MainActivity.java调用这些功能，并在其他类中进行预成式。

是否有特定的名称或方法？如果我为相同的主要活动创建新的类别以预先从那里调用的函数，并保持MainActivity.java短而干净

，我将扩展什么类

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

将您的普通API写入***Util.java（带有静态功能），例如：FileUtil.java是一个工具类，可以写入文件管理，您可以写入
- 公共静态void savefile（字符串路径）
- 公共静态void deletefile（字符串路径）
- 公共静态void savejpeg（字符串路径，位图B）
- 公共静态void delallfiles（字符串文件夹）等等。

您可以编写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;
    }
}

我建议创建UTILS类，其中您可以将所有与数据一起使用的方法放置。

一个Utils类的示例：

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

遵循理智的模式，"外包"您可以重复使用的所有辛勤工作。

另外，如果可能的话，请尝试将MVP结构用于您的未来。

您可以使用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();
    }
}

相关内容

最新更新

热门标签：