Java在JDK5中添加了增强for,静态导入,可变参数,泛型,自动拆装箱等新特性。
自动拆装箱在基本类型的包装类型的文章中总结过。这里主要说增强for,静态导入、可变参数和泛型。
增强for循环
增强for的出现主要是为了替代迭代器，使代码更加简洁。
增强for的缺点：
如果集合为空则会发生异常。需要加非空判断。
增强for依然会发生并发修改异常，需要遍历修改的时候还是要使用普通for，size和get方法相结合来遍历。
import java.util.ArrayList;
public class test {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
// 增强for
if (list != null) {
// 非空判断防止发生空指针异常NullPointerException
for (String s : list) {
System.out.print(s + ",");// hello,world,java,
}
}
}
}静态导入
静态导入的格式: import static 包名.类名.方法名//静态导入
import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.Math.min;
public class test {
public static void main(String[] args) {
int a = 5;
int b = -1;
// 静态导入后可以直接使用该方法
System.out.println(abs(b));// 1
System.out.println(max(a, b));// 5
System.out.println(min(a, b));// -1
}
}可变参数
当方法的参数个数不确定的时候可以使用可变参数，在源码里面出现的多，实际开发慎用。
public class test {
public static int sum(int... a) {// 定义可变参数
// 可变参数相当于数组的处理方式
// 定义最终结果变量
int result = 0;
// 通过增强for遍历处理a
for (int i : a) {
result += i;
}
return result;
}
public static void main(String[] args) {
int a = 1;
int b = 2;
int c = 3;
int d = 4;
System.out.println(sum(a, b));// 3
System.out.println(sum(a, b, c));// 6
System.out.println(sum(10, 20, 30));// 60
}
}泛型
虽然集合可以存储不同类型的元素，但是当我们遍历集合的时候用来接收的元素类型是固定的，这个时候就容易发生类型不匹配的问题，为预防这种问题发生，Java中为我们提供了泛型来限定集合中的元素类型。
加上泛型的好处：
- 解决了黄色警告线的问题。
- 类型不匹配问题会在编译时期就暴露出来，提高了程序的安全性。
- 遍历时不需要强制类型转化，简化了代码，提高可读性。
import java.util.ArrayList;
import java.util.Iterator;
public class test {
public static void main(String[] args) {
ArrayList<String> a = new ArrayList<String>();
// 在集合的定义中用尖括号里面写上元素类型来限定集合的类型
a.add("hello");// 可以解决黄色警告线的问题
a.add("word");
a.add("java");
//a.add(100); 添加类型不匹配的元素会在编译时期就报错
Iterator<String> it = a.iterator();
while (it.hasNext()) {
String s = it.next();// 不需要强制类型转化了
System.out.println(s);
}
}
}
/**
hello
word
java
*/注意：泛型中只能定义对象类型，也就是说想定义基本类型的时候必须定义成基本类型的包装类型。
泛型在类上定义
泛型定义在类上可以提高类的安全性，早期定义任意类型的成员变量时使用object表示任意类型，获取值时需要向下转型，容易发生类转换异常ClassCastException
class Student<T> {
//在类上定义泛型
private T obj;
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
}
public class test {
public static void main(String[] args) {
// 早期使用object表示任意类型，获取值时需要向下转型，容易发生类转换异常ClassCastException
Student<String> s = new Student<String>();
// 创建对象的时候可以限定对象的类型
s.setObj("张三");
// s.setObj(100);传入不匹配的类型会报错。
System.out.println("姓名：" + s.getObj());// 姓名：张三
Student<Integer> s2 = new Student<Integer>();
s2.setObj(27);// 这里自动执行了Integer.valueOf(27)将基本类型装箱成Integer类型
System.out.println("年龄：" + s2.getObj());// 年龄：27
}
}同样，泛型也可以定义在接口上，使用方式和类相似。
泛型在接口上定义
public interface Inter<T> {
// 接口中的变量只能为常量所以不能用泛型
public static final int num = 100;
public abstract void show(); // 抽象方法
}class InterImpl<T> implements Inter<T> {
@Override
public void show() {
System.out.println("hello");
}
}
public class InterDemo {
public static void main(String[] args) {
// 第二种情况
Inter<Integer> i2 = new InterImpl<Integer>();
i2.show();//hello
Inter<String> i3 = new InterImpl<String>();
i3.show();//hello
}
}
泛型在方法上定义
class Student{
public <T> void show(T a) {
System.out.println(a);
}
}
public class test {
public static void main(String[] args) {
Student s=new Student();
s.show("张三");
s.show(18);
s.show(true);
}
}
/**
张三
18
true
*/
需要注意，泛型变量不能直接进行运算操作，需要类型转化。
class Student {
public <T> void show(T a, T b) {
System.out.println((Integer) a + (Integer) b);
}
}
public class test {
public static void main(String[] args) {
Student s = new Student();
s.show(5, 2);//7
}
}泛型的通配符
<?>
代表任意类型Object类型,或者任意的Java类
<? extends E>
向下限定,E的子类或者E这个类型
<? super E>
向上限定,E及其他的父类
import java.util.ArrayList;
class Person {
}
class Student extends Person {
}
public class InterDemo {
public static void main(String[] args) {
// <?>任意类型
ArrayList<?> a1 = new ArrayList<Person>();
ArrayList<?> a2 = new ArrayList<Student>();
ArrayList<?> a3 = new ArrayList<String>();
// <? extends E> 向下限定
ArrayList<? extends Person> a4 = new ArrayList<Student>();
// ArrayList<? extends Person> a5=new ArrayList<Object>();报错，只能为Person本身或它的子类
// <? super E>:向上限定
ArrayList<? super Person> a5 = new ArrayList<Object>();
//ArrayList<? super Person> a6 = new ArrayList<Student>();报错，只能为Person本身或它的父类
}
}集合的嵌套遍历
在泛型中定义一个集合，让一个大集合包含很多个小集合import java.util.ArrayList;
class Student {
// 创建一个学生类
private String name;
private int age;
private String specialty;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSpecialty() {
return specialty;
}
public void setSpecialty(String specialty) {
this.specialty = specialty;
}
public Student() {
super();
}
public Student(String name, int age, String specialty) {
super();
this.name = name;
this.age = age;
this.specialty = specialty;
}
}
public class test {
public static void main(String[] args) {
// 每个系有很多个专业每个专业又有很多学生
// 定义一个信息系大集合
ArrayList<ArrayList<Student>> information = new ArrayList<ArrayList<Student>>();
// 创建计算机班集合
ArrayList<Student> computer = new ArrayList<Student>();
// 创建学生对象
Student c1 = new Student("李四", 21,"计科");
Student c2 = new Student("王五", 22,"计科");
Student c3 = new Student("赵六", 20,"计科");
// 添加学生对象
computer.add(c1);
computer.add(c2);
computer.add(c3);
// 添加到信息系大集合中
information.add(computer);
// 创建自动化班集合
ArrayList<Student> automation = new ArrayList<Student>();
Student a1 = new Student("刘一", 22,"自动化");
Student a2 = new Student("陈二", 24,"自动化");
Student a3 = new Student("张三", 20,"自动化");
automation.add(a1);
automation.add(a2);
automation.add(a3);
information.add(automation);
// 嵌套遍历
for (ArrayList<Student> arr : information) {
for (Student s : arr) {
System.out.println(s.getName() + "--" + s.getAge()+"--"+s.getSpecialty());
}
}
}
}
/**
李四--21--计科
王五--22--计科
赵六--20--计科
刘一--22--自动化
陈二--24--自动化
张三--20--自动化
*/
扫一扫
345
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
