Cannot resolve Symbol Fehler,.... Hilfe!!!

Y

YouKnowNow

Neues Mitglied
0
Hallo ich hab ein Problem Unzwar bin ich ein Anfänger und will wissen warum EXTRA_MESSAGE rot ist und was der blau geschriebene Paragraph bedeutet:
MainActivity.java

Code:
package com.youknownow.myfirstapp;

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;

public class MainActivity extends AppCompatActivity {

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

    public void sendMessage(View view) {
        Intent intent = new Intent(this, DisplayMessageActivity.class);
        EditText editText = (EditText) findViewById(R.id.edit_message);
        String message = editText.getText().toString();
        intent.putExtra(EXTRA_MESSAGE, message);
        startActivity(intent);
    }

}

activity_main.xml
Code:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal">

    <EditText android:id="@+id/edit_message"
        android:layout_weight="1"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:hint="@string/edit_message"
        />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/button_send"
        android:onClick="sendMessage"
         />
</LinearLayout>

Danke
 
Zuletzt bearbeitet von einem Moderator:
Bearbeitet von: Kiwi++Soft - Grund: Bitte Code-Tags verwenden!
EXTRA_MESSAGE ist eine selbst definierte Konstante. Sprich schreibe am Anfang der Klasse:
public static final String EXTRA_MESSAGE = "extra_message";

Der Rest ist recht einfach. Mit dem blauen Text startest du eine neue Activity (in dem Fall die Activity mit dem Namen DisplayMessageActivity).

Mit dem Aufruf intent.putExtra(EXTRA_MESSAGE, message); übergibts du ein Wert an die neue Activity. EXTRA_MESSAGE ist der Key.

Genaue Erklärung:
Googles Android/ Intents oder "Ich hätte gern den Zucker" – Wikibooks, Sammlung freier Lehr-, Sach- und Fachbücher
Intents and Intent Filters | Android Developers
 
@markus.tullius Danke Markus Das hatte ich Schon vorher verstanden Aber Meine Eigentliche Frage was Was Genau ein Intent ist(sorry hab mich nicht richtig aus gedrückt) und hättest du kurz Zeit dir meine neue Frage anzuschauen und mir da evtl. zu helfen...
 
Markus hat dir doch extra zwei Links mitgeschickt.
 
Hallo, ich weis, das mit den Intents ist nicht einfach zu verstehen, da helfen oft keine Links.

Ein Intent ist ein Paket an Daten, das an eine andere APP oder an das Android System mitgegeben werden.

startActivity(intent);

das ruft eine Android-Funktion zum starten von APP auf. Diese Funktion kann aber nicht wissen welche APP nun gestartet werden soll, darum muss man diese Information irgendwie mitgeben. Das hätte man auch klassisch machen können foo(par1, par2,par3, ... ) Dies wäre aber sehr unflexibel gewesen. Darum hat man die Intens erfunden. Ein Intent ist im Grunde eine erweiterte HashMap und enthält Schlüsselwort, Werte Paare. Damit lassen sich fast beliebig viele Daten übergeben. Man kann dem Intent auch eigenen Daten mitgeben. Dafür ist aber ein Extra Datenpaket gedacht, Das Bundle, das ist im Grunde auch nur eine Hashmap, hat aber eineige Funktionen die es einem erleichtern Schlüsselwort, Werte Paare zu übergeben und wieder auszulesen.

mit dieser Funktion startet man auch eigenen zusätzliche Activities.


