Introducción de esta sección:
En este capítulo presentamos el Menu (menú) en Android. En Android, existen los siguientes tipos de menús:
- OptionMenu: Menú de opciones, el menú más común en Android, se invoca mediante la tecla Menu.
- SubMenu: Submenú, en Android al hacer clic en un submenú aparecerá un cuadro flotante que muestra los elementos del submenú. Los submenús no admiten anidamiento, es decir, no pueden incluir otros submenús.
- ContextMenu: Menú contextual, es un menú que aparece al mantener presionado un componente de vista. Este componente debe registrar el menú contextual. En esta sección aprenderemos uno por uno el uso de estos tipos de menús. PD: Documentación oficial:menus
1.OptionMenu (Menú de opciones)
1) ¿Cómo usar OptionMenu?
Respuesta: Muy sencillo, solo hay que sobrescribir dos métodos. De hecho, estos dos métodos se generan automáticamente al crear el proyecto. Son los siguientes:
- public boolean onCreateOptionsMenu(Menu menu): se invoca el OptionMenu, aquí se completa la inicialización del menú.
- public boolean onOptionsItemSelected(MenuItem item): se activa cuando se selecciona un elemento del menú, aquí se gestiona el evento.
Por supuesto, además de estos dos métodos que podemos sobrescribir, también podemos sobrescribir estos tres métodos:
- public void onOptionsMenuClosed(Menu menu): este método se llama cuando se cierra el menú.
- public boolean onPrepareOptionsMenu(Menu menu): este método se llama antes de que se muestre el menú de opciones. Aquí se puede ajustar el menú (cargar dinámicamente la lista de menús).
- public boolean onMenuOpened(int featureId, Menu menu): este método se llama después de que se abra el menú de opciones.
Hay dos formas de cargar el menú: una es escribir directamente un archivo XML de menú y luego llamar a:getMenuInflater().inflate(R.menu.menu_main, menu);Cargar menú O agregar dinámicamente mediante código: el parámetro menu de onCreateOptionsMenu, llama al método add para agregar el menú. add(número de grupo del elemento de menú, ID, número de orden, título). Además, si el número de orden es según el orden de adición, ¡rellénalo con 0!
2) Ejemplo de uso:
Imagen del resultado de ejecución:

Implementación del código:
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);
}
}
Análisis del código:
El código anterior es muy sencillo. Nos muestra cómo agregar dinámicamente elementos de menú en el OptionMenu (menú de opciones) de Android 5.0, así como el manejo de eventos: según el id se determina en qué elemento hizo clic el usuario y luego se ejecuta la operación correspondiente. Además, hay que tener en cuenta que el menú de opciones ha pasado por tres etapas: En Android 2.3.x o versiones anteriores, como la mayoría de los dispositivos en esa etapa tenían la tecla Menu, en esta etapa se mostraba el menú presionando la tecla Menu:

Mientras que en Android 3.0 o versiones superiores, se usa el menú de ajustes de la ActionBar introducida en 3.0:

Y en versiones 5.0 o superiores, se encuentra en la ToolBar; al hacer clic aparece un menú de tipo desbordado (overflow).

Además, sobre la forma de definir un menú mediante XML, mostramos un breve código de referencia:
<?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>
Para el resto, consulten la documentación ustedes mismos ~
2.ContextMenu (Menú contextual)
Al principio dijimos que es un menú que aparece después de mantener presionada una View; necesitamos registrar el menú contextual para esa View.
1) ¿Cómo usar ContextMenu?
Respuesta: El proceso de uso es el siguiente:
- Step 1: Sobrescribir el método onCreateContextMenu().
- Step 2: Registrar el menú contextual para el componente view, usando el método registerForContextMenu(), cuyo parámetro es la View.
- Step 3: Sobrescribir el método onContextItemSelected() para asignar un listener de eventos al elemento del menú.
En el OptionMenu anterior usamos código Java para agregar los elementos del menú. Aquí usaremos un archivo XML para generar nuestro ContextMenu. Además, sobre usar código Java o XML para generar el menú, se recomienda usar este último para definir el menú, ya que reduce la redundancia del código Java y no es necesario asignar ids mediante código cada vez. Solo hay que modificar el archivo XML para cambiar el contenido del menú. Esto, en cierta medida, proporciona un mejor desacoplamiento al programa: bajo acoplamiento, alta cohesión, ¿verdad? ~
2) Ejemplo de uso:
Imagen del resultado de ejecución:

Código de implementación:
Primero vamos a escribir el archivo XML de menú para el menú de opciones:
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>
Luego, sobre la base del menú de opciones, agregamos un TextView y añadimos lo siguiente:
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;
}
Bien, es así de simple ~ Se puede establecer contexto para múltiples Views, switch(v.getId) ya sabes ~ Además, al igual que el submenú del que hablaremos luego, ¡los menús contextuales no pueden mostrar iconos!
3.SubMenu (Submenú)
El llamado submenú no es más que anidar otra capa de <**menu**> dentro de <**item**>.
Ejemplo de código:
Imagen del resultado de ejecución
:
Código de implementación:
Escribir el archivo de menú del submenú: 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>
Luego modificamos el contenido de los dos métodos del menú contextual de arriba y lo reemplazamos con el siguiente código:
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;
}
Bien, es muy simple, ¿verdad? Además, si quieres agregar un submenú en código Java, puedes llamar a addSubMenu().
Por ejemplo: SubMenu file = menu.addSubMenu("Archivo"); file también necesita addItem para agregar elementos del menú, ¡ojo!
4.PopupMenu (Menú emergente)
Es algo similar a PopupWindow; puede mostrar fácilmente un menú emergente debajo de una View específica, y sus opciones de menú pueden provenir de recursos de Menu. A continuación, escribimos un ejemplo simple para usar este algo ~
Ejemplo de uso:
Imagen del resultado de ejecución:
Código de implementación:
Archivo de recursos de menú: 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>
Agrega un botón en el diseño y luego añade el evento de clic:
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();
}
});
Muy sencillo, ¿nueva habilidad adquirida?
5. Descarga del código de ejemplo
MenuDemo1.zip
Resumen de esta sección:
Bien, en esta sección presentamos los tres tipos de menús en Android: menú de opciones, menú contextual y submenú. Finalmente, también explicamos el control PopupMenu. Aquí solo se demostró el uso básico; para otros atributos pueden consultar la documentación. La documentación es el mejor maestro ~ Bien, eso es todo, gracias. Ah, por cierto, hoy es el Día Nacional, ¡les deseo que se diviertan durante el Día Nacional!