黑马程序员_java基础加强_1

最新推荐文章于 2022-01-06 17:26:46 发布

c水滴石穿

最新推荐文章于 2022-01-06 17:26:46 发布

阅读量467

点赞数

本文链接：https://blog.csdn.net/sdsccyy/article/details/8786051

版权

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

java基础加强：

1，静态导入（jdk1.5的新特性）：
import语句可以导入一个类或者某个包中的所有类。
import static 语句导入一个类中的某个静态方法或所有静态方法

示例：

import static java.lang.Math.*;//导入Math类的所有方法。
public class StaticImport {
	public static void main(String[] args) {
		System.out.println(max(3,5));//可以直接使用类的方法
		System.out.println(min(0,7));
		
	}
}

2，可变参数特点（jdk1.5的新特性）：
①只能出现在参数列表的最后；
②...位于变量类型和变量名之间，前后有无空格都可以；
③调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

3，增强for循环（jdk1.5的新特性）：
语法：for（type 变量名　：集合(数组)变量名）

示例：

/*可变参数的使用*/
public class VarableParameter {
	public static void main(String[] args) {
		System.out.println(add(3,4,6));
		System.out.println(add(6,1,2,9));
	}
	
	public static int add(int x ,int... args){
		int sum = 0;
		/*for(int i = 0;i<args.length;i++){
			sum = sum+args[i];
		}*/
		
		//使用增强for循环的方式遍历可变参数
		for(int arg : args){
			sum = sum+arg;
		}
		return sum;
	}
}

4，基本数据类型的自动拆箱和装箱（jdk1.5的新特性）

享元模式：当某个对象应用的次数较多时，可以将其单独定义出来，提供使用，减少内存的使用量
示例：

public class AutoBox {
	public static void main(String[] args) {
		Integer iobj = 3;//自动装箱 等于 Integer iobj = new Integer(3);
		
		System.out.println(iobj + 12);//自动拆箱 ：将Integer对象iobj拆箱为基本类型int。
		
		Integer i1 = 23;
		Integer i2 = 23;
		System.out.println(i1==i2);//返回true，使用了享元模式
		/*
		 * 当创建一个Integer对象的时候，如果在-128~127之间的数字别创建以后，
		 * 会将其存在一个缓存里面，如果别的Integer对象也存在这缓存中，就会调用这个数字。
		 * 可以称为享元模式：
		 * */
	}

5，枚举（jdk1.5的新特性）：是指将变量的值一一列出来，变量的值只限于列举出来的值的范围内，相当于一个类，其中可以定义构造方法，成员变量，普通方法，和抽象方法。枚举元素必须位于枚举体中最开始部分，枚举元素列表的后面要有分号与其他成员分隔。

示例：

public class EnumTest {
	public static void main(String[] args) {

		System.out.println("===============================");
		WeekDay1  weekday2 = WeekDay1.FRI;
		//枚举类的常用方法
		System.out.println(weekday2);
		System.out.println(weekday2.name());//获取变量的name
		System.out.println(weekday2.ordinal());//获取当前变量在枚举中的排行
		System.out.println(WeekDay1.valueOf("SUN"));
		System.out.println(WeekDay1.values().length);
	
		
	}
	//定义一个枚举
	public enum WeekDay1{
		SUN(1),MON,TUE,WED,THI,FRI,SAT;//（1）:代表使用的是哪个构造方法，（）：代表默认的构造方法
		
		//定义一个构造方法.一定要定义在枚举元素的后面，构造方法必须是私有
		private WeekDay1(){
			System.out.println("first");
		}
		private WeekDay1(int day){
			System.out.println("second");
		}
	}
	
	//定义一个带抽象方法的枚举,
	public enum trafficLamp{
		RED(30){
			public trafficLamp nextLamp(){
				return GREEN;
			}
		},GREEN(45){
			public trafficLamp nextLamp(){
				return YELLOW;
			}
		},YELLOW(5){
			public trafficLamp nextLamp(){
				return RED;
			}
		};
		
