java高新技术day-1

压缩文件1-27
1. 可变参数的方法。
package cn.itcast.day1;

public class VarableParameter {

public static void main(String[] args) {
System.out.println(add(2, 3));
System.out.println(add(2, 3,5));

}
public static int add(int x,int...args)
{
int sum=x;
for (int i = 0; i < args.length; i++) {
sum+=args[i];
}
return sum;
}

}
2. for循环增强
package cn.itcast.day1;

public class VarableParameter {

public static void main(String[] args) {
System.out.println(add(2, 3));
System.out.println(add(2, 3,5));

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

}
3. 基本数据的自动拆装箱
package cn.itcast.day1;

public class AutooBox {

public static void main(String[] args) {
Integer iObj=3;//自动装箱
System.out.println(iObj+12);//自动拆箱
Integer x1=130;
Integer x2=130;
System.out.println(x1==x2);
}

}
享元模式：有很多小的对象有很多相同的东西，把他们变成一个对象，把他们的差别变成外部的属性作为方法的参数传入，传入的参数称为外部状态，相同的属性称为内部状态。
4. 枚举原理分析。
增加编程时数据的有效性。
package cn.itcast.day1;

public abstract class WeekDay {
private WeekDay(){}
public final static WeekDay SUN=new WeekDay()
{

@Override
public WeekDay nextDay() {
return MON;
}

};
public final static WeekDay MON=new WeekDay()
{

@Override
public WeekDay nextDay() {
return SUN;
}

};

public abstract WeekDay nextDay();
public String toString()
{
return this==SUN? "SUN":"MON";
}
}
把用多个if、else实现的方法变成多个内部类。
5. 枚举实例
package cn.itcast.day1;

public class EnumTest {

/**
* @param args
*/
public static void main(String[] args) {
WeekDay weekDay2=WeekDay.FRI;//给对象赋一个枚举值
System.out.println(weekDay2);//打印该对象，调用toString方法
System.out.println(weekDay2.name());//打印该枚举元素名
System.out.println(weekDay2.ordinal());//打印该枚举元素在枚举类内的位置
System.out.println(WeekDay.valueOf("SUN").toString());//把字符串转换成枚举类型，并输出
System.out.println(WeekDay.values().length);//返回枚举类的所有元素的数组，并输出数组的长度
}
public enum WeekDay //定义一个枚举类型
{
SUN,MON,TUE,WED,THI,FRI,SAT
}

}
6. 为枚举定义构造方法
public enum WeekDay //定义一个枚举类型
{
SUN,MON(1),TUE,WED,THI,FRI,SAT;
private WeekDay()
{
System.out.println("first");
}
private WeekDay(int day)
{
System.out.println("second");
}
}
说明：在枚举对象的后边括号里添加数值的话会调用有参的构造方法。
7. 用枚举类型实现交通灯转换功能。
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;
}

}
8. 反射的学习
基本数据类型有：boolean,bye,char,int,short,long,float,double,void
总之，只要在源程序中出现的类型，都有各自的Class实例对象与之对应
调用类：
package cn.itcast.day1;

public class ReflectPoit {
private int x;
public int y;
public String str1="ball";
public String str2="basketball";
public String str3="itcast";
public ReflectPoit(int x, int y) {
super();
this.x = x;
this.y = y;
}
public String toString()
{
return this.str1+":"+this.str2+":"+this.str3;
}

}

上机练习代码与注释分析，类ReflectTest：
package cn.itcast.day1;

import java.util.*;
import java.lang.*;
import java.lang.reflect.*;