Hier einen Code Schnipsel aus meinem launcher. Wird von einer anderer APP an meinen Launcher ein Intent geschickt kommt dieser bei der funktion onNewIntent an. Mein Launcher reakiert dann. Und wie du siehst frage ich nach der Existenz des Bundle im Intent. Mit "intent.getExtras". Weiter unten siehst du das ich nach bestimmten Schlüsseln suche. if(bundle.getBoolean("android.intent.extra.FROM_HOME_KEY",false);
Die Schlüssel sind immer Texte in diesem Fall "android.intent.extra.FROM_HOME_KEY".
false ist der Wert der zurück gegeben wird wenn der Schlüssel nicht enthalten ist.
KEY_HOME_PAGE ist ebenfalls ein Text, dieser ist in der APP ganz oben definiert.
static final String KEY_HOME_PAGE = "net.dinglisch.android.tasker.extras.HOME_PAGE";
Statische Variable werden in der regel immer komplett in Großbuchstaben geschrieben;
page = bundle.getInt(KEY_HOME_PAGE); liest den Integer aus der HasMap aus.
Du kannst die Schlüssel, Wertepaare in den Intent(Bundle) beleibig selbst definieren, jedoch wenn du andere APP Daten schicken möchtest musst du nachschauen wie die Schlüssel heißen.

Ich hoffe, dass dir nun klar wurde, was ein Intent ist und wozu er dient. Er dient dem mitgeben von Daten an eine andere APP.
Achso, das Mit den Intents, das war auch für mich das schwierigste Kapitel in der Android Programmierung. :biggrin:
Wen du noch fragen hast, dann frag und wenn ich es weis, dann helf ich dir gerne.

Code:
protected void onNewIntent(Intent intent) {
    ......
    Bundle bundle = intent.getExtras();
    if(bundle != null){
        if(bundle.getBoolean("android.intent.extra.FROM_HOME_KEY",false) ){
            openOptionsMenu();
            restoreScreenOptions = false;
        }

        if(bundle.containsKey(KEY_HOME_PAGE) ){
            page = bundle.getInt(KEY_HOME_PAGE);
            desktop.restore();
        }
    }
 
Zuletzt bearbeitet von einem Moderator:
Bearbeitet von: Kiwi++Soft - Grund: Bitte Code-Tags verwenden!
@Nonsens,
auch dir empfehle die beiden Links. Einfach mal durch lesen, und ausprobieren.
Das ganze hat nichts mit HashMaps zu tun (Wer Zeiger braucht, sollte C++ programmieren. ;) ). Google mal nach dem Begriff "Warteschlange", dies ist das Konzept dahinter.
Intent (Absicht) sagt schon alles. Du schickt eine "Absicht" los. Wenn es jemand gibt, der auf die "Absicht" hört (Receiver, Intentfilter), kann dieser darauf reagieren. Receiver kann man im Code oder im Android Manifest deklarieren.
Bei startActivity(intent) hat man die Absicht eine neue Activity zu starten (wird im Manifest deklariert).

Zusätzlich kann man dem Intent Daten in Form eines Bundle übergeben. Das ist eine Art Container für Daten (Parcel).

Noch ein kleiner Tipp am Rande. Nur weil man etwas kennt (HashMap), muss es nicht überall auftauchen. Häufig sieht bei den Versuch Ähnlichkeiten zu erkennen, den Wald vor lauter Bäume nicht mehr. ;)
 
Zuletzt bearbeitet:
@markus.tullius

Du hast recht, meine Beschreibung war da wohl etwas zu verallgemeinernd. :biggrin:

Hier Details:
Bundle extends BaseBundle
BaseBundle arbeitet intern mit ArrayMap
ArrayMap implements Map.
HashMap implements Map
Und ein Intent kann das Objekt Bundle enhalten.
Damit wäre die Verwandschaft doch bewiesen, da beide von der interface Klasse Map "erben" :biggrin:

Nun, man kann den Intent auch mit einem Adressaufkleber vergleichen mit der Option zusätzlicher Zeilen. Und das Bundle wäre dann das Packet selbst. Und Android wäre die Post.

Grüße
 
markus.tullius schrieb:
WifiConfiguration implements Parceable

Eigentlich sind dann alle Klassen miteinander Verwandt, da alle von der Klasse Objekt erben. ;)

Richtig, Aber in dem Fall geht es um die spezielle Funktionsweise einer HashMap bzw. eines Bundle.

Ich hab da noch einen interessanten Vergleich:

"Im Grunde sind Mercedes, BMW, Opel, Audi alle "gleich", es sind alles Autos".

In Java würde das dann so aussehen:
Class Mercedes implements Auto
Class BMW implements Auto
Class Audi implements Auto

Alle drei Klassen können dann der Funktion

void fahrer(Auto object){...} übergeben werden. Die drei Klassen sind also "verwand" weil sie die selben Funktionen die der Fahrer braucht, enthalten. Und genau das ist der Sinn einer Interface-Klasse, damit die drei Klassen als Klasse vom Typ "Auto" verwendet werden können "müssen" sie die Funktionen die in der Interface-Klasse definiert wurden, enthalten. "Vererbt" wird, im Gegensatz zu einer abstrakten Klasse, nichts.

