java知识点分享_JDK1.5特性

 

JDK1.5新特性
虽然一直在用api的某些东西，但却不能追本溯源，现将jdk1.5的特性介绍如下，方便自己查阅和学习。
会陆续介绍jdk1.6和jdk1.7的新特性。

在黑马入学的自学视频中，不断听到张老师对于新特性的指导，这里也重新复习一下。
一：静态导入
import导入某一个类，或者导入某个包下的所有的类
import static java.lang.Math.max;

 

package com.ambow;
import static java.lang.Math.max;
public class StaticImport {
public static void main(String[] args){
System.out.println(max(3, 6));
System.out.println(Math.abs(3 - 6));
}
}
import static java.lang.Math.*;

二：可变参数：
Overload重载    
Override重写
只能出现在参数列表的最后
...位于参数类型和参数名之间，前后有无空格都可以。
调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数

 

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(add(1,2,2,2,2));
}
public static int add(int x, int...args){
int sum = 0;
sum += x;
/*for(int i : args){
sum += i;
}*/
for(int i=0;i<args.length;i++){
sum += args[i];
}
return sum;
}

三：For循环增强   新式for循环
集合变量可以是数组或实现了Iterable接口的集合类

 

/*for(int i : args){
sum += i;
}*/

四：基本数据类型的自动拆箱与装箱
享源模式

 

Integer iObj = 3;//自动装箱
System.out.println(iObj + 5);//自动拆箱
Integer i1 = 137;   -128~127之间是一样的。用new生成除外
Integer i2 = 137;-128~127之外不一样
String s1 = "abc";字符串是一样的   用new生成除外
String s2 = "abc";==是比较地址   equal是比较对象值
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));

System.out.println("----------------------");

System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

System.out.println("----------------------");
String a1 = new String("abc");
String a2 = new String("abc");
System.out.println(a1 == a2);//地址
System.out.println(a1.equals(a2));//对象值

五：枚举的作用
定值    固定的几个值
编译的时候就发现你填写的值不合法
定义一个新的类型，让这个类型定义的变量指向的值只能是固定的那些值
每一个枚举元素都是一个对象
让每个元素自己写自己的nextDay方法
抽象的方法

 

/**
* 采用抽象方法将nextDay()中大量的if else语句分别转移成了一个独立的类
* @return
*/
public abstract WeekDay nextDay();


　　private WeekDay(){

}
/*public static final WeekDay SUN = new WeekDay();
public static final WeekDay MON = new WeekDay();*/
/**
* 让这个类的子类来创建实例对象
* 这个子类没有名字：匿名类
*/
public static final WeekDay SUN = new WeekDay(){


@Override
public WeekDay nextDay() {
// TODO Auto-generated method stub
return MON;
}

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


@Override
public WeekDay nextDay() {
// TODO Auto-generated method stub
return SUN;
}

};

WeekDay_enum weekDay_enum = WeekDay_enum.FRI;
System.out.println("枚举：" + weekDay_enum);//toString方法
System.out.println("枚举：" + weekDay_enum.name());//自己的name
System.out.println("枚举：" + weekDay_enum.ordinal());//自己的排行，索引从0开始

System.out.println("静态方法：---------------------------------------");

System.out.println("枚举：" + weekDay_enum.getClass());
System.out.println("枚举：" + WeekDay_enum.class);
System.out.println("枚举：" + WeekDay_enum.valueOf("SUN"));
System.out.println("枚举：" + WeekDay_enum.values()[0]);
System.out.println("枚举：" + WeekDay_enum.values().length);
}
public enum WeekDay_enum{
SUN,
MON,
TUE,
WED,
THI,
FRI,
SAT;
}

实现带有构造方法的枚举
枚举中的所有其他信息都必须位于元素列表之后，
元素列表之后如果有东西的话，元素列表之后一定要有分号
构造方法必须为私有的
用到枚举类的时候调用构造方法一次性初始化枚举类内的所有枚举对象

 

 

 

