Actionbar existiert nicht

Hallo zusammen

In meiner App habe ich eine Actionbar in welchem das Menü angezeigt wird. Wenn ich aber folgende Zeile ausführe

bar = getActionBar();
bar.setTitle("Renato");

wird es mit einer Nullpointer Exception quitiert. Aber die Actionbar wird angezeigt und das Menü kann ich ebenfalls ausführen.

Was habe ich vergessen?

package ch.robbisoft.sun_app;

import android.app.ActionBar;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.DatePickerDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.net.Uri;
import android.os.Build;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.design.widget.TabLayout;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.text.InputType;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.WindowManager;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.DatePicker;
import android.widget.EditText;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import static android.Manifest.permission.*;
import static java.lang.Math.abs;
import static java.lang.Math.floor;

public class Main extends AppCompatActivity
implements Frag_Sonne.OnFragmentInteractionListener,
Frag_Astro.OnFragmentInteractionListener,
Frag_Mond.OnFragmentInteractionListener,
AdapterView.OnItemSelectedListener {

public static final String APP = "SONNE";
public static final String FORMAT_DOUBLE = "%2.6f";
public static final String FORMAT_FLOAT = "%2.2f";
public static final String DD_MM_YYYY = "dd.MM.yyyy";
String[] rechte = new String[]{
        ACCESS_NETWORK_STATE,
        ACCESS_COARSE_LOCATION,
        ACCESS_FINE_LOCATION,
        WRITE_EXTERNAL_STORAGE,
        READ_EXTERNAL_STORAGE
};
String[] ZONE = { "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0",
"-1", "-2", "-3", "-4", "-5", "-6", "-7", "-8", "-9", "-10", "-11"};
private Spinner spi_zone;

private Context ctx;
private String str_text;
public static final int MULTIPLE_PERMISSIONS = 99;
private TextView txt_lang;
private TextView txt_breit;
private TextView txt_hoch;
private TextView txt_datum;
private Button btn_rechne;
private Animation anim_click;
private TabLayout tabulator;
private Fragment fragment = null;
private Date datum;
private Calendar kalender;
private DatePickerDialog datumdialog;

// private DatePickerDialog.OnDateSetListener listener;
private LocationManager posmanager;
private LocationListener horcher;

private Double b_breite = (double) 0;
private Double b_laenge = (double) 0;
private String str_datum = "";

//Variablen für Optionen
private int n_anzeige = 0;
private boolean b_findpos = true;
private boolean b_gps = false;
private int n_distanz = 1000;

public Integer getN_zone() {
    return n_zone;
}

public void setN_zone(Integer n_zone) {
    this.n_zone = n_zone;
}

private Integer n_zone;

public Double getB_breite() {
    return b_breite;
}

public void setB_breite(Double b_breite) {
    this.b_breite = b_breite;
}

public Double getB_laenge() {
    return b_laenge;
}

public void setB_laenge(Double b_laenge) {
    this.b_laenge = b_laenge;
}

private AlertDialog.Builder dlg_eingabe;
private EditText edt_neu;

private ActionBar bar;

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

    ctx = getApplicationContext();
    //Verhindert dass eine Tastatur angezeigt wird
    getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);

    bar = getActionBar();
    bar.setTitle("Renato");

    txt_lang = findViewById(R.id.edt_lang);
    txt_breit = findViewById(R.id.edt_breit);
    txt_hoch = findViewById(R.id.edt_hoch);
    txt_datum = findViewById(R.id.edt_datum);
    spi_zone = (Spinner) findViewById(R.id.spi_zone);
    btn_rechne = (Button) findViewById(R.id.btn_rechne);
    anim_click = AnimationUtils.loadAnimation(getApplicationContext(), R.anim.button_click);

    //Spinner aufbauen
    spi_zone.setOnItemSelectedListener(this);
    ArrayAdapter aa = new ArrayAdapter(this,android.R.layout.simple_spinner_item, ZONE);
    aa.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
    spi_zone.setAdapter(aa);

    //Tabulatoren aufbauen
    tabulator = (TabLayout) findViewById(R.id.tab_anzeige);
    TabLayout.Tab tab_sonne = tabulator.newTab();
    tab_sonne.setText(getResources().getString(R.string.lbl_sonne));
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        tab_sonne.setIcon(getDrawable(R.drawable.sun16x16));
    }
    TabLayout.Tab tab_astro = tabulator.newTab();
    tab_astro.setText(getResources().getString(R.string.lbl_astro));
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        tab_astro.setIcon(getDrawable(R.drawable.astro16x16));
    }
    TabLayout.Tab tab_mond = tabulator.newTab();
    tab_mond.setText(getResources().getString(R.string.lbl_mond));
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        tab_mond.setIcon(getDrawable(R.drawable.mond16x16));
    }
    tabulator.addTab(tab_sonne, true);
    tabulator.addTab(tab_astro);
    tabulator.addTab(tab_mond);
    //Den richtigen Tab öffnen
    tabulator.addOnTabSelectedListener((new TabLayout.BaseOnTabSelectedListener() {
        @Override
        public void onTabSelected(TabLayout.Tab tab) {
            //Selektieren der richtigen Seite
            switch (tab.getPosition()){
                case 0 :    fragment = new Frag_Sonne();
                    break;
                case 1 :    fragment = new Frag_Astro();
                    break;
                case 2 :    fragment = new Frag_Mond();
                    break;
            }
            //Parameter übergeben
            String str_breit, str_lang;
            str_breit = Double.toString(getB_breite());
            str_lang = Double.toString(getB_laenge());
            Bundle daten = new Bundle();
            daten.putString("BREITE", str_breit);
            daten.putString("LÄNGE", str_lang);
            daten.putString("DATUM", str_datum);
            daten.putString("ZONE", Integer.toString(getN_zone()));
            fragment.setArguments(daten);

            FragmentManager fm = getSupportFragmentManager();
            FragmentTransaction ft = fm.beginTransaction();
            ft.replace(R.id.simpleFrameLayout, fragment);
            ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
            ft.commit();
        }

        @Override
        public void onTabUnselected(TabLayout.Tab tab) {

        }

        @Override
        public void onTabReselected(TabLayout.Tab tab) {

        }
    }));
    //erste seite anzeigen
    fragment = new Frag_Sonne();
    FragmentManager fm = getSupportFragmentManager();
    FragmentTransaction ft = fm.beginTransaction();
    ft.replace(R.id.simpleFrameLayout, fragment);
    ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
    ft.commit();
    //Aktuelles Datum anzeigen
    SimpleDateFormat sdf = new SimpleDateFormat(DD_MM_YYYY);
    kalender = Calendar.getInstance();
    datum = kalender.getTime();
    str_datum = sdf.format(datum);
    txt_datum.setText(str_datum);
    txt_datum.setOnClickListener(new TextView.OnClickListener() {
        @Override
        public void onClick(View v) {
            int n_jahr, n_monat , n_tag;
            n_jahr = kalender.get(Calendar.YEAR);
            n_monat = kalender.get(Calendar.MONTH);
            n_tag = kalender.get(Calendar.DAY_OF_MONTH);
            v.setFocusable(true);

            datumdialog = new DatePickerDialog(Main.this, listener, n_jahr, n_monat, n_tag);
            datumdialog.show();
        }
    });

    btn_rechne.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            v.startAnimation(anim_click);
            rechne();
        }
    });

    //prüft ob OS Version > 6 ist, denn vorher kann nicht die Rechte geprüft werden
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        //prüfen ob Rechte vorhanden sind um auf die GPS Daten zu zugreifen
        if (pruefrechte()) {
            str_text = getResources().getString(R.string.lbl_start_neu);
            Toast.makeText(ctx, str_text, Toast.LENGTH_SHORT).show();
            initial();

        } else {
        }
    }else{
        str_text = getResources().getString(R.string.lbl_start_alt);
        Toast.makeText(ctx, str_text, Toast.LENGTH_SHORT).show();
        initial();
    }
    //Eingabe der länge und Breite von Hand
    txt_breit.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            String str_text;
            str_text = txt_breit.getText().toString();
            //Prüfen ob es wirklich nur eine Zahl ist
            int n_pos = str_text.indexOf("°");
            if( n_pos < 0 ){
                setB_breite(Double.parseDouble(str_text));
            }else {
                Toast.makeText(ctx, getResources().getString(R.string.txt_keineZahl), Toast.LENGTH_LONG).show();
            }
            //Tastatur schliessen
            KeyBoard.toggle(Main.this);
            zeig_pos();
            return true;
        }
    });
    txt_breit.setOnFocusChangeListener(new View.OnFocusChangeListener() {
        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            if( hasFocus ) {
                txt_breit.setText(getB_breite().toString());
            }
        }
    });

    DialogInterface.OnClickListener BpositivListener = new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            String str_wert = "";
            Double f_wert = 0.0;
            try {
                str_wert = edt_neu.getText().toString();
                f_wert = Double.parseDouble(str_wert);
            }catch (Exception e){
                Toast.makeText(ctx, getResources().getString(R.string.lbl_fehler) + ": " + e.getMessage(), Toast.LENGTH_SHORT).show();
                str_wert = getResources().getString(R.string.lbl_nottrue);
            }
            str_wert += "°";
            txt_breit.setText(str_wert);
            setB_breite(f_wert);
            KeyBoard.toggle(Main.this);
        }
    };
    DialogInterface.OnClickListener negaitvListener = new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            KeyBoard.toggle(Main.this);
        }
    };
    txt_breit.setOnClickListener(new TextView.OnClickListener() {
        @Override
        public void onClick(View v) {
            edt_neu = new EditText(Main.this);
            edt_neu.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_DECIMAL | InputType.TYPE_NUMBER_FLAG_SIGNED);
            dlg_eingabe = new AlertDialog.Builder(Main.this);
            dlg_eingabe.setTitle(getResources().getString(R.string.lbl_breit));
            dlg_eingabe.setMessage(getResources().getString(R.string.lbl_in));
            dlg_eingabe.setView(edt_neu);
            dlg_eingabe.setPositiveButton(getResources().getString(R.string.lbl_speichern), BpositivListener);
            dlg_eingabe.setNegativeButton(getResources().getString(R.string.lbl_verlassen), negaitvListener);
            dlg_eingabe.show();
        }
    });
    txt_lang.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            String str_text;
            str_text = txt_lang.getText().toString();
            int n_pos = str_text.indexOf("°");
            if( n_pos < 0) {
                setB_laenge(Double.parseDouble(str_text));
            }else{
                Toast.makeText(ctx, getResources().getString(R.string.txt_keineZahl), Toast.LENGTH_LONG).show();
            }
            setN_zone(Astronomy.zeitzone(b_laenge));
            spi_zone.setSelection(getpos_zone(n_zone));
            //Tastatur schliessen
            KeyBoard.toggle(Main.this);
            zeig_pos();
            return true;
        }
    });
    txt_lang.setOnFocusChangeListener(new TextView.OnFocusChangeListener() {
        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            if( hasFocus ) {
                txt_lang.setText(getB_laenge().toString());
            }
        }
    });
    DialogInterface.OnClickListener LpositivListener = new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            String str_wert = "";
            Double f_wert = 0.0;
            try {
                str_wert = edt_neu.getText().toString();
                f_wert = Double.parseDouble(str_wert);
            }catch (Exception e){
                Toast.makeText(ctx, getResources().getString(R.string.lbl_fehler) + ": " + e.getMessage(), Toast.LENGTH_SHORT).show();
                str_wert = getResources().getString(R.string.lbl_nottrue);
            }
            str_wert += "°";
            txt_lang.setText(str_wert);
            setB_laenge(f_wert);
            setN_zone(Astronomy.zeitzone(b_laenge));
            spi_zone.setSelection(getpos_zone(n_zone));
            KeyBoard.toggle(Main.this);
        }
    };
    txt_lang.setOnClickListener(new TextView.OnClickListener() {
        @Override
        public void onClick(View v) {
            edt_neu = new EditText(Main.this);
            edt_neu.setInputType(InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_DECIMAL | InputType.TYPE_NUMBER_FLAG_SIGNED);
            dlg_eingabe = new AlertDialog.Builder(Main.this);
            dlg_eingabe.setTitle(getResources().getString(R.string.lbl_lang));
            dlg_eingabe.setMessage(getResources().getString(R.string.lbl_in));
            dlg_eingabe.setView(edt_neu);
            dlg_eingabe.setPositiveButton(getResources().getString(R.string.lbl_speichern), LpositivListener);
            dlg_eingabe.setNegativeButton(getResources().getString(R.string.lbl_verlassen), negaitvListener);
            dlg_eingabe.show();
        }
    });
    //Fokus auf Datumseingabe gesetzt
    txt_datum.requestFocus(1);
    //Aktuelle Position setzen
    spi_zone.setSelection(getpos_zone(n_zone));
}