Und so funktioiert das Bundle "Grundsätzlich" wie eine HashMap. Dabei ist es irrelevant ob in der Klasse Bundle intern nun eine HasMap verwendet wird oder ob da alles neu codiert ist.

Hier noch ein Beispiel da sieht man ganz deutlich die Verwandschaft:

HashMap hashmap = new Hashmap();
Bundle bundle = new Bundle();

String key = "schlüssel wort"
int wert = 5;

hashmap.put(key, wert);
bundle.putInt(key, wert);


wert = (int) hashmap.get(key); // cast notwendig wenn flexiebel
wert = bundle.getInt(key); // kein cast notwendig

Beim Bundle kann man noch einen Wert angeben wenn der Key nicht enthalten ist, das erspart einem viele IF-Anweisungen
int wert = bundle.getInt(key,5);

Bei einer HashMap müsste dann das folgen:
if(wert == null) wert = 5;

Das Bundle tut im Prinzip genau das selbe wie eine HashMap. Schlüssel, Wert Paare speichern. Nur im Bundle ist man da viel flexiebler.

Grüße :biggrin:
 
Sage ich doch, das findet jemand trotz den ganzen Maps den Wald nicht mehr.

Wenn ich alle Klassen in Android zusammen nehme, die eine ArrayList benutzen, und behaupte, die machen alle das gleiche, werde ich wahrscheinlich gesteinigt.
Überspitz könnte man das auch über alle Klasse sagen, die ein String benutzen.

Und in deinem Beispiel, wird nicht mal eine Hashmap benutzt.

Beispiel:

In eine Garage steht ein Auto. Auto ist ein Fahrzeug. Ein Dreirad ist ein Fahrzeug. -> Eigentlich ist eine Garage ein Dreirad.
Intent benutzt ArrayMap. ArrayMap implements Map. HashMap implements Map.
 
markus.tullius schrieb:
In eine Garage steht ein Auto. Auto ist ein Fahrzeug. Ein Dreirad ist ein Fahrzeug. -> Eigentlich ist eine Garage ein Dreirad.
Intent benutzt ArrayMap. ArrayMap implements Map. HashMap implements Map.

Da hast du dir jetzt ein Mächtiges Ei gelegt:lol:

Garage = Gebäude = Container ~ View.
Garage kann keine Eigenschaften von Fahrzeug erben weil es mit Fahrzeug (Außer Gegenstand) keine Gemeinsamkeiten hat.
Auto und Dreirad haben gemeinsame Eigenschaften und diese können entweder per abstrakter Klasse "vererbt" werden oder per interface "definiert" sein.

Ein Objekt "erbt" nie von enthaltenen Objekten. Auch das Auto "erbt" nichts von der Garage. Erben kann man immer nur Eigenschaften die gemeinsam sind und als gemeinsame Eigenschaft über eine abstrakte Klasse "vererbt" werden oder als zu codierende Eigenschaften in einem Interface definiert werden. So dass, um beim deinem Beispiel zu bleiben. Ein Abschleppwagen, selbst ein Fahrzeug, kann Fahrzeuge abschleppen. Um also das Auto oder das Dreirad abschleppen zu können müssen sie entweder
class Auto extends Fahrzeug
oder
class Auto implements Fahrzeug sein.

Dann kann die Klasse Abschleppwagen so aussehen der Funktion abschleppen() könnte die Garage also nicht übergeben werden.

Class Abschleppwagen implements Fahrzeug {
void abschleppen(Fahrzeug fahrzeug){ ... }

}

Aber da auch Flugzeuge abschleppen können würe auch dies möglich:
Class Abschleppwagen implements Fahrzeug, Abschleppen

Frage, Was meine ich mit dem Wort "grundsätzlich" ?


Grüße :biggrin:
 
Zuletzt bearbeitet von einem Moderator:
:D Leider bin ich nicht der Osterhase, mit den Weihnachtsmann hätte mich ja anfreunden können.

Code:
    public class MeineGarage extends Object {
        private Dreirad kinderDreirad;    
        public MeineGarage() {
            kinderDreirad = new Dreirad();
        }
        public MeineGarage(Dreirad dreirad) {
            kinderDreirad = dreirad;
        }

    }
    public class Dreirad implements Fahrzeug {
       @Override
        public void bewegen() {
        }
    }
    public interface Fahrzeug {
       void bewegen();
    }
    public class Schiff implements Fahrzeug {
        @Override
        public void bewegen() {        
        }
    }

