高新技术知识点总结01

eclipse工程管理与快捷键配置：

 

1.IDE开发工具都支持使用工程化方式管理一个项目开发过程，一般来说一个相对独立的项目就是一个工程，一个项目中涉及的多个java文件，资源文件等用一个工程进行管理。如果将一个程序的所有源文件用一个工程来组织，开发工具能对所有源文件集中管理，记住每个源文件的位置和相互关系。工程中有哪几个源文件、启动类是哪个、启动参数设置等配置信息在工程中都记录。

 

一个workspace可以包含多个projece,一个workspace保留了eclipse的一套环境选项的配置，例如，所使用的javac和java命令，等等，希捷请参看window---->preferences。

 

如果要为eclipse再配置一套环境选项，可以再创建一个workspace。Packageexpoorer视图窗口中的filters菜单项，可以显示空的父包（此功能默认是关闭的）。

 

2.一个Perspective代表了若干个view的集合，如何显示各种view。

 

3.设置单个工程的javac和java，选择工程，右键--->properties可以设置javac，右键--->rus as--->poen run dialog可以设置java。先将某个工程的java改为1.5运行看版本问题，然后再设置整个工作间的javac，看是否影响已有的工程，然后再单独设置该工程的javac，让其也为jdk1.5，再运行就没版本为题了。

 

4.快捷键使用技巧：快捷键的位置：General--->keys，设置alt+/进行内容提示时，要注意清除alt+/键原来的绑定关系，直接输入alt+/就可以找到它的绑定关系，删除绑定关系时也可以使用remove binding这个按钮。

 

java5的静态导入与编译器语法设置：

 

imoprt语句可以导入一个类或某个包中的所有类

 

import static 语句导入一个类中的某个静态方法或所有静态方法

 

示例：

 

Java代码

<EM>package cn.itcast.day1;

// import static java.lang.Math.max;

import static java.lang.Math.*;

public class StaticImport

{

public static void main(String[]args){

int x=1;

try{

x++;

} finally{

System.out.println("template");

 

}

System.out.println(x);

System.out.println(max(3,6));

System.out.println(abs(3-6));

}

 

}

</EM>

 

可变参数与OverLoad相关面试题分析:

 

可变参数：

 

问题： 一个方法接受的参数个数不固定，例如：

 

 System.out.println(add(2,3,5));

 System.out.println(add(1,2,3,5));

 

可变参数的特点：

 

 只能出现在参数列表的最后；

 ...位于变量类型和变量名之间，前后有无空格都可以；

 调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

 

示例：

 

Java代码 

package cn.itcast.day1;

public class VarbleParameter

{

public static void main(String[]args){

 

}

 

public static int add(int x,int ...args){

int sum=x;

for(int i=0;i<args.length;i++){

sum+=args[i];

}

return sum;

}

}

 

java5的增加for循环：

 

语法：

 for(type 变量名：集合变量名) {...}

注意事项：

 迭代器变量必须在（）中定义；

 集合变量可以是数组或实现了Iterable接口的集合类

举例：

 publicstatic int add(int x, int ... args) {

  intsum=x; 

  for(intarg : args){

 

   sum+=arg;

  }

 

  returnsum;

 }

 

示例：

Java代码 

<SPAN style="FONT-STYLE:normal">package cn.itcast.day1;

public class VarbleParameter

{

public static void main(String[]args){

 

}

 

public static int add(int x,int ...args){

int sum=x;

/* for(int i=0;i<args.length;i++){

sum+=args[i];

}*/

for(int arg: args){

sum+=arg;

}

return sum;

}

}</SPAN>

基本数据的自动拆装箱及享元设计模式：

 

自动装箱：

 Integernum1=12;

自动拆箱：

 System.out.println(num1+12);

示例:

Java代码 

<SPAN style="FONT-STYLE:normal">package cn.itcast.day1;

public class AutoBox

{

public static void main(String[]args){

Integer iObj=3;

System.out.println(iObj+12);

 

String s1=new String("abc");

String s2=new String("abc");

Integer i1=137;

Integer i2=137;

 

System.out.println(i1==i2);

 

Integer i3=Integer.valueof(213);

Integer i4=Integer.valueof(213);

System.out.println(i3==i4);

}

}</SPAN>

枚举的作用介绍、用普通类模拟枚举的实现原理、java5的枚举的基本应用： 

 

为什么要有枚举：   问题：要定义星期几或性别的变量，该怎么定义？假设1-7分别表示星期一到兴起日，但有人可能会写成int  

weekday=0;  枚举就是要让某个类型的变量的取值为若干个固定值中的一个，否则，编译器就会报错。

枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发   阶段无法实现这一目标。用普通类如何实现枚举功能，定义一个Weekday的类来模拟功能。   私有的构造方法   每个元素分别用一个公有的静态成员变量表示   可以有若干公有方法或抽象方法，例如，要提供nextDday方法必须是抽象的。

