黑马程序员 java1.5版本新特性

----------- android培训、java培训、期待与您交流！ ------------

1、静态导入

import static语句 ：导入一个类的静态方法

import static java.lang.Math.*;
public class Demo {
public static void main(String[] args) {
System.out.println(max(3, 7));
}
}

2、可变参数

何时使用可变参数？

当一个方法接收的参数个数不固定时。

可变参数特点：

①只能出现在参数列表的最后；

②“...”放在参数类型和参数名之间，前后有无空格都可以；

③调用含有可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式可以访问可变参数。

import java.util.Arrays;

class Demo {

public static void main(String[] args) {

add(3, 4, 7, 9, 2, 1);

}

public static void add(int i, int...args) {

System.out.println("可变参数为：" + Arrays.toString(args));

int sum = i;

for(int arg : args) {//增强for

sum += arg;

}

System.out.println("Sum: " + sum);

}

}

3、增强for语句（foreach）

语法：for(Type 迭代变量名 ： 集合变量名)

特点：①迭代变量（如上例代码的arg）必须定义在()中 ②集合变量可以是数组或实现了Iterable的集合类。

4、基本数据的自动装箱与拆箱

public class AutoBox {
public static void main(String[] args) {
Integer iObj = 3;	//自动装箱
Character cObj = 'H';
System.out.println(iObj + 2);	//自动拆箱
System.out.println(cObj + 2);	//自动拆箱

Integer i1 = 154;
Integer i2 = 154;

Integer i3 = 127;
Integer i4 = 127;
System.out.println(i1==i2);	//false
System.out.println(i3==i4); //true
}
}

//总结：1.5之后，不用new基本数据类型的对象，直接赋值给基本数据类型引用
//-128~127之间的数，被放到一个池子里，可以共享

将大量重复使用的元素，进行共享的模式，称为“享元模式”。 元素中不同的部分，将作为方法的参数，进行操作

比如文件和文件夹的图标就是享元模式设计。

5、枚举★★

枚举特点：1、让某个类型的变量只能取固定的几个值，否则编译器将报错。2、只要用到了枚举类，它里面的静态变量都将被初始化。

/*
* 枚举类型用enum修饰，和class、interface类似
* 对于特定的enum类型默认属于Enum的子类，拥有Enum类的所有方法
* 并且有两个隐含的静态方法public static T valueOf(String)和public static T[] values()
*
* */

class EnumDemo {
public static void main(String[] args) {
WeekDay mon = WeekDay.MON;
//打印枚举值的名称
System.out.println(mon.name());

//将字符串转换为枚举类型
System.out.println(WeekDay.valueOf("SUN"));

//获取所有WeekDay类型实例
WeekDay[] wds = WeekDay.values();
int count = 0;
for(WeekDay wd : wds) {
System.out.println("WeedDay：" + wd + "......" + ++count);
}
}

enum WeekDay {//内部类的形式定义枚举类型
MON(), TUE, WED, THU, FRI, SAT, SUN
}
}

MON(这里的参数表明使用了哪个构造方法)，没有参数使用的是默认的空参数构造方法。

public enum TrafficLamp {	//交通灯枚举
RED(30) {
public TrafficLamp nextLamp() {
return GREEN;
}
},
GREEN(40) {
public TrafficLamp nextLamp() {
return YELLOW;
}
},
YELLOW(5) {
public TrafficLamp nextLamp() {
return RED;
}
};
private int time;

private TrafficLamp(int time) {//枚举类的构造方法
this.time = time;
}

public abstract TrafficLamp nextLamp();//也可以用if...else判断写方法
}

6、泛型★★★

泛型限定了集合中存放数据的类型。
1、免去了在取出元素后的强制转换过程
2、将运行时期错误转移到了编译时期
泛型在javac编译器编译时检查限定的类型，集合元素存储完毕后，会去掉“类型信息”，这可以通过反射来证明。
由于编译完的字节码里已经没有了限定，所以可以用反射的方式向其中加入任意元素。
所以泛型只对编译器有用。

泛型类。

何时定义泛型类？

当类中要操作的引用数据类型不确定时，早期定义Object来完成扩展，现在定义泛型完成扩展

可以避免操作过程中的强转。

public class GenericClass {

public static void main(String[] args) {
/*Tools t = new Tools();
t.setObject(new Worker());
Worker w = (Worker)t.getObject();	//强制转型*/

Utils<Worker> u = new Utils<Worker>();
u.setObject(new Worker());
Worker w = u.getObject();	//不用强转
System.out.println(w);
}
}

class Worker {
public String toString() {
return "I'm a Worker";
}
}
class Teacher {}

class Tools {	//早期类
private Object obj;
public void setObject(Object obj) {
this.obj = obj;
}
public Object getObject() {
return obj;
}
}
class Utils <YY>{	//泛型类
private YY y;
public void setObject(YY y) {
this.y = y;
}
public YY getObject() {
return y;
}
}

泛型方法：

/*
* 泛型类定义的泛型，在整个类中有效。
如果被方法使用，当要操作的对象类型确定后，传给该方法的实参必须是该对象类型。
*
* 为了让不同的方法操作不同的类型，并且要操作的类型还不确定，可以将泛型定义在方法上。
*
泛型方法和泛型类可以同在一个类中。并且互不影响。

* 定义泛型格式：<>放在方法返回值类型前面，方法修饰符的后面
（ 如public static <T> void method() ）。
*
* ★★静态方法不能访问在类上定义的泛型。
因为类型在创建了对象后才确定，而静态方法在对象创建前已经加载。
如果静态方法操作的数据类型不确定，可以将泛型定义在静态方法上。
*
*/
public class GenericDemo {

public static void main(String[] args) {
Test<String> t = new Test<String>();
t.show(9);		//报错：无法将类 Test<T>中的方法 show 应用到给定类型;
t.print(9);		//9
}

}

