黑马程序员--JAVA高新技术

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

 

JAVA增强

一，JDK1.5 新特性

1,静态导入：

import 语句可以导入一个类或某个包中的所有类

import static 语句导入一个类中的某个静态方法或所有静态方法

如：

import static java.lang.Math.*;
public class StaticImport{
     public static void main(String[] args){ 
	System.out.println(max(0,1));
	//System.out.println(Math.max(0,1));
     }
}

2,可变参数

    可变参数特点：

    只能出现在参数列表的最后,位于变量类型和变量名之间，前后有无空格都是可以的。

    调用可变参数的方法时，编译器为该可变参数隐含创建了一个数组，

    在方法体中以数组的形式访问可变参数。

    如：

public class VariableParament{
	public static void main (String[] args){
		System.out.println(getAdd(2,3,4));
	}
	public  static int getAdd(int x,int ... arrs){
  		int sum=x;
 		for(int i=0;i<arrs.length;i++){
    			sum=sum+i;
  		}
  		return sum;
	}
}

3,高级for循环 

语法：

for(type 变量名：集合变量名){ ... }

如：

public  static int getAdd(int x,int ... arrs){
	int sum=x;
  	for(int arg : arrs){
    		sum=sum+arg;
  	}
  	return sum;
}

4,自动装箱拆箱

      自动装箱：Integer num1 = 2;

      自动拆箱：int mum2 = num1+3;

      注意：

        Integer i1 = 5; Integer i2 =5; i2==ii 此处为true

Integer i3 = 128; Integer i4 =128;  i4==i5 此处为false

这也是一种模式，叫享元模式，即flyweight pattern;

也就是说在内存中有很多小的对象，当这些小的对象有相同的属性时，可以将这些小的对象变成 同一个对象，把这些相同的属性作为这个对象的内部属性。而把那些不同的属性作为这个对       象的 方法的参数，称为这个对象的外部状态。

  5，枚举 enum

      枚举就是让某个类型的变量的取值只能为若干个值中的一个，否则，编译器就会报错。

      枚举可以让编译器在编译时就可以控制源程序中的非法值。

      如：

public class EnumTest{
	public static void main(String[] args){
		WeekDay week = WeekDay.MON;
		System.out.println(week);
		System.out.println(week.name);
		System.out.println(week.ordinal);
		System.out.println(WeekDay.valueOf("SUN"));
		System.out.println(weekDay.values().length);
 
	}
 	public enum WeekDay{
           	SUN,MON,TUE,WEN,THU,FRI,SAT
       	}
}

枚举的构造方法必须存在于元素列表之后，而且必须是私有的。

      交通灯案例：

 

public class Traffic{
 	public static void main (String[] args){
		TrafficLamp tl = TrafficLamp.RED;
		System.out.println(tl.nextLamp());
 	}
 	public enum TrafficLamp{
     		RED(30){
			public TrafficLamp nextLamp(){
				return GREEN;
			}
     
   		},
     		GREEN(45){
			public TrafficLamp nextLamp(){
				return YELLOW;
			}
     		},
     		YELLOW(5){
			public TrafficLamp nextLamp(){
				return RED;
			}
     
     		};
     		public abstract TrafficLamp nextLamp();
     		private int time;
     		private TrafficLamp(int time){
			this.time=time;
  		}
 	}
}

6，注解。Annotation

      7，泛型。Generic

二，反射：是从jdk1.2开始的。并不是jdk1.5新特性。

    Java程序中的各个 java类属于同一类事物，描述这一类事物java类名就是Class

    得到字节码三种方式：

第一种，

    Person p1 = new Person();

    Class cls = p1.getClass();

第二种，

    Class cls = Date.class;

第三种，

    Class.forName("java.lang.String");//必须要写完整类名。

注意：Class.forName()作用。

    Class.forName()的作用是获取字节码文件，但是分为两种情况，第一种，是这个字节码曾将被调用过，缓存在java 虚拟机中，则直接返回字节码。第二种，是java虚拟机中还没有字节码，则可以通过 类加载器加载字节码文件，返回 字节码文件

九个预定义Class实例对象：(八种基本数据类型+布尔类型)

Int.class == Integer.TYPE

数组类型的Class实例对象

Class.isArray();

总之，只要在源程序中出现的类型，都有各自的Class实例对象，例如int[] void

反射：就是将java中的每一个成分映射成相应地类。

    Constructor类代表某个类中的一个构造方法

    1，得到某个类所有的构造方法：