		//实现抽象的nextLamp的方法：每个元素分别是由枚举类的子类来生产示例对象，这些子类采用类似内部类的方式进行定义。
		public abstract trafficLamp nextLamp();
		private int time;
		private trafficLamp(int time){
			this.time = time;
		}
	}
}

6，反射:就是把java类中的各种成分映射成相应的java类。
①Class：java程序中的各种java类属于同一类事物，描述这类事物的java类名就是Class。
获取Class对象的方法：
Class c1 = 类名.class;
Class c2 = 对象.getClass();
Class c3 = Class.forName("类名");
②java中有九个预定义的Class实例对象：boolean,byte,char,short,int,long,float,double,void

③Constructor类：代表某个类中的一个构造方法。
④Field：获取某个类的一个成员变量
⑤Method：获取某个类的一个成员方法
⑥数组的反射:具有相同维数和元素类型的数组属于同一个类型，既具有相同的Class实例对象；基本类型的一维数组可以被当做Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，即可以当作Object类型使用，又可以当作Object[]类型使用。

示例：

public class ReflectPoint {	
	private int x ;
	public int y;
	public String str1="ball";
	public String str2="basketball";
	public String str3= "itcast";
	ReflectPoint(int x,int y){
		this.x = x;
		this.y = y;
	}
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	public String toString(){
		return str1+":"+str2+":"+str3;
	}
	
}

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectTest {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		//获取Class对象的三种方式：
		String str1 = "abc";
		Class c1 = str1.getClass();
		Class c2 = String.class;
		Class c3 = Class.forName("java.lang.String");
		System.out.println(c1==c2);//true
		System.out.println(c1==c3);//true
		System.out.println(c1.isPrimitive());// false  是否是一个预定义类型的字节码对象。
		System.out.println(void.class.isPrimitive());//true;
		System.out.println(int.class == Integer.class);//false;
		System.out.println(int.class == Integer.TYPE);//true;
		
		System.out.println("-------------------------");
		//获取String类的构造某个方法
		Constructor cons = String.class.getConstructor(StringBuffer.class);
		// 通过获取的构造方法，创建一个String类型对象。
		String str= (String)cons.newInstance(new StringBuffer("abc"));
		System.out.println(str.charAt(2));
		System.out.println("------------------------------------");
		
		//成员变量的反射
		ReflectPoint pt1 = new ReflectPoint(3, 5);
		//filedy:代表一个类上的变量。不是某一个值。可以通过它获取某个对象的值
		Field fieldy = pt1.getClass().getField("y");
		System.out.println(fieldy.get(pt1));
		
		Field fieldx = pt1.getClass().getDeclaredField("x");
		fieldx.setAccessible(true);//x变量是私有的，需要设置其可以改变。
		System.out.println(fieldx.get(pt1));
		
		changeStringValue(pt1);
		System.out.println(pt1);
		
		
		System.out.println("==================================");
		//成员方法的反射
		Method methodCharAt = String.class.getMethod("charAt", int.class);
		System.out.println(methodCharAt.invoke(str1, 1));;
		
		//TestArguments.main(new String[]{"123","bca","234"});
		/*根据用户提供的类名，执行类中的main方法。*/
		//获取类名
		String startingClassName = args[0];
		//获取main方法
		Method mainMethod  = Class.forName(startingClassName).getMethod("main", String[].class);
		//调用main方法
		System.out.println(mainMethod.invoke(null,new Object[]{new String[]{"123","bca","234"}}));
		System.out.println("==================================");
		/*
		 * 数组的反射：具有相同类型并且相同维度的数组是同一个class（字节码对象）
		 * */
		int[] a1 = new int[]{2,4,6};
		int[] a2 = new int[3];
		int[][] a3 = new int[2][3];
		String[] a4 = new String[]{"ab","dji","dxy"};
		System.out.println(a1.getClass().getName());//[I
		System.out.println(a3.getClass().getName());//[[I
		System.out.println(a4.getClass().getName());//[Ljava.lang.String;
		System.out.println(a1.getClass()==a2.getClass());//true
		
		printObject(a1);
		printObject(a4);
	}
	//通过反射的方式打印数组类型的值
	private static void printObject(Object obj){
		Class clazz = obj.getClass();
		if(clazz.isArray()){
			int len = Array.getLength(obj);
			for(int i = 0;i<len;i++){
				System.out.println(Array.get(obj, i));
			}
		}else{
			System.out.println(obj);
		}
	}
	//通过反射修改String类型变量的值
	private static void changeStringValue(Object obj)throws Exception{
		Field[] fields = obj.getClass().getFields();
		for(Field field : fields){
			if(field.getType()==String.class){
				String oldValue = (String)field.get(obj);
				String newValue = oldValue.replace('b', 'a');
				field.set(obj, newValue);
				
			}
		}
	}
}
class TestArguments{
	public static void main(String[] args){
		for(String arg : args){
			System.out.println(arg);
		}
	}
}