class Test<T> {
public  void  show (T t) {//和类泛型一致
System.out.println(t);
}
public <Q> void print(Q q) {//可以操作任意类型
System.out.println(q);
}
}

泛型接口和泛型类类似，在开发中，一般是别人定义好了，直接拿来用。

泛型限定：

/*
* ？泛型通配符，也可以理解为占位符
*
* 泛型限定：用于泛型扩展用的。
* 		<? extends E>	可以接收E类型或E的子类型，上限
* 		<? super E>		可以接收 E类型或E的父类型，下限
*
* */
import java.util.*;
public class GenericLimited {

public static void main(String[] args) {
TreeSet<Student1> ts = new TreeSet<Student1>(new Comp());
ts.add(new Student1("sabc1"));
ts.add(new Student1("sabc2"));
ts.add(new Student1("sabc3"));
ts.add(new Student1("sabc4"));

for(Iterator<Student1> it = ts.iterator(); it.hasNext();) {
System.out.println(it.next().getName());
}

TreeSet<Worker1> ts1 = new TreeSet<Worker1>(new Comp());
ts1.add(new Worker1("wab---c1"));
ts1.add(new Worker1("wab---c2"));
ts1.add(new Worker1("wab---c3"));
ts1.add(new Worker1("wab---c4"));

for(Iterator<Worker1> it = ts1.iterator(); it.hasNext();) {
System.out.println(it.next().getName());
}
}

}

class Person {
private String name;

public Person(String name) {
this.name = name;
}

public String getName() {
return name;
}
}

class Student1 extends Person {
public Student1(String name) {
super(name);
}
}
class Worker1 extends Person {
public Worker1(String name) {
super(name);
}
}

class Comp implements Comparator<Person> {	//定义<? super E>,限定父类型，比较多个子类型
public int compare(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName());
}
}

ArrayList<String> al[] = new ArrayList<String>[4];报错： 数组类型集合不能加泛型。
Vector v1 = new Vector<String>();//编译器不报错
Vector<Object> v2 = v1;//编译器不报错（这里V1编译器会当成Vector）
<>参数类型可以通过反射得到。反射方法中的泛型参数xxxMethod.getGenericParameterTypes();再通过其得到其实际传入类型参数pType.getActualTypeArguments()[0];

7、注解★★★★★

Annotation

向编译器或工具软件传递某种信息。

加一个注解相当于一个注解实例对象。

注解可以加在包、类、字段、方法、方法的参数和局部变量上。

java.lang包中有最基本的Annotation。

@SuppressWarnings表明消除编译器的某些警告；其注解生命周期是RetentionPolicy.SOURCE

@Deprecated表明过时的代码；其注解生命周期是RetentionPolicy.RUNTIME

@Override表明该方法覆盖父类的方法；其注解生命周期是RetentionPolicy.SOURCE



给注解增加属性

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import cn.itcast.practice.heiMa.TrafficLampEnum;

/*
*注解生命周期：
*RetentionPolicy.SOURCE	对应java源文件
*RetentionPolicy.CLASS		对应class文件（默认值）
*RetentionPolicy.RUNTIME	对应内存中的字节码
*
*
*/

/*
* 	@interface MetaAnnotation {
String value();
}

这个注解以包权限放这里就会出现后的输出错误，留个记号@。
将其放在单独文件中以public权限出现即可。
* */

@Target({ElementType.METHOD,ElementType.TYPE})//作用范围
@Retention(RetentionPolicy.RUNTIME)//注解生命周期：
public @interface AnnotationMelon {
//注解的属性
String color() default "blue" ;
String value();
int[] arrayAttr() default {1, 3, 4};
TrafficLampEnum.TrafficLamp lamp() default TrafficLampEnum.TrafficLamp.RED;
MetaAnnotation annotationAttr() default @MetaAnnotation("xyz");
}

@AnnotationMelon(annotationAttr = @MetaAnnotation("wyl"), color = "red", value = "str", arrayAttr = 2)//arrayAttr数组中只有一个元素，可以省略{}
class Demo {
@AnnotationMelon("abc")//就一个value属性
public static void main(String[] args) {
//是否存在某种类型的注解
boolean b1 = Demo.class.isAnnotationPresent(AnnotationMelon.class);
System.out.println(b1);
//判断是否为注解类型
boolean b2 = AnnotationMelon.class.isAnnotation();
System.out.println(b2);

if(Demo.class.isAnnotationPresent(AnnotationMelon.class)) {
//获取Demo"身上"的注解
AnnotationMelon anm = Demo.class.getAnnotation(AnnotationMelon.class);
System.out.println(anm);
System.out.println(anm.color());
System.out.println(anm.value());
System.out.println(anm.arrayAttr().length);
System.out.println(anm.lamp().nextLamp());
System.out.println(anm.annotationAttr().value());//打印注解类型属性的值 @
}

}
}

8、StringBuilder也是1.5出的。

9、Lock锁机制

在多线程中有讲解。

10、更新的线程创建机制。Executors.new ****;

----------------------- android培训、java培训、期待与您交流！ ----------------------
详情请查看：http://edu.csdn.net/heima