Construtcor[] constructors = Class.forName("java.lang.String").getConstructors()

   

    2，得到某一个带参数构造方法：

Constructor constructor =Class.forName("java.lang.String").getConstrucor(StringBuffer.class);    

//这里指定了是StringBuffer参数。

String str = (String)constructor.new Instance(new StringBuffer("abc"));

//这里指定了是StringBuffer对象。

上面两行代码等效于 String str = new String(new StringBuffer("abc"));

当需要得到某一个不带参数的构造方法时，可以直接用Class类中的newInstance()方法。

   

    3，得到某个类中的成员变量：

ReflectPoint pt1 = new ReflectPoint(3,5);//这里参数x是私有的，而y是公有的。

Field FieldY = pt1.getClass.getField("y");

//FieldY的值是多少呢？是5，错。FieldY不是对象身上的变量，

//而是类上要用它去取某个对象上的值。

如：System.out.println(FieldY.get(pt1));//这里指的是5；

另外如果需要获取私有成员变量。需要这样做：

Field FieldX = pt1.getClass.getDeclareField("x");

FieldX.setAccessible(true);

System.out.println(FieldX.get(pt1));

     

   

    4，得到某一个类的成员方法：

String str ="abc";

Method methodCharAt = String.class.getMethod("charAt",int.class);

char a = methodCharAt.invoke(str,2);

//在jdk1.4中，可以写作 char a = methodCharAt.invoke(str,new Object(){2});

//还用到自动装箱

上面两行代码等效于 char b = str.charAt(2);

注意：如果传递给Method对象的invoke()方法中的第一个参数为null。说明该Method对象对应的应该是一个静态方法。

      5，得到数组的反射

当两个数组的维数与元素类型相同的时候，这两个数组的字节码相同。

      如：

int[] a1 =new int[3];

int[] a2 =new int[4];

a1.getClass()==a2.getClass() 其值为true。a1.getClass.getName="[I"。

    数组反射的应用：

public class StringEg {
	public static void main(String[] args) {
		String[] str = new String[]{"abc","abd","dfd"};
		PrintObj(str);
		PrintObj("hello world");
	}


	private static void PrintObj(Object obj) {
		if (obj.getClass().isArray()){
			for(int i=0;i<str.length;i++){System.out.println(Array.get(obj, i));}
		}
		else {
			System.out.println(obj);
		}
	}
}

注意：

Arrays这个工具类中有一个asList(Object[])方法，所以可以使用Arrays.asList直接打印一个数组中的内容，但是注意不能打印 int[] 内容，因为int 并不是Object，而可以直接String[]       因为String 属于Object。

三，HashSet与ArrayList的比较，以及hashcode的分析

  1，ArrayList中可以存入相同的对象。而HashSet中不可以存入相同的对象。

  2，HashSet集合中，当元素存入的时候，是先比较两个对象的hashcode值，如果hashcode值相同，再用equals比较，如果 相同，则不存入，否则，存入。

  3，有人发明了哈希算法来提高哈希表中元素查找的效率，这种方式是将集合分成若干个区域，每个对  象都可以算出一个hash值， 可以将hash值分组，每组对应不同的区域。这样根据一个对象的hash值就 可以快速确定这个对象在哪个区域。

  注意：

当一个对象呗存储进HashSet集合以后，就不能修改这个对象中那些参与计算hash值的字段了，因为，这样对象修改后的hash值与 最初存储进HashSet集合中的哈希值就不同了。这种情况下，会导   致无法从HashSet集合中独立删除当前对象，从而造成内存泄露。

四，反射的作用：实现框架的功能。

  框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

   

  用类加载器的方式管理资源文件盒配置文件有三种方式，

  1，InputStream ips = new FileInputStream("config.properties");

//这里的配置文件应该放在project目录下。

  2，InputStream ips = ReflectPoint.class.getClassLoader().getResourseAsStream("cn.itcast.day1.config.properties"); //这里应该填写 classpath目录。即存放类的位置。

  3，InputStream ips = ReflectPoint.class.getRouseAsStream("config.properties");

//这里可以填写相对路径，也可以填写绝对路径。

四，JavaBean

  IntroSpector:内省，主要用于操作JavaBean，JDK提供了对JavaBean进行操作的API,这套api就称为内省。

  JavaBean:是一个特殊的java类，类中的方法名符合某种特点的规则，方法名是以get和set开,javabean 中的属性时根据get和set方法的名称推断 出来的。如果第二个字母是小写的，则把第一个字 母变为小写。如gettime-->time setTime-->time CPU-->CPU

 

  这是一个简单的javabean；