7，hashCode方法的作用：通过采用哈希算法对对象进行存取，内部采用对某个数字n进行取余的方式对哈希码进行分组和划分对象的存储区域。Object类中定义了一个hashCode()方法来返回每个java对象的哈希码，当从HashSet集合中查找某个对象时，java系统首先调用对象的hashCode方法获取该对象的哈希码，然后根据哈希码找到相应的存储区域，最后取出该存储区域内的每个元素与该对象进行equals方法比较，这样就不用遍历集合中的所有元素就可以得到结果。当一个对象被存进hashSet集合中以后，就不要修改这个而对象中的那些参与运算的哈希值的字段了。否则，对象修改后的哈希值与最初存进HastSet集合中的哈希值就不同了。
8，内省（IntroSpector）：
javaBean：是一种特殊的java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。

示例：

import java.util.Date;

public class ReflectPoint {
	private Date birthday = new Date();
	private int x ;
	public int y;
	ReflectPoint(int x,int y){
		this.x = x;
		this.y = y;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	
}


import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;

public class IntroSpectorTest {
	public static void main(String[] args) throws Exception{
		ReflectPoint pt1 = new ReflectPoint(3, 5);
		
		String propertyName = "x";//获取x属性的值。
		//"x"-->"X"-->"getX"-->methodGetX
		//获取,设置javaBean的属性
		Object retVal = getProperty(pt1, propertyName);
		System.out.println(retVal);
		
		Object value = 88;
		setProperty(pt1, propertyName, value);
	
		//BeanUtils工具包的使用
		System.out.println(BeanUtils.getProperty(pt1, "x").getClass().getName());//返回的是String类型，将x的原始类型int转换为String。
		BeanUtils.setProperty(pt1, "x", "015");
		System.out.println(pt1.getX());
	
		BeanUtils.setProperty(pt1, "birthday.time","111");
		System.out.println(BeanUtils.getProperty(pt1,"birthday.time"));
		
		PropertyUtils.setProperty(pt1, "x", 6);
		System.out.println(PropertyUtils.getProperty(pt1, "x").getClass().getName());//Integer类型，返回的是x的原始类型
		
	}
	// 编写一个可以设置JavaBean属性的方法
	private static void setProperty(Object pt1, String propertyName,
			Object value) throws IntrospectionException,
			IllegalAccessException, InvocationTargetException {
		PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass());
		Method methodSetX = pd2.getWriteMethod();
		methodSetX.invoke(pt1, value);
	}
	//设置一个可以获取JavaBean属性的方法
	private static Object getProperty(Object pt1, String propertyName)
			throws IntrospectionException, IllegalAccessException,
			InvocationTargetException {
		/*
		 *简单的实现方式：
		PropertyDescriptor pd = new PropertyDescriptor(propertyName, pt1.getClass());
		Method methodGetX = pd.getReadMethod();
		Object retVal = methodGetX.invoke(pt1);*/
		
		//另外一种实现方式
		BeanInfo  beanInfo = Introspector.getBeanInfo(pt1.getClass());
		PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
		Object retVal = null;
		for(PropertyDescriptor  pd : pds){
			if(pd.getName().equals(propertyName)){
				Method methodGetX  = pd.getReadMethod();
				retVal = methodGetX.invoke(pt1);
				break;
			}
		}
		return retVal;
	}
}