Core Java(十三)

 

Java API5.0新特性：

优化的功能：对编译器进行的优化

静态引入：

什么是静态引入？将类的静态成员预先引用进来，直接使用就可以了，例如：System.out，直接写成out.printl();就可以了

语法：

        import static 包名.类名.静态成员名

/**

 * 知识点：

 * staticimport:静态引入

 * 程序目标：

 * 测试静态引入的用法

 */

package MY.module12.staticimport;

import static java.lang.Math.*;

import static java.lang.System.out;

public class Test1 {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              System.out.println(Math.abs(-21.57));

              out.println(abs(-30.57));

       }

 

}

注意事项：

        import同名冲突

/**

 * 知识点：

 * 静态引入的注意点：同名静态成员使用冲突

 * 程序目标：

 * 测试同名静态成员使用冲突

 */

package MY.module12.staticimport;

import static java.lang.Integer.*;

import static java.lang.Long.*;

public class Test2 {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

//          System.out.println(MAX_VALUE);

//          System.out.println(MAX_VALUE);//冲突

              System.out.println(Integer.MAX_VALUE);

              System.out.println(Long.MAX_VALUE);

       }

 

}

自动封箱/解箱：Auto-boxing/unboxing

将基本数据类型与Wrapper class做自动转换。

可直接把基本数据类型与Wrapper class做算术运算

/**

 * 知识点：

 * autoboxing/unboxing

 * 程序目标：

 * 测试autoboxing/unboxing的功能

 */

package MY.module12.autoboxing;

 

public class Test1 {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              Integer i1=1;//autoboxing

              int a=i1;//unboxing

              int sum=i1+a;//可直接把基本数据类型与Wrapper class做算术运算

       }

 

}

在容器中体现自动装箱解箱：

/**

 * 知识点：

 * 自动封箱

 * 程序目标：

 * 测试在容器中直接添加基本类型数据，体现封箱的特点

 */

package MY.module12.autoboxing;

import java.util.*;

public class Test2 {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              List list=new ArrayList();

              //list只能添加对象，基本数据类型不行，在这里，1自动装箱为包装类

              //的对象

              list.add(1);

              list.add(2);

              System.out.println(list);

       }

 

}

当调用一个方法并且传参数时，在方法重载的时候，先找同类型的参数方法，如果没有，找比它大的参数类型，如果还没有，找包装类型的参数，三次：

1．一样的

2．比自己大的

3．相对应的包装类型

/**

 * 知识点：

 * Autoboxing/unboxing

 * 程序目标：

 * 当方法重载的时候，调用的情况

 */

package MY.module12.autoboxing;

import static java.lang.System.*;

public class Test3 {

      

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              int i=10;

              Integer i2=100;

              f1(i);

              f1(i2);

       }

       public static void f1(char i){

              out.println("long's"+i);

       }

       public static void f1(Integer i){

              out.println("int's"+i);

       }

 

}

for-each循环：

语法：for(集合元素类型 变量名: 集合)

/**

 * 知识点：

 * for-each循环

 * 程序目标：

 * 使用for-each循环将list中的对象显示出来

 */

package MY.module12.foreach;

import java.util.*;

import static java.lang.System.*;

public class TestForeach {

      

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              List list=new ArrayList();

              list.add("hello");

              list.add("world");

              for(Object obj:list){

                     out.println(obj);

              }

       }

 

}

 

可变长参数：varags

什么意思？在方法中参数的个数可以不确定

       使用注意：

              vargas参数的声明必须是所有参数声明的最后一个

              一个方法的声明中，只能有一个vargas

              在重载时，不能与数组并存

/**

 * 知识点：

 * 可变长参数varags

 * 程序目标:

 * 测试可变长参数

 */

package MY.module12.varags;

import static java.lang.System.*;

public class TestVarags {

      

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              int sum=f2(1,2,3,4,5);

              out.println(sum);

              String s=f1("hello","world");

              out.print(s);

       }

       public static String f1(String...s){

              out.println(s.length);

              String str="";

              for(String x:s){

                     str+=x;

              }

              return str;

       }

      

       public static int f2(int...i){

              int length=i.length;

              int sum=0;

              out.println(length);

              for(int a:i){

                     sum+=a;

              }

              return sum;

       }

       //如果有了varags，在重载方法中，就不能使用数组了，因为代表的是

       //一个意思

