java静态导入和枚举

静态导入：

Import 语句以一般的导入，导入一个类，或者某个包中的所有的类。

例如：Import java.util.*(导入java.util中的所有的类)

     Import java.util.Scanner (导入java .util.包中的Scanner类)

Import Static 语句导入一个类中的静态方法，或者是所有的静态方法

例如：Import Staticjava.lang.Math.max;(导入Math中的max静态方法)

例题：import java.util.Scanner;//导入Scanner类

publicclass Number

{

 

    publicstaticvoid main(String[] args)

    {

        Scanner input = new Scanner(System.in);

        double du = input.nextDouble();

        double dd=Math.abs(du);

        double df = Math.max(dd,6); //使用Math下的abs和max静态方法，要用Math

    }

}

importjava.util.Scanner;

importstatic java.lang.Math.abs;

importstatic java.lang.Math.*;

publicclass Number

{

 

    publicstaticvoid main(String[] args)

    {

        Scanner input = new Scanner(System.in);

        double du = input.nextDouble();

        double dd=abs(du);

        double df = max(dd,6);//使用abs和max方法，因为已经import static导入，所//以就可以直接来进行使用

    }

 

}

枚举

1：枚举是JDK1.5增加的新特性

枚举也是一个类，在使用这个类的时候，只能使用枚举类里面已经定义好的常量，用户不能在定义自己的变量。

理解：enum 中的元素是枚举类的对象，一切就OK了！

例如：publicclass Enum {

    publicstaticvoid main(String[] args) {

           String te = "ont";

           if(Textenum.valueOf(te) == Textenum.ont){

           System.out.println("ttt");

           }

           System.out.println(Textenum.out);

          

    }

  publicenum Textenum{

      ont ,two,three,fore;

       private Textenum(){}

      private Textenum(int i){}

  }

}

在enum类型的类Textenum类中，定义了四个元素：ont，two,three,fore。这四个元素实际上四个Textenum类型的四个对象，可以把它们当做普通的Textenum类的对象来进行使用。

如同：

publicclass Textenum{

    public Textenum(){};

    publicfinalstatic WeekDay ont = new WeekDay();//定义Textenum本身的对象，//并且为静态的常量。

publicfinalstatic WeekDay two = new WeekDay();

publicfinalstatic WeekDay three = new WeekDay();

publicfinalstatic WeekDay fore = new WeekDay();

 

 

}

枚举类型的标示符为enum，会自动封装。

2：Textenum.valueof(),是利用枚举类中的valueof（）方法（静态方法），把字符串“ont”在后台转化为Textenum的实际对象，这样就可以比较“out“和对象ont是否相同。

3：枚举类中的构造方法，必须是私有的，和普通类一样，可以定义多个构造方法。

如：

 publicenum Textenum{

     

      ont ,two,three,fore;

      private Textenum(){}

      private Textenum(int i){

  System.out.println(“two”);

}

     

  }

 

在定义的时候，想要调用不同的构造方法，如：ont这个对象调用不带参数的构造方法， two这个元素想调用带int参数的的构造方法

则为：publicenum Textenum{

     

      ont ,two(2）,three,fore;

      private Textenum(){}

      private Textenum(int i){

 System.out.println(“two”);

}

  }

这样在程序运行是，就会打印出two，说明在用two对象是，调用的是带参数的Textenum（int i）{}构造方法

publicenum Textenum{

         

          ont() ,two(3),three(),fore;

          private Textenum(){}

          private Textenum(int i){

             System.out.println("two");

      }

调用不带参数的构造方法也可以用ont(),three(),fore，加括号和不家括号都可以表示调用不带参数的构造方法。

4：枚举类型中含有抽象的方法。

如：publicenum  unmber{

          a{

 

            @Override

            public unmber sum() {

                // TODO Auto-generated method stub

                returnnull;

            }

          

          },

          b{

 

            @Override

            public unmber sum() {

                // TODO Auto-generated method stub

                returnnull;

            }

          

          },

          c{

 

            @Override

            public unmber sum() {

                // TODO Auto-generated method stub

                returnnull;

            }

          

          },

          d{

 

            @Override

            public unmber sum() {

                // TODO Auto-generated method stub

                returnnull;

            }

          

          },

          e{

 

            @Override

            public unmber sum() {

                // TODO Auto-generated method stub

                returnnull;

            }

          

          };

        publicabstract unmber sum();

    }

 

Number 类型中含有一个抽象的方法，sum（）；这样number中的元素就不能直接创建枚举类number的对象，只能通过它的子类来创建对象，

如：a{

            @Override

            public unmber sum() {

                // TODO Auto-generated method stub

                returnnull;

            }

这种方式可以看做事一个匿名内部类的方式。它的子类是一个匿名内部类。