public enum WeekDay_enum{
SUN(),
MON(),
TUE(2),调用带有参数的构造方法
WED,
THI,
FRI,
SAT;//元素列表之后如果有东西的话，元素列表之后一定要有分号
private WeekDay_enum(){//枚举中的所有其他信息都必须位于元素列表之后
System.out.println("first!");//构造方法必须为私有的
}
private WeekDay_enum(int day){
System.out.println("second!");
}
}
//内部类，与成员方法、成员变量平级，可以有那4个访问修饰符
　　public enum TrafficLamp {
RED(30) {//RED由TrafficLamp类的一个子类（匿名类）写的，子类的代码是一个大括号，子类的名字不知道
public TrafficLamp nextLamp() {
return GREEN;
}
},
GREEN(45) {
public TrafficLamp nextLamp() {
return YELLOW;
}
},
YELLOW(15) {
public TrafficLamp nextLamp() {
return RED;
}
};
public abstract TrafficLamp nextLamp();
private int time;
private TrafficLamp(int time){
this.time = time;
}
private TrafficLamp(){
}
}

 

如果枚举只有一个成员，那么你就可以把它当做一种单例。

反射（不是java1.5的新特性   是从java1.2开始就有的一个特性）
Class代表一类什么样的事物：
Person类
Animal类
Car类
Class   类的名字    类属于哪个包  类里面有哪些成员变量   哪些方法  父类是什么  
代表内存里面的一份字节码   没有构造方法
当我们在源程序里面用到某个类的时候，首先要从硬盘上把这个类的二进制代码加载到内存里面来，接着用它来创建一个个的对象
每一个份类的字节码就代表Class类的一个实例对象

 

 

Class cls1 = Person.class;
P1.getClass();由对象得到它所属于的（内存中已有，直接找到返回）
Class.forName(“com.ambow.Person”);得到这个类的字节码  （加载这个类所对应的字节码到虚拟机或者直接查询这个字节码（要看内存中是否已有），并返回这个字节码）

8个基本的数据类型  void   它们都有对应的Class对象 所以有9个预定义的Class对象
基本类型对应的包装类型里面都定义了一个常量，代表这个包装类型所包装的基本类型的字节码。
Void也有   void.TYPE
System.out.println("int[]是否是基本类型：" + int[].class.isPrimitive());
System.out.println("int[]是否是数组类型：" + int[].class.isArray());
System.out.println("int[]与String[]所对应的字节码类型是否相同：" + (String[].class.isPrimitive() == int[].class.isPrimitive()));

反射：java类中的各种成分分别映射成相应的java类
Field  Method  Constructor   Package
各个类的每一个不同的方法都分别对应Method类的一个对象

Constructor
 Constructor<?>[]getConstructors()           返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。
 Constructor<T>getConstructor(Class<?>... parameterTypes) 可变参数          返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。

数组    类型一致   个数固定
 TnewInstance(Object... initargs)           使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

Constructor<String> constructor = String.class.getConstructor(StringBuffer.class);
System.out.println(constructor);
/**
* 构造方法的反射调用
* 使用constructor去创建一个Constructor<String>所属类String的对象
*/
String  string_jz = constructor.newInstance(new StringBuffer("abc"));
System.out.println(string_jz);
System.out.println("所属类：" + constructor.getDeclaringClass());//得到constructor所属类
System.out.println("修饰符：" + constructor.getModifiers());


 FieldgetField(String name)           返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
 Field[]getFields()           返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。

ReflectPoint pt1 = new ReflectPoint(3,5);
//field_y只代表这个类所对应的字节码字段，没有对应到对象身上
Field field_y = ReflectPoint.class.getField("y");
System.out.println("field_y字段在pt1对象上所对应的值：" + field_y.getInt(pt1));
//Field field_x = ReflectPoint.class.getField("x");//这里会抛出异常，只能得到可见的字段，这个得不到x字段
//System.out.println("field_x字段在pt1对象上所对应的值：" + field_x.getInt(pt1));