//   public static int f2(int[] i){

//          return 0;

//   }

 

}

 

泛型：

什么是泛型？

是一种数据类型，这个类型是不确定的，也可以指定类型，不确定是说可以参数化的，又叫参数化类型

语法：

       类型变量<占位符或者指定类型>

有什么用呢？

增强了类型安全，例如：list是可以加入任何类型的对象的，但是我们有时候需要他加入特定类型的对象，这个时候我们就可以使用泛型

/**

 * Java文件说明:

 * Car.java:汽车类,有颜色属性

 * Color.java:给汽车设置颜色的类,有三种颜色

 * Test.java:得到汽车,给汽车着色,但是上色的范围只能是这三个颜色,并且只能

 * 通过Color类给汽车上色

 * 发现问题:

 * 不能满足程序的目标,参数的类型不安全

 */

package MY.module12.Fanxing.yinli;

 

public class Test {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              Car car=new Car();

              car.setColor(Color.Blue);

              car.setColor("red");//参数类型不安全,我只希望设置Color类中的值,然而不能实现这一要求

       }

 

}

package MY.module12.Fanxing.yinli;

 

public class Car {

       private String Color;

 

       public String getColor() {

              return Color;

       }

 

       public void setColor(String color) {

              Color = color;

       }

      

}

package MY.module12.Fanxing.yinli;

 

public class Color {

        static String Blue="1";

        static String Red="2";

        static String GREEN="3";

}

 

/**

 * 程序目标:

 * People.java:有个属性:姓名

 * Car.java:有个属性:大小

 * Test.java:把People的对象放到List容器中,List不应该再放其他的类型对象了

 * 发现问题:

 * list本身是没有对象类型的限制的,所以,当我们想让这个容器只能添加一个

 * 类型的对象的时候,处理起来比较麻烦,不合理,那么应该怎么解决这个问题呢?

 */

package MY.module12.Fanxing.yinli2;

import java.util.*;

import static java.lang.System.*;

public class Test {

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              List list=new ArrayList();

              list.add(new People("zhang san"));

              list.add(new People("li si"));

              list.add(new Car(10));

             

              Iterator iterator=list.iterator();

              while(iterator.hasNext()){

                     People p=(People)iterator.next();//结果会出现异常

                     //因为里面有一个Car类的对象,这样不符合要求,我只想这个容器

                     //加入People类对象,现在这种情况是类型不安全的

                     out.println(p.getName());

              }

       }

 

}

package MY.module12.Fanxing.yinli2;

 

public class Car {

       private int size;

 

       public Car(int size) {

              super();

              // TODO Auto-generated constructor stub

              this.size = size;

       }

 

       public int getSize() {

              return size;

       }

 

       public void setSize(int size) {

              this.size = size;

       }

      

}

package MY.module12.Fanxing.yinli2;

 

public class People {

       private String name;

 

       public People(String name) {

              super();

              // TODO Auto-generated constructor stub

              this.name = name;

       }

 

       public String getName() {

              return name;

       }

 

       public void setName(String name) {

              this.name = name;

       }

      

}

通过泛型我们可以解决类型安全的问题:

/**

 * 知识点:

 * 参数化类型

 * 程序目标:

 * 只能让List加入指定的People对象

 */

package MY.module12.Fanxing.yinli2;

import java.util.*;

public class Test1 {

      

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              List<People> list=new ArrayList();

              People p1=new People("zhang san");

              People p2=new People("li si");

              Car car=new Car(1000);

              list.add(p1);

              list.add(p2);

//          list.add(car);只能添加参数化的类型People

              System.out.println(list.get(0).getName());

             

              People p=list.get(1);

              System.out.println(p.getName());

             

              Iterator<People> it=list.iterator();//要想得到对象,必须也参数化list中的参数化类型

              while(it.hasNext()){

                     People pp=it.next();

                     System.out.println(pp.getName());

              }

             

              for(People ppp:list){

                     System.out.println(ppp.getName());

              }

       }

 

}

多个占位符:

/**

 * 知识点:

 * 多个占位符

 * Java文件说明:

 * People.java,Car.java,Test2.java

 * 程序目标:

 * 使用有多个占位符的类型变量

 */

package MY.module12.Fanxing.yinli2;

