Einführung in diesen Abschnitt:
Dieses Kapitel stellt Ihnen das Menü in Android vor, und in Android gibt es mehrere Arten von Menüs:
- OptionMenu: Optionsmenü, das gebräuchlichste Menü in Android, aufgerufen über die Menü-Taste
- SubMenu: Untermenü. In Android öffnet ein Klick auf ein Untermenü ein schwebendes Fenster, das die Untermenüelemente anzeigt. Untermenüs unterstützen keine Verschachtelung, d. h., sie können keine weiteren Untermenüs enthalten.
- ContextMenu: Kontextmenü, ein Menü, das nach langem Drücken auf eine View-Komponente erscheint. Die Komponente muss ein Kontextmenü registrieren. In diesem Abschnitt lernen wir die Verwendung dieser Menüs nacheinander kennen. PS: Offizielle Dokumentation:Menüs
1. OptionMenu (Optionsmenü)
1) Wie verwendet man OptionMenu?
Antwort: Es ist ganz einfach, man muss nur zwei Methoden überschreiben. Tatsächlich werden diese beiden Methoden automatisch generiert, wenn wir ein Projekt erstellen. Sie lauten:
- public boolean onCreateOptionsMenu(Menu menu): Wird von OptionMenu aufgerufen; hier die Menüinitialisierung abschließen
- public boolean onOptionsItemSelected(MenuItem item): Wird ausgelöst, wenn ein Menüelement ausgewählt wird; hier das Ereignis behandeln
Natürlich können wir neben den beiden oben genannten Methoden, die wir überschreiben können, auch diese drei Methoden überschreiben:
- public void onOptionsMenuClosed(Menu menu): Diese Methode wird aufgerufen, wenn das Menü geschlossen wird
- public boolean onPrepareOptionsMenu(Menu menu): Diese Methode wird aufgerufen, bevor das Optionsmenü angezeigt wird. Hier können Sie das Menü anpassen (die Menüliste dynamisch laden)
- public boolean onMenuOpened(int featureId, Menu menu): Diese Methode wird aufgerufen, nachdem das Optionsmenü geöffnet wurde
Es gibt zwei Möglichkeiten, ein Menü zu laden. Eine besteht darin, direkt eine Menü-XML-Datei zu schreiben und dann aufzurufen: Menü ladengetMenuInflater().inflate(R.menu.menu_main, menu);Oder dynamisch per Code hinzufügen: Verwende den `menu`-Parameter von `onCreateOptionsMenu` und rufe die `add`-Methode auf, um Menüeinträge hinzuzufügen. `add(group ID des Menüeintrags, ID, Sortiernummer, Titel)`. Wenn die Sortiernummer auf der Einfügereihenfolge basiert, trage einfach bei allen 0 ein!
2) Verwendungsbeispiel:
Screenshot des Laufergebnisses:

Code-Implementierung:
MainActivity.java:
public class MainActivity extends AppCompatActivity {
//1.定义不同颜色的菜单项的标识:
final private int RED = 110;
final private int GREEN = 111;
final private int BLUE = 112;
final private int YELLOW = 113;
final private int GRAY= 114;
final private int CYAN= 115;
final private int BLACK= 116;
private TextView tv_test;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv_test = (TextView) findViewById(R.id.tv_test);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
menu.add(1,RED,4,"红色");
menu.add(1,GREEN,2,"绿色");
menu.add(1,BLUE,3,"蓝色");
menu.add(1,YELLOW,1,"黄色");
menu.add(1,GRAY,5,"灰色");
menu.add(1,CYAN,6,"蓝绿色");
menu.add(1,BLACK,7,"黑色");
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
switch (id){
case RED:
tv_test.setTextColor(Color.RED);
break;
case GREEN:
tv_test.setTextColor(Color.GREEN);
break;
case BLUE:
tv_test.setTextColor(Color.BLUE);
break;
case YELLOW:
tv_test.setTextColor(Color.YELLOW);
break;
case GRAY:
tv_test.setTextColor(Color.GRAY);
break;
case CYAN:
tv_test.setTextColor(Color.CYAN);
break;
case BLACK:
tv_test.setTextColor(Color.BLACK);
break;
}
return super.onOptionsItemSelected(item);
}
}
Codeanalyse:
Der obige Code ist sehr einfach. Er demonstriert das dynamische Hinzufügen von Menüeinträgen zum OptionMenu (Optionsmenü) in Android 5.0 sowie die Ereignisbehandlung: Anhand der id wird ermittelt, auf welchen Eintrag der Benutzer geklickt hat, und dann wird die entsprechende Operation ausgeführt. Außerdem ist zu beachten, dass das Optionsmenü drei Übergangsphasen durchlaufen hat: Unter Android 2.3.x oder niedriger wurde das Menü, da die meisten Geräte in dieser Phase eine Menu-Taste hatten, durch Klicken auf die Menu-Taste eingeblendet:

Unter Android 3.0 oder höher hingegen erfolgt es über das in 3.0 eingeführte Einstellungsmenü in der ActionBar:

Unter Versionen über 5.0 befindet es sich in der ToolBar, und nach dem Anklicken erscheint ein Menü im Overflow-Stil

Außerdem wollen wir für die Definition eines Menüs per XML einen einfachen Referenzcode angeben:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/new_game"
android:icon="@drawable/ic_new_game"
android:title="@string/new_game"
android:showAsAction="ifRoom"/>
<item android:id="@+id/help"
android:icon="@drawable/ic_help"
android:title="@string/help" />
</menu>
Für den Rest lesen Sie bitte selbst die Dokumentation~
2. ContextMenu (Kontextmenü)
Wie am Anfang gesagt, ist es ein Menü, das nach langem Drücken auf eine bestimmte View erscheint; wir müssen für diese View ein Kontextmenü registrieren!
1) Wie verwendet man ContextMenu?
Antwort: Der Verwendungsablauf ist wie folgt:
- Schritt 1: Überschreiben Sie die Methode onCreateContextMenu()
- Schritt 2: Registrieren Sie ein Kontextmenü für die View-Komponente, verwenden Sie die Methode registerForContextMenu(), der Parameter ist eine View
- Schritt 3: Überschreiben Sie die Methode onContextItemSelected(), um einen Event-Listener für Menüelemente festzulegen
Für das obige OptionMenu haben wir Java-Code verwendet, um Menüelemente hinzuzufügen. Hier verwenden wir nun eine XML-Datei, um unser ContextMenu zu erzeugen. Was die Frage angeht, ob man Java-Code oder XML zum Erzeugen von Menüs verwenden sollte, empfiehlt es sich, Letzteres zum Definieren von Menüs zu verwenden. Dadurch lässt sich die Java-Code-Aufblähung reduzieren, und Sie müssen nicht jedes Mal IDs mit Code vergeben; ändern Sie einfach die XML-Datei, um den Menüinhalt zu ändern. In gewissem Maße sorgt dies für eine bessere Entkopplung des Programms – geringe Kopplung, hohe Kohäsion, richtig~
2) Verwendungsbeispiel:
Screenshot des Laufergebnisses:

