泛型和枚举
一、泛型
1.基础：泛型(genericity)可以提高程序的复用性，减少数据类型的转换(个人感觉像是减少了重载从而减少了代码量？)，从而增加代码的运行效率。
2.声明：实际就在声明接口或者类在名字后面加上类型参数，类型参数的定义格式有如下三种：
(1)类型变量标识符
public class GenericA<T>
{ //类体}
(2)类型变量标识符 extends 父类型
public class GenericA<T extends Number>
{ //类体}
(3)类型变量标识符 extends 父类型1 &父类型2 &……&父类型n
public class GenericA<T extends J_C1 & J_C2>
{ //类体}
3.使用
(1)对应2.(1)
class GenericA<X> { X p1; X p2; public GenericA(X x,X y) { p1=x; p2=y; } public String f() { return p1.toString()+p2.toString(); } } public class Genericties<T extends Number> { public static void main(String []args) { /*Genericity<T>*/ GenericA<Integer> a=new GenericA<Integer>(10,10); GenericA<String> c=new GenericA<String>("12","12"); System.out.println(a.f()); System.out.println(c.f()); } }
可以看出使用的字母是X,代表不止可以使用常用字母T，可以使用任何作为变量名称的标识符，若是不继承任何类或接口，那么就默认为只有和Object一样的操作方法，大致有getClass(),hashcode(),toString(),equals(Object obj)等，除此之外，还有notify()和notifyAll()以及wait()几种重载[后面这几个没怎么用过，应该是线程里面的东西，那就后面再讲。。]
2018.07.16
还有一些使用时需要注意的事项：1>GenericA<Integer> a=new GenericA<Integer>(10,10);这句代码有前后两个<Integer>，可以删除任一个或者都删除，并不影响结果。
2>可以删除<>中的内容只保留括号，例如GenericA<Integer> a=new GenericA<>(10,10);但是只适用于后面的那个，奇怪的是前面的不能适用，也即不存在以下这种形式：GenericA<>a=new GenericA<Integer>(10,10);
3>不能使用不同于参数的类型，例如不能有GenericA a=new GenericA<String>(10,10);这种形式，不通过编译。
(2)继承某类(可以是接口)，对应于2.(2)
class GenericB<M extends Number> { public int sum(M a,M b,M c) { return a.intValue()+b.intValue()+c.intValue(); } } public static void main(String []args)
{ GenericB<Double> b=new GenericB<Double>(); System.out.println(b.sum(120.0, 12.0, 1.2));
}
输出133，以此为例，若是继承Number类，则在泛型可以使用的方法包括如下图（少截了个shortValue()）：
(3)继承多个类或者接口，对应2.(3)
class C1 { static int A=8; public void print() { System.out.println("C1"); } } interface C2 { public void printA(); } class C3 extends C1 implements C2 { public C3(int A) { this.A=A; } int A; public void printA() { System.out.println(A); } } class C4 extends C1 implements C2 { public void print() { System.out.println("C4"); } public void printA() { System.out.println(A); } } class GenericC<X extends C1 & C2> { public void m(X x) { x.print(); x.printA(); } }
上面有两个类C3、C4都继承于C1，实现C2都符合带泛型类GenericC<X extends C1 & C2>的条件，我们来做验证：
GenericC<C3> gc=new GenericC<C3>(); GenericC<C4> gc0=new GenericC<C4>(); C3 c3=new C3(12); C4 c4=new C4(); gc.m(c3); gc0.m(c4);
C1
12
C4
8
结果显而易见。
4.泛型方法
泛型不只可以针对类，还可以针对方法。
public class GenerictiesFunction {
public <K,V> void f(K k,V v) {
System.out.println(k.getClass());
System.out.println(v.getClass());
}
public static void main(String[] args) {
GenerictiesFunction g = new GenerictiesFunction();
g.f(0.0,"generic");
}
}
结果是
class java.lang.Double
class java.lang.String
可以看出泛型方法与泛型类还是有区别的。
主要就是那个<>的位置，一个在类名后面，一个在函数返回值前面；
还有就是似乎还没有发现泛型方法使用时需要<>这个东西；2018.07.16 找到需要使用的情况就是在调用的函数名前面添加，例如g.<Double,String>f(0.0,"generic");就等同于g.f(0.0,"generic");但不能使用g.<>f(0.0,"generic")或者<Double,>、<,String>这种。
另外就是泛型方法声明中也能继承其他类或接口，就像这样：public <K extends Number,V> void f(K k,V v){函数体}
5.通配符和边界
(1)类型擦除
2018.08.25 好久都没时间写博客了，这段时间感觉读研还是挺有压力的，特别是一系列事件的冲击更是心力交瘁，不过有对编程的喜爱，就能支撑下去。
类型擦除是指JVM在处理泛型时，在运行期间并不“认识”泛型参数，例如：
class A <T>
{}
public class GeneBound {
public static void main (String []args)
{
A<Integer> a=new A<Integer>();
A<String> b =new A<String>();
System.out.println(a.getClass()==b.getClass());
}
}
返回结果是true，虽然对象a和b的类型一个是A<String>，一个是A<Integer>,但却会被判断为一类，在C++中则是两个类型，这个现象就叫做类型擦除。
这样一来就会造成一定的问题(其实不算大问题)，我的理解是，在Java里，你永远不能在泛型类使用超出该类泛型参数之外的方法。例如下面例子中T无extends任何类型，里面的obj只能调用Object类的方法，所以调用f()会出错。
class HasF {
public void f() {
System.out.println("HasF.f()");
}
}
public class GeneBound<T> {
private T obj;
public GeneBound(T obj) {
this.obj = obj;
}
public void manipulate() {
obj.f(); //无法编译 找不到符号 f()
}
public static void main(String[] args) {
HasF hasF = new HasF();
GeneBound<HasF> manipulator = new GeneBound<>(hasF);
manipulator.manipulate();
}
刚没写几个字的博客，老板又跟我打电话，让交材料，但我还没写先写那个去了，看来又要搁置一段时间了，从8.25-8.29就写了这么一点。先给下次开个头，不知道下次是什么时间了，被再给忘了。
下面写T extends XX 类型的例子。(2018.9.13)
public class GeneBound<T extends Number> {
private T obj;
public GeneBound(T obj) {
this.obj = obj;
}
public int manipulate() {
// obj.f(); //无法编译 找不到符号 f()
int i=obj.intValue();
return i;
}
public static void main(String[] args) {
HasF hasF = new HasF();
GeneBound<Double> manipulator = new GeneBound<>(10.3);
System.out.println(manipulator.manipulate());
}
}
最终输出10可以看出类型擦除到了Number，但不能使用Integer的方法例如VauleOf()或toOctalString()等等，即使你的泛型申请了Integer类型。这就是类型擦除。
(2)泛型数组
泛型数组还是要学一学的，用的地方还蛮多的，而且也没法进行下去了。
直接声明泛型数组是行不通的，例如：
class gen<T>{
}
public class GeneArray {
public static void main(String[] args) {
gen<Integer> []a=new gen<Integer>( ) [3]; //The type of the expression must be an array type but it resolved to gen<Integer> 意料之中不能这样写
gen<Integer> []a=new gen<Integer> [3]; //试一试对象数组的方法，可惜仍然不可以 Cannot create a generic array of gen<Integer>
}
}
我们可以使用ArrayList来进行代替：
ArrayList<gen<Integer>> a = new ArrayList<gen<Integer>>();
09.24
虽然无法创建泛型数组，但是却可以声明，例如：
gen <Integer> []a;//不但能通过编译还能运行，不过不知道怎么用啊。这里先留个尾巴吧。。。。
(3)数组的协变
package genericity; class Fruit {} class Apple extends Fruit {} class Jonathan extends Apple {} class Orange extends Fruit {} /*数组协变，代码来自 https://segmentfault.com/a/1190000005337789*/ public class Covariant { public static void main(String[] args) { Fruit[] fruit = new Apple[10]; fruit[0] = new Apple(); // OK fruit[1] = new Jonathan(); // OK // Runtime type is Apple[], not Fruit[] or Orange[]: try { // Compiler allows you to add Fruit: fruit[2] = new Fruit(); // ArrayStoreException } catch(Exception e) { System.out.println(e); } try { // Compiler allows you to add Oranges: fruit[3] = new Orange(); // ArrayStoreException } catch(Exception e) { System.out.println(e); } } }
在上例中，数组的引用被赋给了一个Apple数组，在此之后数组只能放入Apple及其子类的元素。现在的问题是当这个数组是使用ArrayList的泛型数组时就会失效。
因此引入通配符来解决这个问题。问题就是List<Apple>不是List<Fruit>的子类
<? extends XXX>来实现泛型向上转型。
然而你并不能这样：
Fruit a=new Fruit(); Apple b; Jonathan c; Orange d; List<? extends Fruit> alist = new ArrayList<>();/**/ alist.add(a); //Error The method add(capture#1-of ? extends Fruit) in the type List<capture#1-of ? extends Fruit> is not applicable for the arguments (Fruit) alist.add(b); //Error alist.add(c); //Error alist.add(d); //Error
代表除了null你啥都不能直接添加到通配符的List，那还有啥用啊？但是很明显通配符不是这么用的，List<? extends Fruit>代表List<Fruit>、List<Apple>和List<Orange>都是其子类。例如：
class Fruit { public String name; public Fruit(String name) { this.name=name; } public void getname() { System.out.println(name);; } } class Apple extends Fruit { public Apple(String name) { super(name); // TODO Auto-generated constructor stub } } class Jonathan extends Apple { public Jonathan(String name) { super(name); // TODO Auto-generated constructor stub }} class Orange extends Fruit { public Orange(String name) { super(name); // TODO Auto-generated constructor stub }} public class Covariant { public static void act(List<? extends Fruit> list) { for (Fruit fruit : list) { fruit.getname(); } } public static void act(List<? extends Fruit> list) { for (Fruit fruit : list) { fruit.getname(); } } public static void main(String[] args) { Apple b; Jonathan c; Orange d; List<Apple> alist = new ArrayList<>(); alist.add(new Apple("Wu")); alist.add(new Jonathan("Yi")); List<Fruit> blist = new ArrayList<>(); blist.add(new Apple("Mi")); blist.add(new Jonathan("Ng")); blist.add(new Fruit("Wu")); blist.add(new Orange("Lp")); act(alist); //输出WuYi 只能是Apple的子类，但仍能作为参数适配List<? extends Fruit> } }
同理，<? super Fruit>和<?>分别是下界通配符和无界通配符。
2018.10.28终于算是给通配符画上了一个逗号吧，几个月了都。。。。最近效率有点低。
遇到的两个错误：
(1)List有两个一个在util,一个在awt。不要弄错啊，否则就报错。
(2)其实List是不能被实例化的，Cannot instantiate the type List，
List<Fruit> blist = new List<>(); (×)
List<Fruit> blist = new ArrayList<>(); （√）
二、枚举
1.声明
声明方式与类和接口相同，不能被private、protected、abstract等修饰，若被public修饰，文件名应与枚举名相同。
enum M_DAYS { Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday }
上面是一个枚举声明的例子。
2.枚举变量
(1)单个枚举变量。
M_DAYS m=M_DAYS.Monday; //赋值方法
System.out.println(m.toString());
System.out.println(m);
System.out.println(m.name());
以上三个打印都会输出Monday，方法都等于System.out.println(M_DAYS.Monday);
单个枚举变量的重要性质——可以调用所有枚举常量，当然用枚举名可以访问所有枚举常量：
System.out.println(m.Friday==M_DAYS.Friday); //有警告，就像警告对象名调用的静态域或方法一样。
当然返回true.
(2)多个枚举变量。
M_DAYS m1,m2,m3;
(3)枚举变量数组
M_DAYS []k=M_DAYS.values(); //M_DAYS.values()和m.values()是一样的效果 for(M_DAYS l:k) { System.out.println(l); }
values()方法通过枚举名或枚举变量访问，返回所有枚举常量。上述代码输出所有的枚举常量。
3.switch方法
M_DAYS m=M_DAYS.Sunday; switch(m) { case Monday: System.out.println(m.Monday); break; case Tuesday: System.out.println(m.Tuesday); break; case Wednesday: System.out.println(m.Wednesday); break; default: System.out.println("false"); }
一个值得注意的点是只要switch对象是枚举，case后面直接跟常量就好，例如上面直接用Monday,而不能M_DAYS.Monday或者m.Monday。
一个小case：default后面可以不加break.
4.枚举实现构造方法
enum Color
{
RED("红色",1),BlUE("蓝色",2),WHITE,GRAY(); //枚举常量
String name;
int index;
Color() //默认
{
name="null";
index=0;
}
Color(String name,int index) //构造方法
{
this.name=name;
this.index=index;
}
public void setName(String name) //普通方法
{
this.name=name;
}
public String toString() //覆盖的原有方法
{
return name+"_"+index;
}
}
public class enumclass {
public static void main(String []args)
{
Color c=Color.RED;
Color w=Color.WHITE;
c.setName("绿色");
System.out.println(c.toString());
System.out.println(w.toString());
}
}
对于枚举来说，前面说过枚举声明方式和类是相同的，那么它也能有自己的构造函数，但是构造函数只能是private或者是默认的，也是为了防止实例化枚举对象。如果没有显式声明构造函数，那么也会默认构造函数，也就是说没有构造函数的情况下有：
WHITE，GRAY()可以改为WHITE()，GRAY完全相同。都是创建一个静态的最终的类对象。
而添加方法、添加成员域、覆盖原有的方法与类一样(后期发现再来修改)。
5.实现接口、接口组织枚举
本来实现接口想不在叙述了的，后来发现一种奇特的实现方法，就是枚举的常量可以各自实现接口的方法
RED("红色",1)
{
public String getName()
{
return "111";
}
},
Blue("蓝色",2)
{
public String getName()
{
return "222";
}
},
WHITE
{
public String getName()
{
return "333";
}
},
NULL()
{
public String getName()
{
return "444";
}
}； //各常量各自实现接口
public String getName() //枚举的实现接口 { return name; }
Color c=Color.RED; //不能声明为Color.RED() Color w=Color.WHITE; c.setName("绿色"); System.out.println(c.getName()); System.out.println(w.getName());
结果：111
333 说明常量中的方法会覆盖枚举体内的方法，同理普通类也会覆盖。
接口组织枚举听起来好像很高大上，其实就是枚举里面有枚举，
