directorio
tipo enumerado
- configuración de la interfaz de uso constante
- tipo enumerado, el equivalente de una clase, heredado de java.lang.Enum, cada miembro es una instancia de un tipo enumerado, por defecto se llama pública, estático, modificaciones finales, cuando se utiliza enumeró directamente Nombre Tipo
- Tipo de método común de enumeración
- Tipo de constructores enumerado
- Pueden implementar métodos de interfaz dentro de cada miembro de enum (cada miembro debe alcanzar)
//枚举类型的定义与使用
package ex17_enum;
interface Constants {
public static final int Constants_A = 1; //将常量放在接口中
public static final int Constants_B = 12;
}
public class ConstantsTest {
enum Constants2 {
Constants_1, Constants_2 //将常量放在枚举类型中
}
//使用接口定义的常量
public static void doit(int c) {
switch (c) {
case Constants.Constants_A:
System.out.println("doit() Constants_A");
break;
case Constants.Constants_B:
System.out.println("doit() Constants_B");
break;
default:
System.out.println("others");
}
}
//使用枚举类型定义的常量
public static void doit2(Constants2 c) {
switch (c) {
case Constants_1:
System.out.println("doit2() Constants_1");
break;
case Constants_2:
System.out.println("doit2() Constants_2");
break;
}
}
public static void main(String[] args) {
ConstantsTest.doit(Constants.Constants_A); //使用接口中定义的常量
ConstantsTest.doit(3);
ConstantsTest.doit2(Constants2.Constants_1); //使用枚举类型中的常量
ConstantsTest.doit2(Constants2.Constants_2);
// ConstantsTest.doit2(3); //会报错，因为doit2()的入口参数为Constants2枚举类型
}
}
//枚举类型中的常用方法
package ex17_enum;
public class ShowEnum {
enum Constants2 {
CONSTANTS_1, CONSTANTS_2, CONSTANTS_3 //将常量放在枚举类型中
}
public static void main(String[] args) {
// Constants2[] x = Constants2.values();
//.values() 打印出枚举成员变量
//.ordinal() 获取枚举类型成员的索引位置
for (int i = 0; i < Constants2.values().length; i++) {
System.out.println("枚举类型成员变量："
+ Constants2.values()[i] +
"位置索引：" + Constants2.values()[i].ordinal());
}
//.compareTo() 比较定义顺序
//.valueOf() 将普通字符串转化为枚举类型，必须已经定义
for (int i = 0; i < Constants2.values().length; i++) {
int result = Constants2.valueOf("CONSTANTS_2").compareTo(Constants2.values()[i]);
System.out.println("Constants2.CONSTANTS_2与" + Constants2.values()[i] + "比较" + result);
}
}
}
//枚举类型中的构造方法
package ex17_enum;
public class EnumIndexTest {
enum Constants2 { //将常量放在枚举类型中
CONSTANTS_1("我是枚举成员1"), //定义带参数的枚举常量
CONSTANTS_2("我是枚举成员2"),
CONSTANTS_3("我是枚举成员3"),
CONSTANTS_4(4);
private String description;
private int i = 1;
private Constants2() {
} //无参数构造方法 private防止用户实例化一个枚举对象
private Constants2(String description) { //参数为String的构造方法
this.description = description;
}
private Constants2(int i) { //参数为int的构造方法
this.i = i;
}
public String getDescription() { //获取description的值
return description;
}
public int getI() { //获取i的值
return i;
}
}
public static void main(String[] args) {
Constants2[] cs = Constants2.values(); //获取枚举变量数组
for (int i = 0; i < cs.length; i++) {
Constants2 c = cs[i]; //枚举变量
System.out.println(c + "调用getDescription()方法：" + c.description
+ " 调用getI()方法：" + c.getI());
}
}
}
//在枚举对象中实现接口中的方法
package ex17_enum;
interface d {
String getDescription(); //默认public
int getI();
}
public enum AnyEnum implements d {
CONSTANTS_1 {
public String getDescription() {
return "我是枚举类型1";
}
public int getI() {
return i; //i必须是static，否则使用this.i调用对象的i
}
},
CONSTANTS_2 {
public String getDescription() {
return "我是枚举类型2";
}
public int getI() {
return i; //i必须是static，否则使用this.i调用对象的i
}
};
private static int i;
public static void main(String[] args) {
AnyEnum[] anyEnums = AnyEnum.values(); //返回枚举类型数组
for (int i = 0; i < anyEnums.length; i++) { //每一个枚举对象调用方法
AnyEnum anyEnum = anyEnums[i];
System.out.println(anyEnum + "调用getDescription()方法：" + anyEnum.getDescription()
+ " 调用getI()方法：" + anyEnum.getI());
}
}
}
Los genéricos
Upcast es segura, pero con abatido cuando el tipo equivocado o no hacer esto, el compilador puede ser aceptado, pero habrá una ClassCastException durante la ejecución. Parece que el problema se produce normalmente cuando abatido, utilice el mecanismo genérico efectivamente resolver este problema, será en la comprobación de tipos en tiempo de compilación
- La definición de una clase genérica
- el uso general de los genéricos
- Una pluralidad de declaraciones de tipo MultiOverClass <T1, T2> al definir clase genérica; MultiOverClass <Boolean, Float> x = new MultiOverClass <> ();
- tipo de matriz array declarado privada T [] definiendo clase genérica;
- Elementos de la declaración de clase recipiente de recogida
- Mapa : HashMap, TreeMap
- Set : HashSet, TreeSet
- Lista : ArrayList, treelist
- El uso avanzado de los genéricos
- Tipo genérico no está disponible limitando el uso de restricción, en el defecto todas las subclases de objetos clases se pueden instanciar objetos genéricos
- Nombre de clase Clase <T se extiende anyClass> anyClass cualquier interfaz o clase
- tipo genérico o clase debe implementar esta interfaz hereda anyClass o clase, se utiliza la palabra clave se extiende
- Usar caracteres comodín
- es la función principal creado cuando un objeto de clase genérica es para limitar los implementos de tipo de objeto clase genérica o hereda una interfaz o una clase de subclase
- nombre de la clase genérica <? Extiende Lista> a = null; objeto de la clase genérica sólo se puede asignar un objetivo a lograr una lista de sub-clase o interfaz
- Lista <?> Lista definida objeto de la clase genérica sólo puede ser adquirido o elementos de eliminar, no añade información nueva (porque? El compilador no sabe qué añadir información)
- límite superior de los genéricos
- Usar la palabra clave super
- A <? Lista de Super> a = null; Lista aceptan solamente un objeto que representa una interfaz de tipo de clase padre o la capa superior
- Definiciones también pueden ser heredados y aplicarse como clases genéricas e interfaces
- Si no se especifica genéricos herencia en la herencia, en las subclases se pondrá por defecto al tipo de objetos
- Tipo genérico no está disponible limitando el uso de restricción, en el defecto todas las subclases de objetos clases se pueden instanciar objetos genéricos
resumen:
- parámetro de tipo genérico sólo puede ser tipos de clase, no puede ser un tipo simple
- parámetro de tipo genérico puede ser una pluralidad de
- Se puede utilizar el límite de tipo de palabra clave se extiende súper genéricos
- Puede utilizar comodines para limitar tipo genérico
//泛型的定义
package ex17_enum;
public class OverClass<T> { //定义泛型类
private T over; //定义泛型类成员变量
public T getOver() { //设置getXXX()方法
return over;
}
public void setOver(T over) { //设置setXXX()方法
this.over = over;
}
public static void main(String[] args) {
//实例化一个Boolean类型的对象
OverClass<Boolean> over1 = new OverClass<Boolean>();
over1.setOver(true); //不需要向上转型
Boolean b = over1.getOver(); //不需要向下转型
System.out.println(b);
//实例化一个Float类型的对象
OverClass<Float> over2 = new OverClass<Float>(); //Float可以不写
over2.setOver(12.3F); //不需要向上转型
Float f = over2.getOver(); //不需要向下转型
System.out.println(f);
}
}
//定义泛型时，声明多个类型，声明数组
package ex17_enum;
public class MultiOverClass<T1, T2> {
private T1 multiOver;
private T2[] multiOver2; //声明数组类型
// private T2[] multiOver2 = newT[10]; //不能使用泛型建立数组实例，因为不能确定类型，无法分配内存
public void setMultiOver(T1 multiOver, T2[] multiOver2) {
this.multiOver = multiOver;
this.multiOver2 = multiOver2;
}
public T1 getMultiOver() {
return multiOver;
}
public T2[] getMultiOver2() {
return multiOver2;
}
public static void main(String[] args) {
//自动检测类型，不需要向上转型
MultiOverClass<Boolean, String> multiOverClass = new MultiOverClass<>();
multiOverClass.setMultiOver(true, new String[]{"成员1", "成员2"});
//使用getXXX()方法，不需要向下转型
Boolean b = multiOverClass.getMultiOver();
String[] str = multiOverClass.getMultiOver2();
//输出实例multiOverClass
System.out.println("getMultiOver: " + b);
for (String s : str) {
System.out.println("getMultiOver2: " + s);
}
}
}
//集合类声明元素类型
package ex17_enum;
import java.util.*;
public class AnyClass {
public static void main(String[] args) {
//Map集合(又称为容器):
//HashMap 添加和删除映射关系效率高 不保证顺序 允许为null
//TreeMap 其中的映射关系存在一定顺序 效率比HashMap稍差 键不允许为null
Map<Integer, String> map = new HashMap<>();
Map<Integer, String> map1 = new TreeMap<>();
//为容器填充键和键值
map.put(33333, "A");
map1.put(33333, "A");
map.put(11111, "A");
map1.put(11111, "A");
map.put(22222, "B");
map1.put(22222, "B");
//获取键和键值--使用迭代器 map不保证顺序 map1排序
Set<Integer> keySet = map.keySet(); //利用Set构建Map集合中的key集合
Collection<String> valueColl = map.values(); //利用Collection构建Map中的values集合 值有可能相同
// Set<Integer> keySet = map1.keySet(); //利用Set构建Map集合中的key集合
// Collection<String> valueColl = map1.values(); //利用Collection构建Map中的values集合 值有可能相同
Iterator<Integer> keyIterator = keySet.iterator();
Iterator<String> valueIterator = valueColl.iterator();
while (keyIterator.hasNext()) {
System.out.println("key: " + keyIterator.next()
+ " value: " + valueIterator.next());
}
//Set
//HashSet 不保证顺序
//TreeSet 有一定顺序 也可以按照指定比较器递增排序
Set<String> set = new HashSet<>();
Set<String> set1 = new TreeSet<>();
set.add("33333");
set1.add("33333");
set.add("11111");
set1.add("11111");
set.add("22222");
set1.add("22222");
Iterator<String> setIterator = set.iterator();
Iterator<String> setIterator1 = set1.iterator();
System.out.println("--------HashSet不保证顺序---------");
while (setIterator.hasNext()) {
System.out.println(setIterator.next());
}
System.out.println("--------TreeSet增序---------");
while (setIterator1.hasNext()) {
System.out.println(setIterator1.next());
}
//List
//ArrayList 可以根据索引位置快速访问 缺点是插入删除速度慢
//LinkedList 随机访问比ArrayList效率低 优点是插入删除效率比ArrayList高
List<String> stringList = new ArrayList<>();
List<String> stringList1 = new LinkedList<>();
}
}
//泛型的高级用法，限制类型，通配符
package ex17_enum;
import java.util.ArrayList;
import java.util.List;
public class debug {
public static void main(String[] args) {
List<String> stringList = new ArrayList<>();
stringList.add("成员1");
stringList.add("成员2");
List<String> stringList1 = stringList; //没有使用通配符 引用赋值 可添加新信息
System.out.println("-------删除之前的stringList-------------");
for (String str : stringList) {
System.out.println(str);
}
stringList1.remove(0);
System.out.println("-------删除之后的stringList-------------");
for (String str : stringList) {
System.out.println(str);
}
stringList1.add("成员3(stringList1添加的)");
System.out.println("-------添加成员-------------");
for (String str : stringList) {
System.out.println(str);
}
System.out.println("----------------------------");
List<?> stringList2 = stringList; //使用List<?> 引用赋值 不能添加新信息 只能获取或删除
System.out.println("获取信息：" + stringList2.get(1));
System.out.println("删除信息：" + stringList2.remove(1));
// stringList2.add("不可添加成员");
// stringList2.set(0,"不可添加成员"); //不能添加新信息
for (String str : stringList) {
System.out.println(str);
}
}
}
