黑马程序员_java基础加强_1

时间：2021-10-03 12:15:01

------- 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);//trueSystem.out.println(c1==c3);//trueSystem.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());//[ISystem.out.println(a3.getClass().getName());//[[ISystem.out.println(a4.getClass().getName());//[Ljava.lang.String;System.out.println(a1.getClass()==a2.getClass());//trueprintObject(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;
}
}



标签：

相关文章