黑马程序员-java1.5新特性



---------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ---------------------- 

1静态导入：
**import语句可以导入一个类或某个包中的所有类
**importstatic语句导入一个类中的某个静态方法或所有静态方法
静态导入后，静态方法前面就不用写类名.方法的方式类调用
**语法举例：
importstatic java.lang.Math.sin;//导入一个静态方法
importstatic java.lang.Math.*; //导入一个类中的所有静态方法
**静态导入使用注意：
当类名重复时，需要制定具体的包名；
当方法重名时，需要制定具体所属的对象或者类
2可变参数：
**可变参数的特点：
*可变参数只能出现在参数列表的最后；
*...位于变量类型和变量名之间，前后有无空格都可以;
*调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，
在方法体中以数组的形式访问可变参数。
**可变参数举例：
*变量类型...变量名 如 int... arr 表示可变参数数组
*publicstatic void show(String str , int... arr){}
3增强for循环：
**语法：
for (type 变量名：集合变量名 ) { … }
**注意事项：
迭代变量必须在( )中定义！
集合变量可以是数组或实现了Iterable接口的集合类
**举例：
publicstatic int add(int x,int ...args) {
intsum = x;
for(intarg:args) {
sum+= arg;
}
returnsum;
}
**增强for循环代替了迭代器使用的不爽，简化书写
**增强for循环局限性：
对集合或者数组进行遍历时，只能取元素，不能对集合进行操作
4基本数据类型的自动装箱和拆箱
**基本数据类型
byte ---> Byte
short ---> Short
int ---> Integer
long ---> Long
float ---> Float
double ---> Double
char ---> Character
boolean ---> Boolean
**例子：
**装箱：自动把一个基本数据类型的数据装箱成一个该类型数据的对象引用
Integeri = 3;(jdk1.5之前这样写是不行的，编译报错)
**拆箱：自动把一个基本数据类型的对象引用拆箱成一个基本数据类型的数据，再参与运算
Integeri = 12;
sop(i+4);
**享元模式：
Integernum1 = 12;
Integernum2 = 12;
System.out.println(num1== num2);//打印true

Integernum5 = Integer.valueOf(12);
Integernum6 = Integer.valueOf(12);
System.out.println(num5== num6);//打印true

Integernum3 = 129;
Integernum4 = 129;
System.out.println(num3== num4);//打印false

为什么前面的返回true而后面的运算返回false呢？
对于基本数据类型的整数，装箱成Integer对象时，如果该数值在一个字节内,(-128~127)，
一旦装箱成Integer对象后，就把它缓存到磁里面，当下次，又把该数值封装成Integer对象时
会先看磁里面有没有该对象，有就直接拿出来用，这样就节省了内存空间。因为比较小的整数，
用的频率比较高，就没必要每个对象都分配一个内存空间。
这就是享元模式！比如26个英文字母，10个阿拉伯数字


Integrated Development Environment
装箱和拆箱
享元设计模式：有很多小的对象，他们的属性相同，就把他们变成一个对象，那些不同的属性就把他们变成方法的参数，称之为外部状态，那些相同的属性就把他们变成对象的内部状态
例:
Integeri1 = 12;
Integeri2 = 12;
System.out.println(i1== i2);//true
-128~127之间的数值就不会建立新的对象
Integeri1 = 128;
Integeri2 = 128;
System.out.println(i1== i2);//false

5枚举，自己定义类，规定给变量能赋多少的值，变量赋值不符合我已经定义好的值时，让其编译不能通过

实现枚举抽象的next方法，每个元素分别是由枚举的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义
枚举只有一个成员时，就可以作为一种单例的实现方式
****枚举实例
package com.ljq.test;