import java.util.*;

import static java.lang.System.*;

public class Test2 {

      

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              Map<Integer,People> map=new HashMap<Integer,People>();//也可以在HashMap后面写上

              map.put(1,new People("yuchen"));

//          map.put("hello",new People("lisi"));

//          map.put(2,new Car(10));

              People p=map.get(1);

              out.println(p.getName());

       }

 

}

 

 

                     小结：

                     (1)泛型是一种带占位符的类型，使用时

                            提供实际参数（参数化类型）。

                     (2)泛型类型解决了类型安全问题

                            如：在将数据放入Collection时，

                            通过泛型类型的声明，确保只有

                            同一类型的对象会加入到容器中，

                            在取出时，不用做类型的转换

                     （３）泛型不能使用基本类型

                            如：Set<char>或者List<int>

泛型也可以充当一个占位符,可以被参数化：

package MY.module12.Fanxing.yinli2;

import static java.lang.System.*;

import java.util.*;

public class Test3 {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              List<People> list=new ArrayList();

              list.add(new People("zhang san"));

              list.add(new People("li si"));

             

              List<Car> list2=new ArrayList<Car>();

              list2.add(new Car(3));

              list2.add(new Car(5));

             

              Map<Integer,List<People>> map=new HashMap<Integer,List<People>>();

//          map.put(1,list2);

              map.put(1,list);

             

//          List list3=map.get(1);如果写成这样,for-each循环中报错

              //因为,list3中得到的对象都是People类型的,list3指向的是list对象

              //list对象是<People>所以应该按下面的方法写

              List<People> list3=map.get(1);

              for(People p:list3){

                     out.println(p.getName());

              }

       }

 

}

使用时注意的问题:

1.      在1.5中将一些类进行了重写(泛型),所以,当不写泛型参数的话,将提示警告

2.      泛型类型的转换问题:泛型中参数化类型一定要一样,被转换为非参数化是可以的

       ArrayList<Integer> l = new ArrayList<Integer>();

       List<Integer> m = l; // ok

       Collection<Integer> n = l; // ok

       ArrayList<Number> o = l;   // error

       List<Object> lo = l;//error 一个List<X>不允许被转换为一个List<Y>，即使这个X能够被转换为Y

       List listold = l;//ok 参数化类型转换为非参数化类型是允许的

/**

 * 知识点:

 * 注意问题:

 * 2.泛型类型的转换问题:泛型中参数化类型一定要一样,被转换为非参数化是可以的

 * 程序目标:

 * 验证上面那句话

 */

package MY.module12.Fanxing.second;

import java.util.*;

public class Test1 {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              ArrayList<Integer> l=new ArrayList<Integer>();

              List list=l;

              List<Integer> list2=l;

              Collection<Integer> c=l;

              Collection c2=l;

             

       //       List<Object> list3=l;

       //       ArrayList<Number> o = l;

       }

 

}

运行时类型安全:

                            泛型设定的信息经过编译后不会

                            保留在.class文件中，即泛型

                            仅提供了编译期的类型安全。

                           

                            使用java.util.Collections中

                            的checkedList()和checkedMap( )

                            方法,通过这个方法，我们可以在

                            运行时，立即捕获类型不匹配错误。

/**

 * 知识点:

 * 运行时类型安全

 */

package MY.module12.Fanxing.second;

import java.util.*;

public class Test2 {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

//          List<Integer> list=new ArrayList<Integer>();

             List list=new ArrayList();

//          List list2=list;

//          list2.add(1);

//          list2.add("hello");

//          Integer i=list.get(0);

              //这里应该编译不能通过的,可是确在运行的时候报错

              //为什么运行时报错而不是编译的时候呢?

              //因为:泛型在编译的时候不将信息保存在.class文件中,这样就通过了

              //编译期类型安全的检查,他会在运行的时候做类型安全检查

              //这里的错误是因为加入的是String对象list2.add("hello");而规定是//Integer

              //所以,我希望在报错的时候,能够在list2.add("hello");给予提示,这样

              //我就清楚为什么出错了,我可以通过下面的方法实现这个目标

              List<Integer> list=new ArrayList<Integer>();

              List<Integer> list2=Collections.checkedList(list,Integer.class);

              List list3=list2;

              list3.add("hello");//运行时,提示这个有错误

