Java 在android Studio中调用类函数

我正在做一个有GPS课程的项目

我知道要调用类，我必须使用类的瞬间

像这样的

GPS insgps = new GPS();
if (insgps .canGetLocation())
{/* Do Something */}

但是当我尝试使用这个代码时，我得到了一个错误

GPS在“com.myapp.locationapp.app.GPS”中有私人访问权。

我不知道为什么以及如何解决这个问题

这是我使用的类

        import android.Manifest;
        import android.app.Activity;
        import android.app.AlertDialog;
        import android.content.Context;
        import android.content.DialogInterface;
        import android.content.Intent;
        import android.content.pm.PackageManager;
        import android.location.Location;
        import android.location.LocationListener;
        import android.location.LocationManager;
        import android.os.Bundle;
        import android.provider.Settings;
        import android.support.v4.app.ActivityCompat;

public final class GPS implements LocationListener, ActivityCompat.OnRequestPermissionsResultCallback {
    private static GPS _instance = new GPS();
    private static Activity _activity;

    private static boolean _isGPSEnabled = false;
    private static boolean _isNetworkEnabled = false;
    private static boolean _canGetLocation = false;
    private static boolean _isPermissionEnabled = false;

    private Location _location;
    private double _latitude;
    private double _longitude;

    private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 1; // 10 meters
    private static final long MIN_TIME_BW_UPDATES = 1; // 1 minute

    private static LocationManager _locationManager;

    private LocationPermissionResponseListener _locationPermissionListener;
    public static final int LOCATION_REQUEST_CODE = 200;

    private GPS() {}

    public static GPS sharedInstance(Activity activity) {
        _activity = activity;
        _locationManager = (LocationManager) _activity.getSystemService(Context.LOCATION_SERVICE);
        _isGPSEnabled = _locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
        _isNetworkEnabled = _locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);

        if (!_isGPSEnabled && !_isNetworkEnabled) {
            _canGetLocation = false;
        } else {
            _canGetLocation = true;
        }

        if (ActivityCompat.checkSelfPermission(_activity, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            _isPermissionEnabled = false;
        } else {
            _isPermissionEnabled = true;
        }

        return _instance;
    }

    public Location getLastKnownLocation() {
        if (ActivityCompat.checkSelfPermission(_activity, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            _isPermissionEnabled = false;
        } else {
            if (_canGetLocation) {
                if (_isNetworkEnabled) {
                    _locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, MIN_TIME_BW_UPDATES, MIN_DISTANCE_CHANGE_FOR_UPDATES, this);

                    if (_locationManager != null) {
                        _location = _locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

                        if (_location != null) {
                            _latitude = _location.getLatitude();
                            _longitude = _location.getLongitude();
                        }
                    }
                }

                if (_isGPSEnabled) {
                    if (_location == null) {
                        _locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, MIN_TIME_BW_UPDATES, MIN_DISTANCE_CHANGE_FOR_UPDATES, this);

                        if (_locationManager != null) {
                            _location = _locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);

                            if (_location != null) {
                                _latitude = _location.getLatitude();
                                _longitude = _location.getLongitude();
                            }
                        }
                    }
                }
            }
        }

        return _location;
    }

    public void stopUsingGPS() {
        if (_locationManager != null) {
            if (ActivityCompat.checkSelfPermission(_activity, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
                _locationManager.removeUpdates(GPS.this);
            }
        }
    }

    public double getLatitude() {
        if (_locationManager != null) {
            _latitude = _location.getLatitude();
        }

        return _latitude;
    }

    public double getLongitude() {
        if (_locationManager != null) {
            _longitude = _location.getLongitude();
        }

        return _longitude;
    }

    public boolean canGetLocation() {
        return _canGetLocation;
    }

    public boolean isPermissionEnabled() {
        return _isPermissionEnabled;
    }

    public void showSettingsAlert() {
        AlertDialog.Builder alertDialog = new AlertDialog.Builder(_activity);
        alertDialog.setTitle("GPS Settings");
        alertDialog.setMessage("GPS is not enabled. Do you want to go to settings menu ?");

        alertDialog.setPositiveButton("Settings",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        Intent intent = new Intent(
                                Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                        _activity.startActivity(intent);
                    }
                });

        alertDialog.setNegativeButton("Cancel",
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        dialog.cancel();
                    }
                });

        alertDialog.show();
    }

    public void requestLocationPermission(LocationPermissionResponseListener listener) {
        _locationPermissionListener = listener;

        ActivityCompat.requestPermissions(_activity, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, LOCATION_REQUEST_CODE);
    }

    @Override
    public void onLocationChanged(Location location) {
        this._location = location;
    }

    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {

    }

    @Override
    public void onProviderDisabled(String provider) {

    }

    @Override
    public void onProviderEnabled(String provider) {

    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        switch (requestCode) {
            case GPS.LOCATION_REQUEST_CODE: {
                _locationPermissionListener.onResponse(grantResults[0] == PackageManager.PERMISSION_GRANTED);
            }
        }
    }

    public static interface LocationPermissionResponseListener {
        public void onResponse(Boolean permissionGranted);
    }

    }

---

您的构造函数是私有的：

private GPS() {}

这需要公开

public GPS() {}

尽管如此，您的类似乎正在使用共享实例函数，因此您可能需要：

GPS insgps = GPS.sharedInstance([myactivitycontext]);

---

从外观上看，

GPS

是一个单例类

有一个类型为

GPS

的私有静态字段

\u实例

，还有一个名为

sharedInstance（Activity）

的静态方法。这些是单体的特点

单例类基本上意味着在运行时该类只有一个实例。在本例中，它是

\u实例

。不允许创建

GPS

的其他实例。这就是为什么构造函数被标记为private，使您无法访问它

因为如果出现这种情况，则不应创建

GPS

的新实例。相反，您应该通过调用方法

sharedInstance

来访问仅有的一个实例

GPS insgps = GPS.sharedInstance(anActivity);

---

如果您在

活动

的子类中编写此代码，请将上面的

活动

替换为

此

。如果您正在其他类中编写此代码，请获取

Activity

的实例，并用它替换

anActivity

。

将构造函数

private GPS（）{}

更改为

public GPS（）{}

。或者，如果您想访问静态方法，请确保该方法也是公共的，并将其称为

GPS.yourMethod（）