/**********************************************************************************************
* Ermittelt die Posiotn
 * Formatierung der Höhenausgabe gemacht
*
* @author robbisoft @since 19. März 2020
* @param
* @return
**********************************************************************************************/
private void position(){
    posmanager = (LocationManager) getSystemService(LOCATION_SERVICE);
    horcher = new LocationListener() {
        @Override
        public void onLocationChanged(Location location) {
            Double lang = location.getLongitude();
            Double breit = location.getLatitude();
            Double hoch = (double) 0;
            if( location.hasAltitude() )
                hoch = location.getAltitude() - location.getAccuracy();

            setB_breite( breit );
            setB_laenge( lang );
            zeig_pos();
            txt_hoch.setText(String.format(FORMAT_FLOAT, hoch));
        }

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

        }

        @Override
        public void onProviderEnabled(String provider) {

        }

        @Override
        public void onProviderDisabled(String provider) {

        }
    };
    //Position wird gesucht
    if( b_gps ) { //genau
        posmanager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, n_distanz, (LocationListener) horcher);
    }else { //ungenau
        posmanager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, n_distanz, (LocationListener) horcher);
    }
}

/**********************************************************************************************
* Ermittelt die Position, berechnet die Daten und stellt die ergebnisse dar
*
* @author robbisoft @since 2. Juni 2019
* @param
* @return
**********************************************************************************************/
private void initial(){
    //Gespeicherte Position lesen damit sofort was angezeigt wird
    lese_daten();
    Double b_breit = getB_breite();
    Double b_lang = getB_laenge();
    zeig_pos();
    setN_zone(Astronomy.zeitzone(b_lang));
    //Position ermitteln nur wenn gewünscht Optionen
    if( b_findpos ) {
        position();
    }
    //Parameter übergeben
    String str_breit, str_lang;
    str_breit = Double.toString(b_breit);
    str_lang = Double.toString(b_lang);
    Bundle daten = new Bundle();
    daten.putString("BREITE", str_breit);
    daten.putString("LÄNGE", str_lang);
    daten.putString("DATUM", str_datum);
    daten.putString("ZONE", Integer.toString(n_zone));
    fragment.setArguments(daten);
}