              Integer i=list.get(0);

       }

 

}

类型参数通配符:<?>

通配符的作用,和不是泛型的参数的区别?有通配符的参数,在方法中不能随意的添加对象,要按照指定的类型添加,如果参数不是泛型,就没有限制了

/**

 * 知识点:

 * 通配符

 * 程序目标:

 * 测试通配符的功能作用

 * 思考:通配符和不写泛型有什么区别,使用通配符有什么好处

 */

package MY.module12.Fanxing.second;

 

import java.util.*;

 

public class Test3 {

      

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              List list=new ArrayList();

              list.add(1);

              display(list);

              display(list);

              display3(list);//如果不是泛型,也可以调用参数为泛型的方法,因为可以类型转换

              List<String> list2=new ArrayList<String>();

              list2.add("zhangsan");

              display(list2);

              display2(list2);

              display3(list2);

              List<Integer>list3=new ArrayList<Integer>();

              list3.add(2);

       //       display(list3);error

              display2(list3);

              display3(list3);

//          List<?>list4=new ArrayList<?>();error

       }

       public static void display(List<String> list){

              for(Object s:list){

                     System.out.println(s);

              }

       }

      

       public static void display2(List list){

              for(Object obj:list){

                     System.out.println(obj);

              }

       }

      

       public static void display3(List<?> list){

              for(Object obj:list){

                     System.out.println(obj);

              }

       }

 

}

界定通配符:

普通的通配符不能很好的保证类型安全,界定的通配符可以解决这个问题

/**

 * 知识点:

 * 界定通配符

 * Java文件说明:

 * People.java

 * Man.java

 * Woman.java

 * 程序目标:

 * 验证界定通配符的作用

 */

package MY.module12.Fanxing.second;

import java.util.*;

public class Test4 {

      

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              List<Integer>list=new ArrayList<Integer>();

              list.add(1);

              list.add(10);

              double d=sumList(list);

              System.out.println(d);

             

              List<People>list2=new ArrayList<People>();

              list2.add(new Man(20));

              list2.add(new Woman(30));

              sumList2(list2);

             

              List<Man>list3=new ArrayList<Man>();

              list3.add(new Man(23));

              sumList2(list3);

       }

       public static double sumList(List<? extends Number> list){

              double d=0.0;

              for(Number n:list){

                     d+=n.doubleValue();

              }

              return d;

       }

       public static void sumList2(List<? extends People>list){

              int age=0;

              for(People p:list){

                     System.out.println(p);

              }

       }

}

package MY.module12.Fanxing.second;

 

public class People {

 

}

package MY.module12.Fanxing.second;

 

public class Man extends People{

       private int age;

 

       public Man(int age) {

              super();

              // TODO Auto-generated constructor stub

              this.age = age;

       }

 

       public int getAge() {

              return age;

       }

 

       public void setAge(int age) {

              this.age = age;

       }

 

       @Override

       public String toString() {

              // TODO Auto-generated method stub

              StringBuffer sb=new StringBuffer();

              sb.append(age);

              return sb.toString();

       }

      

}

package MY.module12.Fanxing.second;

 

public class Woman extends People{

       private int age;

 

       public Woman(int age) {

              super();

              // TODO Auto-generated constructor stub

              this.age = age;

       }

 

       public int getAge() {

              return age;

       }

 

       public void setAge(int age) {

              this.age = age;

       }

 

       @Override

       public String toString() {

              // TODO Auto-generated method stub

              StringBuffer sb=new StringBuffer();

              sb.append(age);

              return sb.toString();

       }

      

}

自定义泛型类:

              首先，在一对尖括号(< >)中

              声明类型变量，以逗号间隔

              变量名列表。命名一个类型变量习惯于一个

              大写字母。

              注意：在类的实例变量和方法中，

              可以在任何类型的地方使用那些类型变量。

              切记，类型变量仅在编译时存在，所以不能使用

              instanceof和new这类运行时操作符来操作类型变量。

/**

 * 知识点:

 * 自定义泛型类

 * Java文件说明:

 * EntrySet.java:自定义的泛型类

 * EntrySetTest.java

 */

package MY.module12.Fanxing.mygenerics;

import static java.lang.System.*;

public class EntrySetTest {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              EntrySet<Integer,String>es=new EntrySet<Integer,String>(1,"zhang san");

