java基础知识总结7(枚举+泛型)

七、枚举

枚举是一个类类型，是JDK1.5的新特性
枚举的关键字是enum
Java中所有的枚举类都是java.lang.Enum的子类

注意：枚举类中可以包含成员有【字段（常量）、方法（构造方法、普通方法）】

枚举中不能有number；不能赋值————类

只有顺序可以比较———–

语法：

enum 枚举名{

 枚举体

}

例：

enum Direction{//枚举体

 EAST,SOUTH,WEST,NORTH//后面可以有分号也可以没有

}

调用：枚举名.成员

枚举名 name =枚举名.成员；

Direction dir = Direction.EAST;

Enum的方法使用：

Javap—————查看字节码文件

代码：

enum Direction{

EAST(‘e’),SOUTH(’s’),NORTH(‘n’),WEST(‘w’);

protected char a;

private Direction(char a){

this.a = a;

}

public String toString(){

return a+”“;

}

}

字节码：

———- javap ———-

Compiled from “Direction.java”

final class Direction extends java.lang.Enum {//不能被实例化

public static final Direction EAST;

public static final Direction SOUTH;

public static final Direction NORTH;

public static final Direction WEST;

protected char a;//默认是private，但可以使用4P

public static Direction[] values();//默认方法，用来遍历打印枚举成员

public static Direction valueOf(java.lang.String);

public java.lang.String toString();

static {};//静态初始化块

}

由上面可以知道枚举继承java.lang.Enum类，参数的默认修饰符public static final，在枚举中可以使用4p

public enum A{BLUE,RED,BLACK};//声明并定义一个枚举，初始化为。。。

在一个类中定义一个enum成员，enum默认是静态的————-相当于类变量

枚举的用法
一、常量

枚举出来之前都是通过接口

在JDK1.5 之前，我们定义常量都是： public static fianl，现在可以把相关的常量分组到一个枚举类型里，例：

public enum Color {

RED, GREEN, BLANK, YELLOW

}
二、Switch

JDK1.5之后的switch语句支持Byte，short，int,char,enum类型，使用枚举，能让我们的代码可读性更强，JDK1.7之后开始支持String类型，例：

enum Signal {

 GREEN, YELLOW, RED

}

public class TrafficLight {

 Signal color = Signal.RED; public void change() {           switch (color) {           case RED:                    color = Signal.GREEN;                    break;           case YELLOW:                    color = Signal.RED;                    break;           case GREEN:                    color = Signal.YELLOW;                    break;           } }

}
三、向枚举中添加新方法

要自定义方法，必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum实例，例：

public enum Color {

 RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4); // 成员变量 private String name; private int index; // 构造方法 private Color(String name, int index) {           this.name = name;           this.index = index; } // 普通方法 public static String getName(int index) {           for (Color c : Color.values()) {                    if (c.getIndex() == index) {                             return c.name;                    }           }           return null; } // get set 方法 public String getName() {           return name; } public void setName(String name) {           this.name = name; } public int getIndex() {           return index; } public void setIndex(int index) {           this.index = index; }

}
四、覆盖枚举的方法

例如覆盖toString（）

public enum Color {

 RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4); // 成员变量 private String name; private int index; // 构造方法 private Color(String name, int index) {           this.name = name;           this.index = index; } //覆盖方法 @Override public String toString() {           return this.index+"_"+this.name; }

}
五、实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类，例：

public interface Behaviour {

 void print(); String getInfo();

}

public enum Color implements Behaviour{

 RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4); // 成员变量 private String name; private int index; // 构造方法 private Color(String name, int index) {           this.name = name;           this.index = index; }

//接口方法

 @Override public String getInfo() {           return this.name; } //接口方法 @Override public void print() {           System.out.println(this.index+":"+this.name); }

}
六、使用接口组织枚举

public interface Food {

 enum Coffee implements Food{           BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO } enum Dessert implements Food{           FRUIT, CAKE, GELATO }

}
七、枚举集合

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的key是enum类型，而value则可以是任意类型。

枚举和普通类的区别与联系;

1、枚举与类都可以实现多接口；访问控制符都可以使用（4p）,但枚举中默认的是private，类中默认的是package；

2、枚举直接继承java.lang.Enum类，普通类是继承java.lang.Object;其中java.long.Enum类实现了java.long.Serializable和java.long.Comparable两个接口。

3、使用enum定义、非抽象的枚举默认修饰符为public final，因此枚举不能派生子类。
4、枚举的构造器只能使用private访问控制符，如果省略了枚举的访问修饰符其默认为private修饰；因为枚举的字段不能初始化，对象类型的必须调用构造方法，所有有多少个成员构造方法就会运行多少次；
5、枚举的所有实例必须在枚举的第一行显示列出，否则这个枚举永远都不能生产实例，列出这些实例时系统会自动添加public static final修饰，无需程序员显式添加

6、所有的枚举类都提供了一个values方法，该方法可以很方便的遍历所有的枚举值

7、关键字：枚举是enum，类是class

8、枚举是类类型，类是引用类型