/**********************************************************************************************
* Prüft die Rechte der App
*
* @author robbisoft @since 7. Juni 2019
* @param
* @return
**********************************************************************************************/
private boolean pruefrechte(){
    int result;
    List listPermissionsNeeded = new ArrayList<>();
    for (String p:rechte)
    {
        result = ContextCompat.checkSelfPermission(this,p);
        if (result != PackageManager.PERMISSION_GRANTED)
        {
            listPermissionsNeeded.add(p);
        }
    }
    if (!listPermissionsNeeded.isEmpty())
    {
        ActivityCompat.requestPermissions(this, (String[]) listPermissionsNeeded.toArray(new String[listPermissionsNeeded.size()]),MULTIPLE_PERMISSIONS );
        // keine permissions gesetzt
        return false;
    }
    // alle permissions gesetzt
    return true;
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    switch (requestCode)
    {
        case MULTIPLE_PERMISSIONS:
        {
            if (grantResults.length > 0)
            {
                String permissionsDenied = getResources().getString(R.string.lbl_permission);
                for (String per : permissions)
                {
                    if(grantResults[0] == PackageManager.PERMISSION_DENIED)
                    {
                        permissionsDenied += "\n" + per;
                        Toast.makeText(ctx, permissionsDenied, Toast.LENGTH_LONG).show();
                    }
                }
                // Nach dem ersten Male
            }
            return;
        }
    }
}