              out.println(es.getKey());

              out.println(es.getValue());

              es.setKey(20);

              out.println(es.getKey());

       }

 

}

package MY.module12.Fanxing.mygenerics;

 

public class EntrySet<K,V> {

       private K key;

       private V value;

       public EntrySet(K key, V value) {

              super();

              // TODO Auto-generated constructor stub

              this.key = key;

              this.value = value;

       }

       public K getKey() {

              return key;

       }

       public void setKey(K key) {

              this.key = key;

       }

       public V getValue() {

              return value;

       }

       public void setValue(V value) {

              this.value = value;

       }

      

}

/**

 * 知识点:

 * 自定义泛型类

 * Java文件说明:

 * Car.java:汽车类

 * BMWCar.java:宝马汽车

 * BenZCar.java:奔驰汽车

 * CarFactory.java:生产汽车的简单工厂,功能如下:

 * 生产入库,全部出库,出库(某一辆),查看库存数量,得到出库的权利

 * Test.java:用户实际操作

 */

package MY.module12.Fanxing.third;

import java.util.*;

public class Test {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              CarFactory<BMWCar> c=new CarFactory<BMWCar>();

              c.add(new BMWCar());

              System.out.println(c.count());

              c.add(new BMWCar());

              System.out.println(c.count());

              System.out.println(c.getAll());

              System.out.println(c.getCar(0));

              Iterator<BMWCar> it=c.iterator();

              while(it.hasNext()){

                     System.out.println(it.next());

              }

       }

 

}

package MY.module12.Fanxing.third;

 

public class Car {

      

}

package MY.module12.Fanxing.third;

 

public class BenZCar extends Car{

       private static final String s="BenZCar";

 

       @Override

       public String toString() {

              // TODO Auto-generated method stub

              StringBuffer sb=new StringBuffer();

              sb.append(s);

              return sb.toString();

       }

      

}

package MY.module12.Fanxing.third;

 

public class BMWCar extends Car{

       private static final String s="BMWCar";

       public String toString() {

              // TODO Auto-generated method stub

              StringBuffer sb=new StringBuffer();

              sb.append(s);

              return sb.toString();

       }

}

package MY.module12.Fanxing.third;

import java.util.*;

public class CarFactory<K extends Car> {

       private List<K> list;//库房

       public CarFactory(){

              list=new ArrayList<K>();

       }

       public void add(K k){//汽车入库

              list.add(k);

       }

       public List<K> getAll(){//全部出库清仓

              return list;

       }

       public K getCar(int i){//出库(某一辆)

              return list.get(i);

       }

       public int count(){//查看库存数量

              return list.size();

       }

       public Iterator<K> iterator(){

              return list.iterator();

       }

}

 

枚举:

引例:

/**

 * Java文件说明:

 * Car.java:汽车类,有颜色属性

 * Color.java:用来给汽车上颜色

 * Test.java:生产汽车,并上颜色

 * 程序目标:

 * 用户买一辆汽车,颜色范围只有三种,不能选择其他的颜色

 * 发现问题:

 * 不能满足业务规则

 */

package MY.module12.enums.first;

 

public class Test {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              Car c=new Car();

              c.setColor(Color.RED);

              c.setColor(1);//编译可以通过,违反了我的业务规则

       }

 

}

package MY.module12.enums.first;

 

public class Car {

       private int Color;

 

       public Car() {

              super();

              // TODO Auto-generated constructor stub

       }

 

       public int getColor() {

              return Color;

       }

 

       public void setColor(int color) {

              Color = color;

       }

      

}

package MY.module12.enums.first;

 

public class Color {

       public static final int BLUE=0;

       public static final int RED=1;

       public static final int GREEN=2;

}

通过枚举类型可以解决上面的问题:

什么是枚举?给出业务需要的取值范围的类型

如何定义一个枚举类型:

语法:    

public enum 名称{

       属性

       构造器

       方法

}

              说明：

                     （１）自动继承java.lang.Enum类。

                     （２）构造器不能用public，protected

                                   修饰。

                     （３）声明枚举类型的值时，直接输入字

                            符，编译器会自动为这些值加上public、

                            static、final修饰符。

                     （４）枚举类型方法或变量必须在

                            枚举值申明的后面。

                     （５）枚举也可定义在一个类的内部。