采用抽象方法定义nextDay就将大量的if.else语句转移成了一个独立的类。 枚举的基本作用   举例：定义一个Weekday的枚举。   扩展：枚举类的values,valueOf,name,toString,ordinal等方法。   总结：枚举是一种特殊的类，其中的每个元素都是给类的一个实例对象，

例如可以调用WeekDay.SUN.getClass().getName和Week.Day.class.getName()。 示例：  

Java代码 

package cn.itcast.day1;

public class EnumTest

{

public static void main(String[]args){

WeekDay weekDay=WeekDay.MON;

System.out.println(weekDay.nextDay());

}

}

Java代码 

package cn.itcast.day1;

public abstract class WeekDay

{

private WeekDay(){}

 

public final static WeekDaySUN= new WeekDay(){

 

public WeekDay nextDay(){

 

return MON;

}

};

 

public final static WeekDayMON= new WeekDay(){

 

public WeekDay(){

 

return SUN;

}

};

 

public abstract WeekDaynextDay();

 

/* Public WeekDay nextDay(){

 

if(this==SUN){

return MON;

}else{

return SUN;

}

}

*/

public String toString(){

 

return this==SUN?"SUN":"MON";

}

}

Java代码 

package cn.itcast.day1;

public class EnumTest

{

public static void main(String[]args){

WeekDay1 weekDay=WeekDay1.MON;

System.out.println(weekDay.nextDay());

 

WeekDay weekDay2=WeekDay.FRI;

System.out.println(weekDay2);

System.out.println(weekDay2.name());

System.out.println(weekDay2.ordinal());

System.out.println(WeekDay.valueOf("SUN").toSting());

System.out.println(WeekDay.values().length);

}

public enum WeekDay{

 

SUN,MON,TUE,WED,THI,FRI,SAT

}

}

实现带有构造方法的枚举：

Java代码 

package cn.itcast.day1;

public class EnumTest

{

public static void main(String[]args){

WeekDay1 weekDay=WeekDay1.MON;

System.out.println(weekDay.nextDay());

 

WeekDay weekDay2=WeekDay.FRI;

System.out.println(weekDay2);

System.out.println(weekDay2.name());

System.out.println(weekDay2.ordinal());

System.out.println(WeekDay.valueOf("SUN").toSting());

System.out.println(WeekDay.values().length);

}

public enum WeekDay{

 

SUN(1),MON(),TUE,WED,THI,FRI,SAT;

private WeekDay(){System.out.println("first");}

private WeekDay(int day){System.out.println("second");}

}

}

实现带有抽象方法的枚举：

Java代码 

package cn.itcast.day1;

 

import java.util.Date;

 

public class EnumTest {

 

/**

* @param args

*/

public static void main(String[]args) {

// TODO Auto-generated method stub

WeekDay1 weekDay = WeekDay1.MON;

System.out.println(weekDay.nextDay());

 

WeekDay weekDay2 = WeekDay.FRI;

System.out.println(weekDay2);

System.out.println(weekDay2.name());

System.out.println(weekDay2.ordinal());

System.out.println(WeekDay.valueOf("SUN").toString());

System.out.println(WeekDay.values().length);

 

new Date(300){};

}

 

public enum WeekDay{

 

SUN(1),MON(),TUE,WED,THI,FRI,SAT;

private WeekDay(){System.out.println("first");}

private WeekDay(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;

}

};

public abstract TrafficLampnextLamp();

private int time;

private TrafficLamp(int time){this.time= time;}

}

}

透彻分析反射的基础_Class类:

反射的基石--->Class类。

Java程序中的各个Java类属于同一类事物，描述这类事物的java类名就是Class。

对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？

 人---->Person

 Java类---->Class

对比提问：Person类代表人，它的实例对象就是张三、李四这样一个个具体的人，Class类代表java类，它的各个实例对象又分别对应什么呢？哦那个

 对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。

 一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以他们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？

如何得到各个字节码对应的实例对象（class类型）

 类名.class，例如，System.class

 对象.getClass()，例如，newDate().getClass()

 Class.forName("类名")，例如，Class.forName("java.util.Date")

九个预定义Class实例对象：

 参看Class.isPrimitve方法的帮助

 Int.class==Integer.TYPE

数组类型的Class实例对象

 class.isArray()

总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[],void...

理解反射的概念：

反射就是把java类中的各种成分映射成相应的java类。例如，一个java类中用一个Class类的对象表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的java类来表示，就像汽车一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Fild、Method、Contructor、Package等等。

一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

构造方法的反射应用：

Constructor类：

Constructor类代表某个类中的一个构造方法

得到某个类所有的构造方法：

 例子:  Constructor[]constructor=Class.forName("java.lang.String").getConstructor();