@Override
public void onFragmentInteraction(Uri uri) {

}

@Override
public void onFragSelectet(int position) {
    Frag_Sonne frag_sonne = (Frag_Sonne)
            getSupportFragmentManager().findFragmentById(R.id.txt_dam_begin_wert);
    if(frag_sonne != null){

// frag_sonne.update_sonne( position );
}else{

    }
}

@Override
public void onPointerCaptureChanged(boolean hasCapture) {

}

@Override
protected void onDestroy() {
    super.onDestroy();

    double breit, lang;
    breit = getB_breite();
    lang = getB_laenge();
    schreibe_daten(breit, lang);
}

/**********************************************************************************************
* Liest die Daten aus dem Speicher
*
* @author robbisoft @since 8. Juni 2019
* @param
* @return
**********************************************************************************************/
private void lese_daten(){
    float breit, lang;
    SharedPreferences pref = getSharedPreferences(APP, 0);
    breit = pref.getFloat("BREIT", 0);
    setB_breite((double) breit);
    lang = pref.getFloat("LANG", 0);
    setB_laenge((double) lang);
    n_anzeige = pref.getInt("ANZEIGE", 0);
    b_findpos = pref.getBoolean("FINDPOS", true);
    b_gps = pref.getBoolean("GPS", false);
    n_distanz = pref.getInt("DISTANZ", 1000);
}