/**

 * 知识点:

 * 定义一个枚举类型

 */

package MY.module12.enums.second;

 

public enum CarColor {

       RED,

       GREEN,

       BLUE,

}

/**

 * 知识点:

 * enum

 * Java文件说明:

 * Car.java

 * CarColor.java:定义了一个枚举类型

 * 程序目标:

 * 给汽车上颜色,只能有指定的颜色范围

 */

package MY.module12.enums.second;

 

public class Test {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              Car car=new Car();

              car.setColor(CarColor.BLUE);

//          car.setColor(1);

              System.out.println(car.getColor());

       }

 

}

package MY.module12.enums.second;

 

public class Car {

       private CarColor color;

 

       public CarColor getColor() {

              return color;

       }

 

       public void setColor(CarColor color) {

              this.color = color;

       }

      

}

像内部类一样使用:

/**

 * 知识点:

 * enum的内部类写法

 * 程序目标:

 * 测试enum的内部类写法

 */

package MY.module12.enums.second.t1;

 

public class Test2 {

       enum type{

              a,

              b,

              c,

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              System.out.println(type.a);

       }

 

}

 

package MY.module12.enums.second.t2;

import static MY.module12.enums.second.t2.Superior.*;

import static java.lang.System.*;

public class Test {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              huashanlunjian(Dongxie,XiDu,Nandi,BeiGai);

              out.println(Dongxie);

              out.println(Dongxie.name());

              out.println(Dongxie.getDetail());

              Superior s=Superior.valueOf("BeiGai");

              out.println(s);

       }

       public static void huashanlunjian(Superior...sup){

              for(Superior s:sup){

                     out.println(s.getDetail());

                     out.println(s);//Dongxie等可以看做对象,打印对象调用toString方法

                     //this是说当前对象

              }

       }

}

package MY.module12.enums.second.t2;

 

public enum Superior {

       Dongxie("黄药师", "弹指神通"), XiDu("欧阳峰", "蛤蟆功"), Nandi("段皇爷", "一阳指"), BeiGai(

                     "洪七公", "降龙十八掌");

      

       private String name;

       private String wugong;

       private Superior(String name, String wugong) {

              this.name = name;

              this.wugong = wugong;

       }

       public String getDetail(){

              return (name + " " + wugong);

       }

       public String toString() {

              // TODO Auto-generated method stub

              String desc = null;

              switch (this) {

              case Dongxie:

                     desc = "桃花岛主";

                     break;

              case XiDu:

                     desc = "白驼山主";

                     break;

              case Nandi:

                     desc = "大理皇帝";

                     break;

              case BeiGai:

                     desc = "丐帮帮主";

                     break;

              default:

                     desc = "Not defined";

              }

              return desc;

       }

}

Enum类:

package MY.module12.enums.third;

 

import MY.module12.enums.second.*;

import static MY.module12.enums.second.CarColor.*;

import static java.lang.System.*;

//可用static import将枚举值导入进来

 

/**

 * 演示枚举类的基本方法及枚举使用注意事项

 *

 */

public class Test1 {

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

             

              //compareTo

              //比较两个枚举值的顺序

              int result = RED.compareTo(BLUE);

              out.println("RED.compareTo(BULE) "+result);

             

             

              //equals

              boolean isEqual = RED.equals(RED);

              out.println("RED.equals(BULE) "+isEqual);

             

              //ordinal

              //次序值

              int indexOfRED = RED.ordinal();

              out.println("RED.ordinal() "+indexOfRED);

             

              //name

              //取得枚举值对应的名称字符串

              String s = RED.name();

              out.println("RED.name() "+s);

             

              //valueof

              //跟name方法相反，取得与字符串对应的枚举类型的值

              CarColor color = CarColor.valueOf("RED");

              out.println("color's name "+color.name());

             

              //values

              //取出枚举类型的所有值

             CarColor[] colors = CarColor.values();

             

              //可用for-each循环来遍历所有枚举值

              for(CarColor carcolor:colors){

                     out.println(carcolor);

              }

             

              //枚举值也可用在switch语句中

              CarColor colorKey = CarColor.valueOf(args[0]);