public class ReflectTest {

private static final String String = null;
public static void main(String[] args) throws Exception {
String str1="abc"; //定义字符串abc
Class cla1=str1.getClass();//用对象获得实例化该对象的类得字节码
Class cla2=String.class; //由类获得字节码
Class cla3=Class.forName("java.lang.String");//由类名获得字节码
System.out.println(cla1==cla2);//验证这三种方法取得的字节码是否相同
System.out.println(cla2==cla3);

System.out.println(cla1.isPrimitive()); //判断该字节码是不是基本数据类型
System.out.println(void.class.isPrimitive());//判断void的字节码是不是基本数据类型
System.out.println(int.class==Integer.class);//判断int的字节码是不是基本数据类型
System.out.println(int.class==Integer.TYPE);//基本数据类型的包装类的TYPE属性获得相应的基本数据类型
System.out.println(int[].class.isPrimitive());//获得数组的类型
System.out.println(int[].class.isArray());

Constructor constructor=String.class.getConstructor(StringBuffer.class);//获得一个类的构造方法，根据参数的不同调用相应的构造方法
String str2=(String)constructor.newInstance(new StringBuffer("abc"));//用通用的构造方法进行转型
System.out.println(str2.charAt(2));//获得字符串的第二个字符

ReflectPoit po1=new ReflectPoit(3,5);//定义一个点的对象
Field fildY=po1.getClass().getField("y");//获得相应类的字段y
System.out.println(fildY.get(po1));//获得对象poi的字段y值

Field fildX=po1.getClass().getDeclaredField("x");//获得类内声明的变量
fildX.setAccessible(true);//定义该字段的取得是有效的
System.out.println(fildX.get(po1));//获得某对象的该字段值

changeStringValue(po1);//调用更改字符串方法
System.out.println(po1);//打印该方法的toString方法

Method methodCharAt=String.class.getMethod("charAt", int.class);//获得String类的charAt方法
System.out.println(methodCharAt.invoke(str1, 1));//执行该通用方法
System.out.println(methodCharAt.invoke(str1, new Object[]{2}));//用1.4调用该方法

TestArguments.main(new String[]{"111","222","33"});//直接调用类的main方法

String startingClassName=args[0];//获得主类的第一个参数，设置第一个参数为要调用类的地址
Method mainMethod=Class.forName(startingClassName).getMethod("main",String[].class);//获得调用类的主方法
mainMethod.invoke(null,new Object[]{new String[]{"111","222","33"}});//为通用的方法赋值，如果是静态方法，则第一个参数为null，把要传入的数组打成一个包

int []a1=new int[]{1,2,3};//定义一个人一维数组
int []a2=new int[4]; //定义一个一维数组
int [][]a3=new int[3][4]; //定义一个二维数组
String []a4=new String[]{"a","b","c"};//定义一个字符串数组
System.out.println(a1.getClass()==a2.getClass());//比较一维整形数组的类字节码
System.out.println(a1.getClass()==a3.getClass());//比较一维数组和二维数组的类字节码
System.out.println(a1.getClass()==a4.getClass());//比较一维数组和字符串数组的类字节码

System.out.println(a1.getClass().getSuperclass().getName());//获得a1字节码父类名
System.out.println(a3.getClass().getSuperclass().getName());//获得a3字节码父类名

Object aObject1=a1;//把数组赋值给一个Object对象
Object aObject2=a4;
//Object []aObject3 =a1; //把一维整形数组赋值给一个一维类数组，因为整形不是类类型，所以赋值无效
Object []aObject4 =a4;
Object []aObject5 =a3;

System.out.println(a1);
System.out.println(a4);
System.out.println(Arrays.asList(a1));//把一维整形数组转化成集合，因为类型不匹配，转化失败
System.out.println(Arrays.asList(a4));//把一维字符串数组转化成集合，转化成功

printObject(a4);//打印数组
printObject("xyz");//打印字符串

}

private static void printObject(Object obj) {
Class class1=obj.getClass();//获得该对象的类
if (class1.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);//不是数组的话，打印单个元素
}

}
private static void changeStringValue(Object obj) throws Exception {
Field[] fields=ReflectPoit.class.getFields();//获得ReflectPoit类的所有字段
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);
}
}
}

9. 反射的实例分析
主程序：
package cn.itcast.day1;
import java.util.*;
public class ReflectTest2 {

public static void main(String[] args) {
Collection collections=new HashSet();//定义一个HashSet对象
ReflectPoit pt1=new ReflectPoit(3,3);//定义三个点
ReflectPoit pt2=new ReflectPoit(5,5);
ReflectPoit pt3=new ReflectPoit(3,3);
collections.add(pt1);//把对象添加到集合中
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);
System.out.println(collections.size());//获得集合的长度

}

}
重写点类里的hashCode方法和equls方法
public int hashCode() { //获得hashCode的方法
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {//重写比较的方法
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final ReflectPoit other = (ReflectPoit) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
hashSet的存储方式是在内存中按照区域存储的，其中hashCode就是在内存中划分区域的算法源。
10. 建立一个读取文件的框架
config.properties文件内的内容是：className=java.util.HashSet
调用执行该文件的代码是：
InputStream ips=new FileInputStream("config.properties");//用文件输入流读取该文件内容
Properties props=new Properties();//建立一个Properties 对象
props.load(ips);//用该对象读取文件内容
ips.close();//关闭文件输入流，释放系统资源
String className=props.getProperty("className");//获得要实例化的类名
Collection collections=(Collection)Class.forName(className).newInstance();//用反射来实例化一个集合对象