/**********************************************************************************************
* Schreibt die Daten in den Speicher
*
* @author robbisoft @since 28. August 2019
* @param 'Länge und Breite der aktuellen Position
* @return
**********************************************************************************************/
private void schreibe_daten(double breit, double lang){
    SharedPreferences pref = getSharedPreferences(APP, 0);
    SharedPreferences.Editor edit = pref.edit();
    edit.putFloat("BREIT", (float) breit);
    edit.putFloat("LANG", (float) lang);
    edit.putInt("ANZEIGE", n_anzeige);
    edit.putBoolean("FINDPOS", b_findpos);
    edit.putBoolean("GPS", b_gps);
    edit.putInt("DISTANZ", n_distanz);
    edit.commit();
}

/**********************************************************************************************
* Übergiebt die Parameter für die Fragmente
*
* @author robbisoft  @since 18. Juli 2019
* @param 'Breitengrad der Position
* @param 'Längengrad der Position
* @param 'Datum zum Berechnen
* @return
* @exception
* @throws
**********************************************************************************************/
private void rechne(){
    //Parameter übergeben
    String str_breit, str_lang;
    str_breit = Double.toString(getB_breite());
    str_lang = Double.toString(getB_laenge());
    Bundle daten = new Bundle();
    daten.putString("BREITE", str_breit);
    daten.putString("LÄNGE", str_lang);
    daten.putString("DATUM", str_datum);
    daten.putString("ZONE", Integer.toString(getN_zone()));
    fragment.setArguments(daten);
    if(fragment instanceof Frag_Sonne){
        ((Frag_Sonne) fragment).update_sonne(b_breite, b_laenge, datum, n_zone);
    }
    if(fragment instanceof Frag_Astro){
        ((Frag_Astro) fragment).update_astro(b_breite, b_laenge, datum, n_zone);
    }
    if(fragment instanceof Frag_Mond){
        ((Frag_Mond) fragment).update_mond(b_breite, b_laenge, datum, n_zone);
    }
}