public class TestEnum {
/**
* 普通枚举
*/
public enum ColorEnum {
red, green, yellow, blue;
}

/**
* 枚举像普通的类一样可以添加属性和方法，可以为它添加静态和非静态的属性或方法
public enum SeasonEnum {
//注：枚举写在最前面，否则编译出错
spring, summer, autumn, winter;

private final static Stringposition = "test";

public static SeasonEnumgetSeason() {
if("test".equals(position))
return spring;
else
return winter;
}
}

/**
* 订单状态
*
* 实现带有抽象方法的枚举
*/
public enum OrderState {
/** 已取消 */
CANCEL {public StringgetName(){return "已取消";}},
/** 待审核 */
WAITCONFIRM {public StringgetName(){return "待审核";}},
/** 等待付款 */
WAITPAYMENT {public StringgetName(){return "等待付款";}},
/** 正在配货 */
ADMEASUREPRODUCT {public StringgetName(){return "正在配货";}},
/** 等待发货 */
WAITDELIVER {public StringgetName(){return "等待发货";}},
/** 已发货 */
DELIVERED {public StringgetName(){return "已发货";}},
/** 已收货 */
RECEIVED {public StringgetName(){return "已收货";}};

public abstract String getName();
}

public static void main(String[]args) {
//枚举是一种类型，用于定义变量，以限制变量的赋值；赋值时通过“枚举名.值”取得枚举中的值
ColorEnum colorEnum =ColorEnum.blue;
switch (colorEnum) {
case red:
System.out.println("color is red");
break;
case green:
System.out.println("color is green");
break;
case yellow:
System.out.println("color is yellow");
break;
case blue:
System.out.println("color is blue");
break;
}

//遍历枚举
System.out.println("遍历ColorEnum枚举中的值");
for(ColorEnum color :ColorEnum.values()){
System.out.println(color);
}

//获取枚举的个数
System.out.println("ColorEnum枚举中的值有"+ColorEnum.values().length+"个");

//获取枚举的索引位置，默认从0开始
System.out.println(ColorEnum.red.ordinal());//0
System.out.println(ColorEnum.green.ordinal());//1
System.out.println(ColorEnum.yellow.ordinal());//2
System.out.println(ColorEnum.blue.ordinal());//3

//枚举默认实现了java.lang.Comparable接口
System.out.println(ColorEnum.red.compareTo(ColorEnum.green));//-1
}

}

6反射:反射就是把java类中的各个成分映射成相应的java类
一个类中的每一个成员都可以通过Class类中的方法得到

如何得到类的字节码

Method类
Method类代表某个类中的一个成员方法
得到类中的某个方法：Method methodCharAt= Class.forName(“java.lang.String”).getClass().getMethod(“methodCharAt”，int.class);
调用方法：
通常方式: str.charAt(1)；
反射方式: methodCharAt.invoke(str,1);
如果传递给Method对象的invoke()方法的第一个参数为null;那说明该Method对象对应的是一个静态方法；
JDK1.5:publicObject invoke(Object obj,Object…args); 引入了可变参数，不用再把数个参数装到数组中再导入


Hashcode分析：
作用1：可以计算地址值，分配地址值有个Hashcode算法，是按照Hashcode值划分区域，以便查找或比较。
2：在对对象分配完内存空间后，如果更改了对象的某个值，就会导致其哈希值改变，也就改变了它的内存地址，所以你以为删除了这个对象，其实没有，这样的情况发生的一多，就会导致内存溢出

反射的作用----实现框架功能
框架与框架要解决的核心问题：
我做房子给用户住，由用户自己安装门窗和空调，但我不知道用户会安装什么样的门窗，写程序时也一样，我写的框架程序不知道要调用的类名，所以在程序中无法直接new对象，要用反射的方式来做
****实例
需求: 用集合存储对象
但我不知道用户指定哪个集合来存储对象
所以创建配置文件，其中记录用户指定的集合名称
在用户要改变集合时，至于要在配置文件中改变，不用到源程序中

public class reflact {
publicstatic void main(String[] args)throws Exception{
ReflactPointrp = new ReflactPoint();
chengeString(rp);
System.out.println(rp);

InputStreamis = new FileInputStream("config.properties");
Propertiesprop = new Properties();
prop.load(is);
is.close();
StringclassName = prop.getProperty("className");
Collectioncollections = (Collection)Class.forName(className).newInstance();

// Collectioncollections = new ArrayList();
ReflactPointpt1 = new ReflactPoint(3,3);
ReflactPointpt2 = new ReflactPoint(1,1);
ReflactPointpt3 = new ReflactPoint(3,3);
// ReflactPointpt1 = new ReflactPoint(3,3);
collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);
System.out.println(collections.size());

}
配置文件存放路径的选择，eclipse会把源程序下的.java文件都编译为.class文件放入用户目录下，而别的类型的文件会原封不动的放到用户目录下
getRealPath（）获得总项目存放路径+项目内部自己设定的完整路径
通常用类加载器加载配置文件 reflact.class.getClassLoader().getResourceAsStream(“”);
Class中提供了简便方法 reflact.class.getResourceAsStream(“”);
都可以用相对路径或绝对路径

内省(IntorSpector)----操作javaBean
javaBean是一种特殊的java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则
setid（）的意思是设置id值，属性名是id
setCPU()的意思是设置CPU的值，属性名是CPU
getUPS()的意思是获得UPS的值，属性名是UPS
总之，一个类被当作javaBean使用时，javaBean的属性名是根据方法名推断出来的，不用管java内部的私有成员变量是什么

 详情请查看：www.itheima.com