Implementierungscode:
Schreiben wir zuerst die Menü-XML-Datei des Optionsmenüs:
menu_context.xml:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<!-- 定义一组单选按钮 -->
<!-- checkableBehavior的可选值由三个:single设置为单选,all为多选,none为普通选项 -->
<group android:checkableBehavior="none">
<item android:id="@+id/blue" android:title="@string/font_blue"/>
<item android:id="@+id/green" android:title="@string/font_green"/>
<item android:id="@+id/red" android:title="@string/font_red"/>
</group>
</menu>
Fügen Sie dann auf Basis des obigen Optionsmenüs eine TextView hinzu und fügen Sie anschließend Folgendes hinzu:
private TextView tv_context;
tv_context = (TextView) findViewById(R.id.tv_context);
registerForContextMenu(tv_context);
//重写与ContextMenu相关方法
@Override
//重写上下文菜单的创建方法
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenu.ContextMenuInfo menuInfo) {
MenuInflater inflator = new MenuInflater(this);
inflator.inflate(R.menu.menu_context, menu);
super.onCreateContextMenu(menu, v, menuInfo);
}
//上下文菜单被点击是触发该方法
@Override
public boolean onContextItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.blue:
tv_context.setTextColor(Color.BLUE);
break;
case R.id.green:
tv_context.setTextColor(Color.GREEN);
break;
case R.id.red:
tv_context.setTextColor(Color.RED);
break;
}
return true;
}
Okay, so einfach ist das~ Sie können den Kontext für mehrere Views festlegen, switch(v.getId) Sie wissen, was ich meine~ Außerdem können Kontextmenüs, wie das später zu besprechende Untermenü, keine Icons anzeigen!
3. SubMenu (Untermenü)
Das sogenannte Untermenü ist einfach eine weitere Ebene `<menu>`, die innerhalb von `<item>` verschachtelt wird.
Codebeispiel:
Screenshot des Laufergebnisses
:
Implementierungscode:
Schreiben Sie die Menüdatei für das Untermenü: menu_sub.xml:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/submenu" android:title="子菜单使用演示~">
<menu>
<group android:checkableBehavior = "none">
<item android:id="@+id/one" android:title = "子菜单一"/>
<item android:id="@+id/two" android:title = "子菜单二"/>
<item android:id="@+id/three" android:title = "子菜单三"/>
</group>
</menu>
</item>
</menu>
Dann ändern wir den Inhalt der beiden Methoden im obigen Kontextmenü und ersetzen ihn durch den folgenden Code:
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenu.ContextMenuInfo menuInfo) {
//子菜单部分:
MenuInflater inflator = new MenuInflater(this);
inflator.inflate(R.menu.menu_sub, menu);
super.onCreateContextMenu(menu, v, menuInfo);
}
public boolean onContextItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.one:
Toast.makeText(MainActivity.this,"你点击了子菜单一",Toast.LENGTH_SHORT).show();
break;
case R.id.two:
item.setCheckable(true);
Toast.makeText(MainActivity.this,"你点击了子菜单二",Toast.LENGTH_SHORT).show();
break;
case R.id.three:
Toast.makeText(MainActivity.this,"你点击了子菜单三",Toast.LENGTH_SHORT).show();
item.setCheckable(true);
break;
}
return true;
}
Okay, sehr einfach, oder? Außerdem kannst du, wenn du im Java-Code ein Untermenü hinzufügen möchtest, addSubMenu() aufrufen
Zum Beispiel: `SubMenu file = menu.addSubMenu("File");` `file` muss ebenfalls `addItem` aufrufen, um Menüeinträge hinzuzufügen!
4. PopupMenu (Pop-up-Menü)
Eine Sache ähnlich wie PopupWindow. Sie kann bequem ein Pop-up-Menü unter einer angegebenen View anzeigen, und ihre Menüoptionen können aus einer Menu-Ressource stammen. Im Folgenden schreiben wir ein einfaches Beispiel, um diese Sache zu verwenden~
Anwendungsbeispiel:
Screenshot des Laufeffekts:
Implementierungscode:
Menü-Ressourcendatei: menu_pop.xml:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/lpig" android:title="小猪" />
<item android:id="@+id/bpig" android:title="大猪" />
</menu>
Füge einen Button zum Layout hinzu und füge dann ein Klickereignis hinzu:
MainActivity.java:
btn_show_menu.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
PopupMenu popup = new PopupMenu(MainActivity.this,btn_show_menu);
popup.getMenuInflater().inflate(R.menu.menu_pop, popup.getMenu());
popup.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
@Override
public boolean onMenuItemClick(MenuItem item) {
switch (item.getItemId()){
case R.id.lpig:
Toast.makeText(MainActivity.this,"你点了小猪~",
Toast.LENGTH_SHORT).show();
break;
case R.id.bpig:
Toast.makeText(MainActivity.this,"你点了大猪~",
Toast.LENGTH_SHORT).show();
break;
}
return true;
}
});
popup.show();
}
});
Sehr einfach. Hast du die neue Fähigkeit erlernt?
5. Beispielcode-Download
MenuDemo1.zip
Zusammenfassung dieses Abschnitts:
Okay, in diesem Abschnitt wurden die drei Arten von Menüs in Android vorgestellt: das Optionsmenü, das Kontextmenü und das Untermenü. Schließlich haben wir auch ein PopupMenu-Steuerelement erklärt. Hier wird nur die grundlegende Verwendung gezeigt; für andere Attribute kannst du die Dokumentation konsultieren. Die Dokumentation ist der beste Lehrer~ Nun, das war alles. Danke. Übrigens, heute ist Nationalfeiertag. Ich wünsche euch allen einen schönen Nationalfeiertag!