Field field_x = ReflectPoint.class.getDeclaredField("x");//只要是类里面声明过的，管它可见还是不可见，都能够得到，但是不一定能够去访问取值
field_x.setAccessible(true);//设置可以去取值  可以去访问
System.out.println("field_x字段在pt1对象上所对应的值：" + field_x.getInt(pt1));

Method
 MethodgetMethod(String name, Class<?>... parameterTypes)           返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
 Method[]getMethods()           返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。
//pt1.str1.charAt(1);
Method method_charAt = String.class.getMethod("charAt", int.class);
//在pt1.str1字符串对象上调用charAt这个方法（Method method_charAt），并传递参数1
method_charAt.invoke(pt1.str1, 1);
System.out.println(method_charAt.invoke(pt1.str1, 1));
method_charAt.invoke(null, 1);//不通过方法，是静态的，静态方法的调用不需要对象
 Objectinvoke(Object obj, Object... args)           对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
System.out.println((a1.getClass() == aa.getClass()));
System.out.println(aa.getClass().getSuperclass().getName());

Array还可以插队，有顺序
HashSet插入数据之前先判断集合中是否已经有该数据。根据hashcode值进行判断是否相等，集合中是否已经有该数据
数据插入后
在数据插入后，Hashset中参与hashcode值计算的变量尽量不要修改，否者hashcode值变了     很容易造成内存泄露，
　　Collection collections = new HashSet();
ReflectPoint pt1 = new ReflectPoint(3,3);
　　collections.add(pt1);
　　pt1.setX(7);
collections.remove(pt1);（没有删掉）

由此可见，java中也有内存泄露！！hashset   流没有关闭  输入流  输出流   链接（系统所关联的资源  操作系统的资源）

IntroSpector------主要用于对JavaBean进行操作
如果第二个字母是小写，则把第一个字母设置为小写
如果第二个字母是大写，则第一个字母保持原样！

Beanutils工具包

注解：
@Override
/**
* equals(ReflectPoint obj)不能写成这个，写成这个的话此方法根本得不到调用
* 集合调用的是父类的equals方法equals(Object obj)
*/
public boolean equals(Object obj) {

注解类
应用了注解类的类
对应用了注解类的类进行反射的类

 

 

 

 

 

一个注解的生命周期有三个阶段，
source   源文件   
class     类文件
runtime  运行时

@Retention(RetentionPolicy.RUNTIME)//元注解     元数据  元信息   信息的信息
public @interface ItcastAnnotation {

ArrayList<E> 泛型类型  
E称为类型变量或类型参数
ArrayList<Integer>参数化的类型
ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
<>念typeof

泛型中的问号“？”通配符
限定通配符的上边界：
限定通配符的下边界：
限定通配符总是包含自己

java.util 接口 Map.Entry<K,V>
Entry定义成了Map内部的一个类       完整名称是：Map.Entry
java.util 类 ArrayList<E>
Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess 

java.util 接口 Set<E>
Collection<E>, Iterable<E> 
除了在应用泛型时可以用extends限定符，在定义泛型时也可以用extends限定符。并且还可以用&定义多个限定
<V extends Serializable & cloneable>

还可以对异常采用泛型

通配符方案比泛型更有效
类型推断：
根据调用泛型方法时实际传递的参数类型或返回值的类型来推断
前面是在方法上定义泛型
下面在类上定义泛型：
Create  read   update  delete
CRUD

类加载器
Java虚拟机
Java虚拟机当中有多个类加载器，系统默认提供三个主要的类加载器，每个类加载器负责加载特定位置的类
BootStrap（已经内嵌在java虚拟机内核里面了） 
ExtClassLoader  C:\Program Files\Java\jdk1.5.0_14\jre\lib\ext *.jar
AppClassLoader  C:\Program Files\Java\jdk1.5.0_14\jre\lib rt.jar