Class Person{
	private int x;
	public int getAge(){
		return x;
	}
	public void setAge(int age){
		this.x=age;
	}
}

应用:在一个类中读取另外一个JavaBean中的属性值。

      第一种方式：

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.jar.Attributes.Name;


//获取Point类中的属性值，并设置。
public class PointTest {
	private static Map age;
	public static void main(String[] args) throws Exception{
		Point pt = new Point(3, 5);
		String propertyName="x";
		//获取x值。
		BeanInfo beanInfo = Introspector.getBeanInfo(pt.getClass());
		PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
		for(PropertyDescriptor pd : pds){
			if (pd.getName().equals(propertyName)) {
				Method getMethod = pd.getReadMethod();
				System.out.println(getMethod.invoke(pt));
				break;
			}
		}
		//设置x值。
	}


}

第二种方式：

使用BeanUtils这个工具类来进行get和set属性。

BeanUtils.getProperty(pt,"x");

//注意这里操作的是字符串“x”。

BeanUtils.setProperty(pt,"x","8");

另外一种是使用PropertyUtils.getProperty(pt,x)//注意这里是x,并不是字符串。

BeanUtils不仅可以操作JavaBean，而且可以操作map集合。

 

  JDK1.7其中一个新特性：

  Map map = {name:"zx",age:21};

五，注解,Annotation

  一个注解就是一个类，相当于一个标记。

  @SupressWarnings("deprecation") //不提示过时，在命令行可以，但是在eclipse中不起作用。

  @Deprecated  //表示过时了。

  @Override //表示重写，可以判断是否重写。

  自定义注解类。

  注解的应用结构图。

如：

  注解类：

import java.lang.annotation.*；

@Retention(RetentionPolicy.RUNTIME)

// 编译器将把注释记录在类文件中，在运行时 VM 将保留注释

@Target(ElementType.METHOD)

//指定注解类存放位置，存放咋i类中，方法上等等。

public @interface MyAnnotation

{

}

  应用注解类的类：

import java.lang.annotation.Annotation;
public class AnnotationTest {
	public static void main(String[] args) {
		if (AnnotationTest.class.isAnnotationPresent(MyAnnotation.class)) {
			Annotation annotation = AnnotationTest.class.getAnnotation(MyAnnotation.class);
			System.out.println(annotation);
		}
	}
}

为注解增加属性及高级属性：

public @interface MetoAnnotation{
	String value();
}
public @interface MyAnnotation{
	String color() default "blue"; //设置缺省属性，即默认属性。
	String value();
	int[] arrAttr();
	EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;//枚举类型的属性
	MetoAnnotation annotationAttr() default @MetoAnnotation("lhm");
}


@MyAnnotation(value=“xyz”,arrAttr={1,2,3},annotationAttr=@MetoAnnotation("zxx
//注意：如果只有value属性，则可以不用写“value=”，当数组只有一个元素时，可以不用{}，即 //arrAttr=1;
public class AnnotationTest{
}

六，泛型。

  泛型是提供给javac编译器使用的，可以限定集合中的输入类型。当编译过之后，java虚拟机会去 掉“类型”信息。

  所以可以通过反射跳过编译器，这样就不会出现泛型限定情况了。

  泛型常见术语：

ArrayList称为泛型类型

ArrayList中的E称为类型变量或类型参数

ArrayList称为参数化的类型

ArrayList中的Integer称为类型参数的实例或实际类型参数

ArrayList中的<>念type of

ArrayList称为原始类型

  参数化类型与原始类型的兼容性：

参数化类型可以引用一个原始类型的对象，编译报告警告。如：

Collection c = new Vector();

原始类型可以引用一个参数化类型的对象，编译报告警告。如：

Collection c = new Vector();

  参数化类型不考虑类型参数的继承关系：

Vector v = new Vector(); //错误

Vectorv = new Vector(); //也错误

  在创建数组实例是，数组的元素不能使用参数化的类型，如：

Vector vector[] = new Vector[10];//错误

  注意：

Vector v1 = new Vector();//原始类型可以引用参数化类型

Vectorv = v1;//参数化类型也可以引用原始类型。

泛型中的？通配符

    使用？通配符可以引用其他各种参数化的类型，？通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与 参数化有关的方法。

    可对通配符变量赋任意值：  如： Collection

 

 

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

                              详情请查看：www.itheima.com