黑马程序员 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