--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------

1.  静态导入

          静态导入：导入的是静态的方法，这样在调用类的时候就可以不用写类名了，直接可以使用静态方法。

      格式：import static 包名.类名.方法名；这是导入的是一个方法

       import static 包名.类名.*;导入的是这个类中的所有静态方法。

      普通的导入：导入的是类，调用其中的方法还得用类名或者是对象，格式：import 包名.类; 或者是  import 包名.*;

 import static java.lang.Math.*;//导入的是静态方法
public class Demo {
  public static void main(String[] args) {
    System.out.println(abs(-1));//求绝对值
  }
}

2.  可变参数

      可变参数是用…来表示的，其实里面封装了一个可变长度的数组。注意点：在定义参数的时候，一定要把其放到所有参数的后面。

 public class Demo {
  public static void main(String[] args) {
    sum("求和：",2,3,4,5);
    sum("求和：",4,34);
  }
  public static void sum(String str,int ...ss ){
    System.out.print(str);
    int sum=0;
    for(int s:ss)
      sum+=s;
    System.out.println(sum);
  }
}

3.  增强for循环

      格式：for(类型 变量：集合变量)

     此变量：必须实现了Iterator接口

    只能读取，不能对其进行其他操作(修改，删除，增加)

     String [] ss={"abc","123","de12"};

     for(String s:ss)

        System.out.println(s);

4.  自动装箱和拆箱

     在-128~127之间，基本数据它们都共享同一个对象，这样使用的享元模式，这样可以节约资源，但是超过这个范围，那么他们就会创建新的对象。

public class Demo {
  public static void main(String[] args) {
    Integer a=28;//装箱，自动装箱把Int类型封装成了Integer
    Integer b=28;
    System.out.println(a==b);//true
    //a和b是共享同意个对象
    Integer c=128;
    Integer d=128;
    System.out.println(c==d);//false
    //因为超出了-128~127范围，所以c和d不会共享同一个对象，是两个对象
    Integer e=28;
    int f=e+12;//自动拆箱，Integer没有+的运算，使用的是int的+运算，所以是把Integer类型的转换成int类型，做的加法运算
  }
}
 

5.  枚举

       1.  概述

       枚举类就是一个特殊的类，使用关键字enum来修饰类，enum 类名{}，里面值规定了特有的几个对象，那么在获取的时候，也就这几个对象，不能是其他的对象。

       2.  模拟枚举类

 abstract class EnumColor {
  /*
   * 其实也可以不使用内部类，把nextColor方法定义成普通方法，里面使用if~else进行判定
   * 然后指定下一个颜色，但是那样比价麻烦，使用内部类替换了，这样更清晰，是enmu的特点
   */
  public final static EnumColor Black = new EnumColor() {// 定义的是成员变量，使用类内部类
    public EnumColor nextColor() {
      return Red;
    }
  };
  public final static EnumColor Red = new EnumColor() {
    public EnumColor nextColor() {
      return Blue;
    }
  };
  public final static EnumColor Blue = new EnumColor() {
    public EnumColor nextColor() {
      return Black;
    }
  };
 
  /* 构造方法私有化，防止其他类继承 */
  private EnumColor() {
  }
 
  public abstract EnumColor nextColor();
 
  public String toString() {
    return this == Black ? "Black" : (this == Red ? "Red" : "Blue");
  }
}
public class Demo {
  public static void main(String[] args) {
    EnumColor red=EnumColor.Red;//红色
    System.out.println("red.newColor():"+red.nextColor());
  }
}
结果：
red.newColor():Blue

        3.  枚举的常用方法

 public class Demo {
  enum WeekDay {
    SUN, MON, TUE, WED, THU, FRI;// 最后的分号也可以不要，但是要是成员变量列表后面有信息的话，那么就必须加上分号，默认的调用无参构造方法
  }
 
  public static void main(String[] args) {
    WeekDay mon=WeekDay.MON;
    WeekDay sun=WeekDay.valueOf("SUN");//将字符串转换成枚举类型
    WeekDay []days=WeekDay.values();//获得枚举中的所有对象
    System.out.println(days.length);//6
   
  }
}

       4.  枚举对象

public enum TrafficLamp {
  RED(30) {
    public TrafficLamp nextLamp() {
      return GREEN;
    }
  },
  GREEN(40) {
    public TrafficLamp nextLamp() {
      return YELLOW;
    }
  },
  YELLOW(10) {
    public TrafficLamp nextLamp() {
      return RED;
    }
  };// 这里必须加分号：因为后面有语句,默认的调用无参构造方法
  private TrafficLamp() {
  }
 
  private TrafficLamp(int time) {
    this.time = time;
  }
 
  private int time;
 
  public abstract TrafficLamp nextLamp();//抽象方法，在变量后使用内部类来重写
 
  public String toString(){//重写toString()方法
    return this == RED ? "RED" : (this == GREEN ? "GREEN" : "YELLOW");
  }
}
public class Demo {
  public static void main(String[] args) {
    System.out.println(TrafficLamp.GREEN.nextLamp());
   
  }
}
结果：
YELLOW

注意点：

1.  在枚举成员变量列表前面不能加任何语句。

2.  枚举的构造方法必须是私有的(private)，为了是枚举类不能被继承

3.  当变量后什么也没有的话，那么就是默认的调用无参的构造方法，当调用自定义的构造方法的时候格式：变量(参数)

4.  也可以定义抽象方法，那么就使用内部类，在成员变量后面重写即可.使用内部类来实现其抽象方法。

5.  假如枚举中只有一个成员的话，那么就可以看作单例模式。

6.  在类中要是有抽象方法，必须要定义成抽象方法

但是如果在枚举中有抽象方法的话，不用定义成抽象的。

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！
--------------------