黑马程序员_高新技术

最新推荐文章于 2014-08-19 12:26:50 发布

原创最新推荐文章于 2014-08-19 12:26:50 发布 · 358 阅读

0 ·

CC 4.0 BY-SA版权

一、静态导入

概念：静态导入就是将类中或者包中的静态成员导入到程序中。以简化书写。

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

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

例如：

import static  java.lang.Math.max;//导入类中某个方法

import static java.lang.Math.*;//导入类中所有方法。

二、可变参数

概念：一个方法接受的参数个数不确定。
特点：

1、只能出现在参数列表的最后；（重点记住）

2、…位于变量类型和变量名之间，前后有无空格都可以；

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

三、增强for循环

语法：for(type 变量名：集合变量名或数组){…}

注意：
1、迭代变量必须在()中定义。

2、集合变量可以是数组或实现了Iterable接口的集合类。

例：

ArrayList<String> list=new ArrayList<String>();

for(String s :list){
System.out.println(s);
}

四、自动拆箱与装箱

概念：对于基本类型数据可以自动包装成基本类型数据对象，基本数据类型对象也可以自动拆包成基本类型数据。

自动装箱：Integer num=12;

自动拆箱：System.out.println(num+12);

注意：对于-128~127一个字节范围内的数据封装成Integer对象，两个该对象数值相等，对象也相等。

享元模式：有很多小的对象，它们属性相同，把它们变成一个对象，把不同的对象变成方法的参数，称之为外部状态，那些相同的属性称之为内部状态。

五、枚举

概念：枚举就是让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

注意：

1、枚举的构造函数必须放在所有对象实例的后面。并且如果实例后面还有代码，最后一个实例后面必须加上分号。

2、当枚举中包含抽象方法时，必须在每个实例中通过匿名内部类来重写抽象方法。

练习：

package myreview;

public class enumdemo{
	public static void main(String[] args) {
		
		System.out.println(weekday1.Sun.nextday());
		System.out.println(weekday1.Mon.nextday());
		System.out.println(weekday1.Sat.nextday());
	}
	
	public enum weekday1 {
		Sun{

			public weekday1 nextday() {
				return Mon;
			}
	},
	Mon{
		public weekday1 nextday() {
			return Tue;
		} 
	},
	Tue{

		public weekday1 nextday() {
			return Wed;
		}  
	},
	Wed{

		public weekday1 nextday() {
			return Thus;
		}
	 

	}, 
	Thus{
		public weekday1 nextday() {
			return Fri;
		}
	},
	Fri{
		public weekday1 nextday() {
			return Sat;
		}


	},
	Sat{

		public weekday1 nextday() {
			return Sun;
		}
	 
	    
	};
	public abstract weekday1 nextday();
	}

}

六、反射

反射技术： JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
简单一句话：反射技术可以对类进行解剖。

获取Class对象的三种方式

方式一：
通过对象的getClass方法进行获取。
麻烦在于每次是不是都需要具体的类和该类的对象，以及调用getClass方法。
方式二：
任何数据类型都具备着一个静态的属性class，这个属性直接获取到该类型的对应Class对象。这种方法比第一种简单，不用创建对象，不用调用getClass方法。
但是还是要使用具体的类，和该类中的一个静态属性class完成。
方式三：
通过给定的字符串名称就可以获取该类，这种方式较为简单，只要知道的类的名称即可。不需要使用该类，也不需要去调用具体的属性和行为。就可以获取到Class 对象了。
这种仅知道类名就可以获取该类字节码对象的方式，

	//方式3
	public static void getObject_3() throws ClassNotFoundException {
		String className = "day29.people";
		Class clazz = Class.forName(className);
		
		System.out.println(clazz);
		
	}
	//方式二：
	public static void getObject_2() {
		
		Class clazz = people.class;
		
		
	}

	//方式一。
	public static void getObject_1(){
		
		people p = new people();
		Class clazz = p.getClass();		
		people p1 = new people();
		Class clazz1 = p1.getClass();
		System.out.println(p==p1);
		System.out.println(clazz==clazz1);
	}

}

package day29;

public class people {
	String name;
	int age;
	public people(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public people() {
		super();
		// TODO Auto-generated constructor stub
	}
	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;
	}
	
}

通过Class创建对象:

		String className = "day29.people";
		Class clazz = Class.forName(className);
		Object  obj = clazz.newInstance();

获取字段

className = "day29.people";		
		Class clazz = Class.forName(className);
		
		//获取该类中的名称为age的字段
		
//		Field ageField = clazz.getField("age");//只能获取公有和父类中.
		Field ageField = clazz.getDeclaredField("age");

获取方法：

Method[] methods = clazz.getMethods();//只获取公共的和父类中的。
		methods = clazz.getDeclaredMethods();//获取本类中包含私有。
		
		for(Method method : methods){
			System.out.println(method);
		}

练习：

package day29;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class reflect {

	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
		// TODO Auto-generated method stub
		Class clazz=Class.forName("day29.people");
		Constructor con=clazz.getConstructor(String.class,int.class);
		System.out.println(con);
//		people peo=(people) con.newInstance("Bryan",21);
//		System.out.println(peo.getAge()+peo.getName());
		Object obj=clazz.newInstance();
		Field agef=clazz.getDeclaredField("age");
		agef.set(obj, 20);
		Object o=agef.get(obj);
		System.out.println(o);
	}

}

七、泛型

当一个类要操作的引用数据类型不确定的时候，可以将该类型定义一个形参。用到的这类时，由使用者来通过传递类型参数的形式，来确定要操作的具体的对象类型。

JDK1.5出现的，是一个安全机制。用于编译时期。

泛型的好处：

1、将运行时期的ClasscastException异常转移到了编译时期进行检查，并以编译失败来体现。这样有利于尽早解决问题。

2、有了泛型类，省去了曾经的强转和类型转换异常的麻烦。

泛型什么时候用：
先简单理解：只要在使用类或者接口时，该类或者接口在api文当描述时都带着<>就需要在使用时，定义泛型。

其实，泛型无非就是通过<>定义了一个形式参数。专门用于接收具体的引用类型。在使用时，一定要传递对应的实际参数类型。
集合中泛型的应用特别多见。
泛型的擦除：
泛型技术是用于编译时期的技术，编译器会按照<>中的指定类型对元素进行检查，
检查不匹配，就编译失败，匹配，就编译通过，通过后，生产的class文件中是没有泛型的。这就成为泛型的擦除。
泛型的补偿：
运行时，可以根据具体的元素对象获取其具体的类型。并用该类型对元素进行自动转换。

注：静态方法不能访问类上定义的泛型，如果需要泛型，该泛型只能定义在方法上。

package myreview1;

import java.util.ArrayList;

public class test1 {

	public static void main(String[] args) {
		/*
		 * 泛型
		 */

		
		ArrayList<String> arr =new ArrayList<String>(); 
		arr.add("xiaoming1");
		arr.add("xiaoming2");
		arr.add("xiaoming3");
		for(String s:arr){
		System.out.println(s.length());
	}
	}

}

泛型的通配符：?
当操作的不同容器中的类型都不确定的时候，而且使用的都是元素从Object类中继承的方法。这时泛型就用通配符?来表示即可。

泛型的限定：

< ? extends 类名>：上限；

<? super 类名>：下限；

上限的使用：一般情况下，只要是往容器中添加元素时，使用上限。
下限的使用：一般清况下，只要是从容器中取出元素时，是用下限。