              switch(colorKey){

              case RED:

                     out.println("your select is "+colorKey);

                     break;

              case BLUE:

                     out.println("your select is "+colorKey);

                     break;

              default:

                     out.println("your select is others");

              }

             

       }

 

}

注释:Annotations

什么是注释?添加到代码中的修饰符,用来为相关程序提供额外的信息

分三种:

1.      直接用的注释

2.      注释的注释

3.      自定义的注释

 

1.      直接用的注释:

@Override:表明该方法为重置方法

@Deprecated:已经过失的方法

@SuppressWarnings("unchecked"):去掉警告

/**

 * 知识点:

 * 三个系统注释

 * Java文件说明:

 * Car.java,BMWCar.java

 * 程序目标:

 * 测试系统注释

 */

package MY.module12.Annotation.t1;

 

import java.util.*;

 

public class BMWCar extends Car{

       private List list=new ArrayList();

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              BMWCar c=new BMWCar();

              c.f2();

       }

 

       @Override

       public void f1() {//表示该方法是重置方法

             

       }

       @Deprecated

       public void f2(){

              System.out.println("已经过时");

       }

      

       @SuppressWarnings("unchecked")

       public void f3(){

              list.add(10);//会警告类型不安全,加上这个注释就不警告了

       }

}

package MY.module12.Annotation.t1;

 

public class Car {

       public void f1(){

             

       }

}

2.      注释的注释:原注释 和自定义注释

用来描述注释的注释

Target:

       用来指定Annotation类型可用在哪些元素上。

Retention

       设定Annotation类型的信息保留到什么时候。

/**

 * 知识点:

 * 自定义注释和原注释

 * 程序目标:

 * UsingMyAnnotation.java:

 * 1.打印被注释的那个方法的名字

 * 2.打印注释的信息

 * 3.执行被注释的那个方法

 * 使用反射的机制

 * MyFirstAnnotation.java:自定义的注释类

 *

 */

package MY.module12.Annotation.t2;

 

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

 

public class UsingMyAnnotation {

       @MyFirstAnnotation("是我的")

       public void info(){//被注释的方法

              System.out.println("hello");

       }

       public static void fenxi(Class c) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{

              Object uma=(UsingMyAnnotation) c.newInstance();

              Method[] m=c.getDeclaredMethods();

              for(Method mm:m){

                     String s=mm.getName();

                     if(s.equals("info")){

                            System.out.println("method' name is :"+s);

                            MyFirstAnnotation mfa=mm.getAnnotation(MyFirstAnnotation.class);

                            if(mfa!=null){

                                   System.out.println(mfa.value());

                                   mm.invoke(uma,new Object[]{});

                            }

                     }

              }

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              try {

                     fenxi(UsingMyAnnotation.class);

              } catch (IllegalArgumentException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (InstantiationException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IllegalAccessException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (InvocationTargetException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

 

}

package MY.module12.Annotation.t2;

import java.lang.annotation.ElementType.*;

import java.lang.annotation.*;

@Target(ElementType.METHOD)//该注释只能给方法注释

@Retention(RetentionPolicy.RUNTIME)//在运行的时候保存注释信息

public @interface MyFirstAnnotation {

       String value();

}

/**

 * 知识点:

 * 注释类中的注释类

 * 程序目标:

 * L.java:注释类,包含T.java类

 * T.java:注释类

 * Test.java:

 * 通过反射得到注释信息

 */

package MY.module12.Annotation.t3;

@L(name="zhangsan",notice="许可证",

              redistributable=true,

              t={@T(name="1",owner="a"),@T(name="2",owner="b")}

              )

public class Test {

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              Test t1=new Test();

              L l=t1.getClass().getAnnotation(L.class);

              System.out.println(l.name());

              System.out.println(l.notice());

              System.out.println(l.redistributable());

              T[] tt=l.t();

              for(T ttt:tt){

                     System.out.println(ttt.name()+" "+ttt.owner());

              }

       }

 

}

package MY.module12.Annotation.t3;

 

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

 

import linshi.annotation.t2.Trademark;

 

@Retention(RetentionPolicy.RUNTIME)

 

@Target({ElementType.TYPE, ElementType.PACKAGE})

public @interface L {

       String name();

 

       String notice();

 

       boolean redistributable();

 

       T[] t();

}

package MY.module12.Annotation.t3;

 

public @interface T {

       String name();

       String owner();

}