得到某一个构造方法：

 例子： Constructorconstructor=Class.for.Name("java.lang.String").getConstructor(StringBuffer.class);

   //获得方法时要用到类型

创建实例对象：

 通常方式：String str= new String(new StringBuffer("abc"));

 反射方式：String str= (String)constructor.newinstance(newStringBuffer("abc"));

 //这里要用到上面相同类型的实例对象

Class.newInstance()方法：

 例子：String obj=(Strng)Class.for.Name("java.lang.String").newInstance();

 该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

 该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

示例：

成员变量的反射、成员变量反射的综合案例：

Field类代表某个类中的一个成员变量

演示用eclipse自动生成Java类的构造方法

问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。

示例代码：

 ReflectPoint point = new ReflectPoint(1,7);

 Field y =Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");

 System.out.println(y.get(point));

 //Field x =Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");

 Field x =Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");

 x.setAccessible(true);

 System.out.println(x.get(point));

作业：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。

成员方法的反射：

Method类：

Method类代表某个类中的一个成员方法

得到类中的某一个方法：

例子：   MethodcharAt = Class.forName("java.lang.String").getMethod("charAt",int.class);

调用方法：

通常方式：System.out.println(str.charAt(1));

反射方式：System.out.println(charAt.invoke(str, 1));

如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！

jdk1.4和jdk1.5的invoke方法的区别：

Jdk1.5：public Object invoke(Object obj,Object... args)

Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

 

对接收数组参数的成员方法进行反射：

用反射方式执行某个类中的main方法

 

目标：

写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白为什么要用反射方式去调啊？

问题：

启动Java程序的main方法的参数是一个字符串数组，即publicstatic void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,newString[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。

解决办法：

mainMethod.invoke(null,new Object[]{newString[]{"xxx"}});

mainMethod.invoke(null,(Object)newString[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了

 

数组与Object的关系及其反射类型：

数组的反射

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

Arrays.asList()方法处理int[]和String[]时的差异。

Array工具类用于完成对数组的反射操作。

思考题：怎么得到数组中的元素类型？

 

 

数组与Object的关系及其反射类型、数组的反射应用：

 

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。

代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

Arrays.asList()方法处理int[]和String[]时的差异。

Array工具类用于完成对数组的反射操作。

思考题：怎么得到数组中的元素类型？

 

ArrayList_HashSet的比较及Hashcode分析、框架的概念及用反射技术开发框架的原理、用类加载器的方式管理资源和配置文件：

 

反射的作用?实现框架功能

 

框架与框架要解决的核心问题

我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

框架要解决的核心问题

我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？

因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。

综合案例

先直接用new 语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。

然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异。

引入了elipse对资源文件的管理方式的讲解。

 

示例：

Java代码 

package cn.itcast.day1;

 

import java.io.FileInputStream;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashSet;

import java.util.Properties;

 

public class ReflectTest2 {

 

/**

* @param args

*/

public static void main(String[]args) throws Exception{

// TODO Auto-generated method stub

/*getRealPath();//金山词霸/内部

一定要记住用完整的路径，但完整的路径不是硬编码，而是运算出来的。*/

//InputStream ips = newFileInputStream("config.properties");

 

//InputStream ips =ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties");

//InputStream ips =ReflectTest2.class.getResourceAsStream("resources/config.properties");

InputStream ips =ReflectTest2.class.getResourceAsStream("/cn/itcast/day1/resources/config.properties");

 

Properties props = new Properties();

props.load(ips);

ips.close();

String className =props.getProperty("className");

Collection collections =(Collection)Class.forName(className).newInstance();

 

//Collection collections = new HashSet();

ReflectPoint pt1 = new ReflectPoint(3,3);

ReflectPoint pt2 = new ReflectPoint(5,5);

ReflectPoint pt3 = new ReflectPoint(3,3);

 

collections.add(pt1);

collections.add(pt2);

collections.add(pt3);

collections.add(pt1);

 

//pt1.y = 7;

//collections.remove(pt1);

 

System.out.println(collections.size());

}

 

}

Java代码 

package cn.itcast.day1;

 

import java.util.Date;

 

public class ReflectPoint {

private Date birthday = new Date();

 

private int x;

public int y;

public String str1 = "ball";

public String str2 = "basketball";

public String str3 = "itcast";

 

public ReflectPoint(int x, int y){

super();

this.x = x;

this.y = y;

}

 

 

@Override

public int 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 ReflectPoint other =(ReflectPoint) obj;

if (x != other.x)

return false;

if (y != other.y)

return false;

return true;

}

 

 

@Override

public String toString(){

return str1 + ":" +str2 + ":" + str3;

}

 

 

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 Date getBirthday() {

return birthday;

}

 

 

public void setBirthday(Datebirthday) {

this.birthday = birthday;

}

 

}