黑马程序员_<<基础加强--1.5新特性(上)>>

--------------------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培训、期待与您交流！
--------------------