@Override
public void onAttachFragment(Fragment fragment) {
    super.onAttachFragment(fragment);
    if (fragment instanceof Frag_Sonne) {
        Frag_Sonne frag = (Frag_Sonne) fragment;
        frag.setOnFragmentInteractionListener(this);
    }

}

@Override
protected void onStart() {
    super.onStart();
}

@Override
protected void onResume() {
    super.onResume();
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.menu_main, menu);
    return super.onCreateOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    int id = item.getItemId();
    switch (id){
        case R.id.mnu_optionen : {
            Intent AufRuf = new Intent(ctx, Optionen.class);

// startActivity(new Intent(ctx, Optionen.class));
AufRuf.putExtra("anzeige", n_anzeige);
AufRuf.putExtra("findpos", b_findpos);
AufRuf.putExtra("gps", b_gps);
AufRuf.putExtra("distanz", n_distanz);
startActivityForResult( AufRuf, 1 );
return true;
}
case R.id.mnu_savepos : {
Intent AufRuf = new Intent(ctx, SaveActivity.class);
AufRuf.putExtra("breit", b_breite);
AufRuf.putExtra("lang", b_laenge);
startActivity(AufRuf);
return true;
}
case R.id.mnu_loadpos : {
Intent AufRuf = new Intent(ctx, LoadActivity.class);
startActivityForResult(AufRuf, 2);
return true;
}
default : return super.onOptionsItemSelected(item);
}
}

@Override
public void onItemSelected(AdapterView<?> parent, View view, int n_position, long id) {
    int n_wer = parent.getId();
    switch ( n_wer){
        case R.id.spi_zone : {
            String item = parent.getItemAtPosition(n_position).toString();
            setN_zone(Integer.parseInt(item));
            rechne();
        }
    }
}

@Override
public void onNothingSelected(AdapterView<?> parent) {

}

/**********************************************************************************************
* Ermittelt die Position innerhalb des Arrays um den Spinner zu setzen
 * Negatige Zahlen sollen ebenfalls berücksichtigt werden
*
* @author robbisoft  @since 10. Mai 2020
* @param Aktuelle Zeitzone
* @return Position innerhalb vom Array
* @exception keine
* @throws keine
**********************************************************************************************/
private int getpos_zone( int n_aktuelle_zone ){
    int n_pos = 12;
    int n_pool = 0;
    String str_zone = null;

    for(int i=0; i < 24 ;i++){
        str_zone = ZONE[i].toString();
        n_pool = Integer.parseInt(str_zone);
        if(n_pool == n_aktuelle_zone){
            n_pos = i;
            return n_pos;
        }
    }

    return n_pos;
}

/**********************************************************************************************
* Berechnet die Position in Grad und Stunden und gibt alles als String zurück
*
* @author robbisoft  @since 27. August 2019
* @param Position in double
* @return Position in Grad und Stunden
* @exception
* @throws
**********************************************************************************************/
private String pos2hhmm ( double b_position) {
    String str_text = null;
    int stunde;
    double minute;

    if( b_position < 0) {
        stunde = (int) floor(b_position);
        b_position += (stunde * -1);
        minute = (double) (b_position * -60);
    }else{
        stunde = (int) floor(b_position);
        b_position -= stunde;
        minute = (double) b_position * 60;
    }
    str_text = Integer.toString(stunde);
    str_text += "°";
    str_text += String.format(FORMAT_FLOAT, minute);
    str_text += "'";

    return str_text;
}