Oder anders:
Code:
    public class Intent extends Objekt {
        private Bundle mExtras;

       // Und hier ist sogar eine Arraylist :)
        public <T extends Parcelable> ArrayList<T> getParcelableArrayListExtra(String name) {
              return mExtras == null ? null : mExtras.<T>getParcelableArrayList(name);
       }   

    }

   public class Bundel extends BaseBundle {
       
    }
    public class BaseBundle {
          ArrayMap<String, Object> mMap = null;
    }

   public class ArrayMap implements Map {
        @Override
        public void clear() {
        }
    }

    public interface Map {
       void clear(); //und andere Methoden
    }
 
    public class HashMap implements Map {
       @Override
        public void clear() {
        }
    }
[doublepost=1476387734,1476387641][/doublepost]Oder anders gesagt, alle Wege führen nach Rom. :)
 
Zuletzt bearbeitet:
Code:
    public class MeineGarage extends Object {
        private Dreirad kinderDreirad;   
        public MeineGarage() {
            kinderDreirad = new Dreirad();
        }
        public MeineGarage(Dreirad dreirad) {
            kinderDreirad = dreirad;
        }

Ich würde das so machen. Dann kann das Dreirad und das Schiff eingeparkt und bewegt werden.
Der Sinn eines Interfaces ist, dass man eine Klasse mit dem Klassennamen das Interfaces ansprechen kann.

Code:
    public class MeineGarage extends Gebaude {
        Fahrzeug fahrzeug;   
        
        public einparken(Fahrzeug obj) {
            fahrzeug = obj;
        }

        public bewegen(){
           fahrzeug.bewegen();
       }
 
:lol:

Noch ein Info zu dem Thema.
Java vererbt über Daten-Typen. D.h mit einem Interface definiert man ein eigenen Daten-Typ, der nicht von Objekt erbt. (Ein Interface kann Methoden haben, muss es aber nicht.) Es die einzige Möglichkeit in Java, Mehrfachvererbungen zu implementieren.
Eine gute Methode, wenn man Objekt in eine Methode übergeben will, obwohl es nicht vorgesehen ist (Man verändert einfach den Datentyp).
Eine schöne Beigabe der ganzen Angelegenheit, ist das man zusätzlich noch die Implementation von Methoden erzwingen kann. (Mir ist nicht klar, warum immer alle Leute glauben, dass sei die eigentliche Aufgabe von Interfaces.)

Es gibt Sprachen, wie Go, da läuft die Vererbung über die Methoden. Ein Objekt hat die Methode clear(). Ein anderes Objekt hat die Methoden clear() und stop(). Dann erbt das zweite Objekt vom ersten (Grob gesagt, das ist keine Einführung in Go).
Und noch ein Historischer Nachtsatz, eine ähnliche Konstruktion gab es schon bei Pascal (units).
[doublepost=1476392050,1476391016][/doublepost]PS: Es geht noch einfacher:

Code:
public interface Fahrzeug{
}
public class DreiRad implements Fahrzeug {
}
public class Schiff implements Fahrzeug {
}
public class Gebaeude {

     public Fahrzeug parkPlatz;
}

// Und man parkt so:
Gebaeude garage = new Gebaeude();
garage.parkPlatz = new DreiRad();
 
Ich glaube wir führen die Diskussion besser Privat fort, denn das ist alles OT

:biggrin:
 
Ok. Ein bisschen herum albern muss mal sein. Außerdem denke ich mal, das wir nicht nur zum Problem lösen hier sind. :)
 
markus.tullius schrieb:
Ok. Ein bisschen herum albern muss mal sein. Außerdem denke ich mal, das wir nicht nur zum Problem lösen hier sind. :)

Stimmt, aber ich dachte, dass es für Mitleser langsam langweilig werden könnte.

:biggrin:
 

Ähnliche Themen

5
Antworten
0
Aufrufe
1.149
586920
5
SaniMatthias
Antworten
19
Aufrufe
957
swa00
swa00
D
Antworten
23
Aufrufe
2.542
Data2006
D
Zurück
Oben Unten