instanceof关键字：
public class FX {
public static void main(String[] args) {
boolean b = (“1” instanceof String);//判断某个对象是不是某个类的实例 Result = Object instanceof Class/interface
//Result：布尔类型。
//Object：必选项。任意对象表达式。
//Class：必选项。任意已定义的对象类。
System.out.println(b);
}
}

注解—JDK1.5的新特性
使用位置：类上、方法上、语句上
八、协变与泛型

协变——-可以用在数组、重写，不可以用在枚举中

可变参数：

int… a————-代表一个没有长度限制的数组———-JDK1.5之后有的

输入的必须是数组

Java1.5增加了新特性：可变参数：适用于参数个数不确定，类型确定的情况，java把可变参数当做数组处理。注意：可变参数必须位于最后一项。只支持有一个可变参数。因为参数个数不定，所以当其后边还有相同类型参数时，java无法区分传入的参数属于前一个可变参数还是后边的参数，所以只能让可变参数位于最后一项。

可变参数的特点：

（1）、只能出现在参数列表的最后；

（2）、… 位于变量类型和变量名之间，前后有无空格都可以；

（3）、调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。例：

public class Varable {
public static void main(String [] args){
System.out.println(add(2,3));
System.out.println(add(2,3,5));
}
public static int add(int x,int …args){
int sum=x;
for(int i=0;i
协变的作用范围

1、数组：如果 A 是 B 的超类，则 A[] 也是 B[] 的超类，所有需要 A[] 的地方都可以用 B[] 代替，例：

public class Test2 {

public static void main(String[] args){

Integer[] ints=new Integer[1];ints[0]=99;show(ints);

}

static void show(Number[] ns){

System.out.println(Arrays.toString(ns));

}

}

2、重写

public class Test2 {

public static void main(String[] args){

P p=new C();System.out.println(p.get());

}

}

class P{

public Number get(){

return new Integer(0);

}

}

class C extends P{

public Integer get(){

return new Integer(1);

}

}

3、泛型不能协变：如果 A 是 B 的超类，则 List 和 List 无关，需要 List 的地方不可以用 List 代替，例：

public class Test2 {

public static void main(String[] args) {

List<Integer> ints = new ArrayList<Integer>();//incompatible type--类型不兼容show(ints);

}

static void show(List ns) {

System.out.println(ns);

}

}
泛型（Generic）的本质是类型参数化

————-是JDK1.5提供的新技术，它的本质是类型参数化，类似C++中的模板，它根据应用主要分为泛型方法，泛型接口，泛型类，协变不适用于泛型

泛型————-泛型类class Demo{}，泛型接口interface Inter{}，泛型方法public T show(T a) {}

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率

例1：
public class GenericDemo{

public static void main(String[] args) {

      C c1 = new C(new A("aaa"));      C c2 = new C(new B(3.4));//包装成double---自动装箱      Object obj = c1.getObj();      A obj = (A)(c1.getObj());//强制转换      System.out.println(obj);

}

}

class A{

private String x;

public A(String x){

      this.x=x;

}

public String getX(){

      return x;

}

}

class B{

private Double d;

public B(Double d){

      this.d=d ;

}

public Double getD(){

      return d;

}

}

class C{

private Object obj;

public C(Object obj){

      this.obj=obj ;

}

public Object getObj(){

      return obj;

}

}
泛型的使用

一、泛型类：

public class Demo1 {

public static void main(String[] args) {

      Generic<String> c = new Generic<String>("asad");      System.out.println(c.getA());      //Generic<int> c1 = new Generic<int>(12);必须要是包装类

}

}

class Generic{//泛型类

private T a;

public Generic(T a){

      this.a = a;

}

public T getA(){

      return a;

}

}

二、泛型方法

public static T getX(T t){//泛型方法———-< >–表声明
return t;

}

三、泛型接口

public class GenericDemo3{

public static void main(String[] args) {

D < int[][]> d = new D< int[][]>();

d.show(new int[][]{{1,4},{2,3}});

}

}

interface IA{

void show(T t);

}

class D implements IA{

public void show(T t){

System.out.println(t.getClass().getName());

}

}

有界类型：

上界：extends 默认上界为Object

Class G < T extends Number,K extends Object,H super Integer>{}

下界：super———-只有通配符有下限

extends关键字声明了类型的上界，表示参数化的类型可能是所指定的类型，或者是此类型的子类

super关键字声明了类型的下界，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至Object

规则和限制

1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。

2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

3、泛型的类型参数可以有多个。< T,K>

4、泛型的参数类型可以使用extends关键字，例如< T extends superclass>。习惯上称为“有界类型”。

5、泛型的参数类型还可以是通配符类型。例如Class< ? > classType = Class.forName(“java.lang.String”)

6、如果只指定了< ? >，而没有extends，则默认是允许Object及其下的任何Java类了。也就是任意类。

7、通配符泛型不但可以向下限制，如< ? extends Collection >，还可以向上限制，如< ? super Double >，表示类型只能接受Double及其上层父类类型，如Number、Object类型的实例。

8、泛型类定义可以有多个泛型参数，中间用逗号隔开，还可以定义泛型接口，泛型方法。这些都与泛型类中泛型的使用规则类似。

一个普通static方法，无法访问泛型类的类型参数，所以，若普通static方法需要使用泛型参数，必须使其成为泛型方法。