/**********************************************************************************************
* Berechnet die Position in Grad Stunden und minuten um und gibt alles als String zurück
*
* @author robbisoft  @since 27. August 2019
* @param Position
* @return String in Grad Minuten und Sekunden
* @exception
* @throws
**********************************************************************************************/
private String pos2hhmmss ( double b_position ){
    String str_text = null;
    int stunde, minute;
    double sekunde;

    if( b_position < 0) {
        stunde = (int) floor(b_position);
        b_position += (stunde * -1);
        b_position *= -60;
        minute = (int) floor(b_position);
        b_position += (minute * -1);
        sekunde = (double) b_position * -60;
    }else{
        stunde = (int) floor(b_position);
        b_position -= stunde;
        b_position *= 60;
        minute = (int) floor(b_position);
        b_position -= minute;
        sekunde = (double) b_position * 60;
    }
    str_text = Integer.toString(stunde);
    str_text += "°";
    str_text += Integer.toString(minute);
    str_text += "'";
    str_text += String.format(FORMAT_FLOAT, sekunde);
    str_text += "''";

    return str_text;
}

/**********************************************************************************************
* Gibt die Position als String zurück
*
* @author robbisoft  @since 27. August 2019
* @param Position
* @return String in Grad
* @exception
* @throws
**********************************************************************************************/
private String pos2string ( double b_position ) {
    String str_text = null;

    str_text = String.format(FORMAT_DOUBLE, b_position);
    str_text += "°";

    return str_text;
}

/**********************************************************************************************
* Gibt die Position als String zurück je nach option
*
* @author robbisoft  @since 27. August 2019
* @param Position
* @param welcher String soll ausgegeben werden
* @return zusammengesetzter String
* @exception
* @throws
**********************************************************************************************/
private String pos2str ( double d_pos, int n_was ) {
    switch ( n_was ){
        case 0 : return pos2string(d_pos);
        case 1 : return pos2hhmm(d_pos);
        case 2 : return pos2hhmmss(d_pos);
        default: return pos2string(d_pos);
    }
}

/**********************************************************************************************
* Stellt die Position in den Feldern an
 * Erweiterung mit dem Ermitteln der Zeitzone
 *
* @author robbisoft  @since 16. März 2020
* @param
* @return
* @exception
* @throws
**********************************************************************************************/
private void zeig_pos(){
    txt_lang.setText(pos2str(getB_laenge(), n_anzeige));
    txt_breit.setText(pos2str(getB_breite(), n_anzeige));
    setN_zone(Astronomy.zeitzone(b_laenge));
    spi_zone.setSelection(getpos_zone(n_zone));
}

@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    switch (requestCode){
        case 1 : {
            if(resultCode == Activity.RESULT_OK && data != null) {
                n_anzeige = data.getIntExtra("anzeige", 0);
                b_findpos = data.getBooleanExtra("findpos", true);
                b_gps = data.getBooleanExtra("gps", true);
                n_distanz = data.getIntExtra("distanz", 1000);
                zeig_pos();
            }
            break;
        }
        case 2 : {
            Double ort_breit, ort_lang;
            try {
                if(resultCode == Activity.RESULT_OK && data != null) {
                    ort_breit = data.getDoubleExtra("ort_breit", 0);
                    ort_lang = data.getDoubleExtra("ort_lang", 0);
                    setB_breite(ort_breit);
                    setB_laenge(ort_lang);
                    zeig_pos();
                    rechne();
                }
            }catch (Exception e){
                String str_meldung = getResources().getString(R.string.lbl_fehler);
                str_meldung += " " + e.getMessage();
                Toast.makeText(ctx, str_meldung, Toast.LENGTH_LONG).show();
            }
        }
    }
}

//Beim anklicken Datumsdialog anzeigen
private DatePickerDialog.OnDateSetListener listener = new DatePickerDialog.OnDateSetListener() {
    @Override
    public void onDateSet(DatePicker view, int year, int month, int dayOfMonth) {
        //gewähltes Datum setzen
        SimpleDateFormat sdf = new SimpleDateFormat(DD_MM_YYYY);
        kalender.set(year, month, dayOfMonth);
        datum = kalender.getTime();
        str_datum = sdf.format(datum);
        txt_datum.setText(str_datum);
        rechne();
    }
};

}

Gruss Renato