ja

<iframe>是框架的一种形式，它于<frame>不同的是iframe可以嵌在网页中的任意部分。一、<iframe>中元素的作用举如下例子:<iframename=a1width=420height=330frameborder=0scrolling=autosrc=URL></iframe>name：内嵌帧名称；width：内嵌帧宽度(可用像素值或百分比)；height：内嵌帧高度(可用像素值或百分比)；frameborder：内嵌帧边框；marginwidth：帧内文本的左右页边距；marginheight：帧内文本的上下页边距；scrolling：是否出现滚动条(“auto”为自动，“yes”为显示，“no”为不显示)；src：内嵌入文件的地址；style：内嵌文档的样式(如设置文档背景等)；allowtransparency：是否允许透明；二、<iframe>使用的方法1、在<ifame>中可以直接调用src来实现每个固定的页面的显示，例如：<iframename=a1width=420height=330frameborder=0scrolling=autosrc=URL></iframe>这里的URL可以是相对路径，也可以是绝对路径。2、超链接跳转到某个<iframe>，只要给<iframe>命名就可以了。例如<iframewidth=420height=330name=myiframeframeborder=0src=www.sina.com.cn></iframe>。如果要从某个网页上的超链接转到该<iframe>，如下配置就可以：<ahref=URLtarget=myiframe>

直接用超级链接不就好了嘛？为什么呢非得要用javascript框架调用自己的没问题但是调用别的网站不一定行得通的

嵌入其他的页面！

VNC是一款优秀的远程控制工具，由著名的ATT的欧洲研究实验室开发的。VNC是在基于UNIX和Linux操作系统的的开放源码，远程控制能力强大，基本上它是属于一种显示系统,也就是说他能将完整的窗口界面通过网络,传输到另一台计算机的屏幕上.Hi-VPS提供的KVM和Xen 技术VPS支持VNC远程登录管理(Openvz VPS无法使用VNC远程访问)，但是VNC的远程登录效果一般，延迟较大，建议只用来查看Linux故障原因或者安装OS时使用。OS安装成功后就采用SSH或者windows的“远程桌面”来远程控制，访问效果更好。获取VNC登录信息请注意，由于技术架构原因，Openvz VPS无法提供VNC登陆的功能。如果您的VPS是Oepnvz VPS，您是无法使用VNC登陆VPS的功能的。登录VPS的控制面板，获取VNC登录信息后即可登录（控制面板的版本稍微不同，界面可能会有所变化）“VNC password”可以修改您的VNC密码（VNC访问密码和您的root密码可能不一样，请注意），修改后需要重启VPS才能使新的VNC访问密码生效！点击上图的“VNC”图标后，就会弹出VNC访问信息的页面。在“VNC information”中，第一行的您的VPS VNC访问的IP和端口。如果您的VPS没有显示如上信息的话，可能是因为您的VPS尚未开通VNC服务，请在“客户中心”发服务单让我们帮助您开通VNC功能。通过控制面板内置Java版本VNC客户端使用控制面板内置的VNC，必须安装Java。否则您点击“Launch VNC viewer”后浏览器是没有任何反应的。使用老版本Java版本，VNC鼠标定位可能会有一些偏移，所以请安装最新版的Java。因为Chrome内置了Java客户端，可能会引起一些权限的问题。我们建议您JAVA后，使用IE来登录控制面板的JAVA VNC。启动VNC客户端需要JAVA，请首先JAVA。 启动VNC后就能看到了windows2003的安装画面(使用windows 2003镜像安装系统时，在VNC上看到BIOS闪过以后会提示“按任意键开始从CD启动”字样，在键盘上按任意键即可开始windows安装，否则继续使用硬盘引导)。通过第三方VNC连接您可以通过安装VNC Viewer等来连接VPS的VNC：如果连接信息正确的话，VNC Viewer会要求您输入VNC访问密码来访问VPS：

/** * @author Hardneedl */public class ComparableDemo { private interface MinimalChecker<T extends Comparable> { T getMinimal(T v0,T v1); } public static void main(String[] args) { //整型 MinimalChecker integerChecker = new MinimalChecker<Integer>(){ public Integer getMinimal(Integer v0, Integer v1) { return v0.compareTo(v1)<0?v0:v1; } }; }}

错误时找不到符号，具体错误在多少行，不联系上下文光这样看是不好解决的，一般是jar包路径没有搞对吧。

找不到学生类新建一个学生类的构造器

http://www.examda.com/JAVA/

org格式用jade打开方法可以尝试使用Internet Explorer进行访问。org是非营利组织的基本域名。此类文件不能够直接打开，需要使用游戏程序利用特定的加/解密方法进行数据读取和储存。这些org文件格式是游戏系统里自己调用的文件，一般来说除了本游戏，是无法另外打开的。

象征,意向,超现主义,自然主义者,风格,主题,反讽,意识流,多角度描写,有限视角叙述,爵士时代,南方文学,本土特色,迷失的一代

iteye

没看明白，你举例说明下

FANY 姓名：黄伦硕()（HwangYoonSuk） 艺名：焕熙、欢喜()(HwanHee) 生日：1982年1月17日 鞋码：290mm 腰围：30 血型：B 爸爸的名字：黄润室 妈妈的名字：蔡姬子 爷爷的名字：黄易俊 小时候的梦想：当警察 兴趣：打篮球，看电影 听音乐 擅长：舞、篮球、唱歌 最宝贝的：我的家和Brian 初恋：没有 喜欢的饭：排骨 炒饭 讨厌的事物：狗肉和炸酱面 喜欢的歌手：Wax，Brian，朴孝新，杰克逊 喜欢的音乐类型：R&B RoCK 视力:1.5 1.5 觉得自己哪点不好呢?眼睛再大点就好了 宗教:无 学校:情报大学 睡觉的习惯:总是掉到床底下 哭的最长的时候:妈妈住院的时候 笑的最长的时候:第一次FlytotheSky演出的时候 魅力所在：健壮 习惯：总是揉眼睛 喜欢的艺人：N‘SYNC，Brian,金朝汉 经常唱的歌：金朝汉的《到今天为止》 喜欢的颜色：黑色 喜欢的饮食：泡菜炒饭 喜欢的零食：Wapel(不知道是什么东东？） 喜欢的饭馆：日式风味的“Dunga" 酒量：不喝酒（我喜欢） 喜欢的服装式样：Hip-Hop&Suit 喜欢听的话：OPPA 喜欢的人：有道义的，直率的 讨厌的人：把自己的感受隐藏起来，和人装亲近的 讨厌 听的话：起床了（小懒猪） 喜欢的颜色：黑色 喜欢的饮料：SHILOUNTI 喜欢的商标：GALGANI，ALEMANI，NOTIKA 喜欢的食物：泡菜炒饭 喜欢的饰物：耳环 喜欢的餐厅：日式的DUNGA 喜欢的零食；WAPEL 喜欢的服饰：HIO HOP型的，西装 喜欢的香水：2期的DAPAG 喜欢的动物：狗 讨厌的动物：老鼠 亲密的艺人：HOT，SHINWHA，金钟汉，朴孝信 最想采访的明星：JIN 做梦都想见的电影明星：正在锡 采访的时候不可缺的人物：总统 在演艺圈最想知道的事：公开的评奖过程 喜欢的电影： 都很好 想见的演员：许世元。WAX 解除压力的方法：大声唱歌 宝贝：朋友，家人，BRIAN 喜欢哪种女孩：长发，爱我的女孩 喜欢的歌：Brian Mcknight的歌 座右铭：努力唱歌 官网： http://flytothesky.pfull.com记得采纳啊

s

多线程，放到另一个class中。

当然是equals啦，c1,c2又不是常量

这句没有问题！检查是不是其他地方出错

创建另一个类得对象就行了啊 用点运算符调用对象成员

学习下

static 是java一个静态属性

String aa = (String)Class<?>.newInstance();

选择题 (25道)1. 下列选项中，不属于Java语言特点的一项是( C )。A:分布式 B:安全性 C:编译执行 D:面向对象2. Java语言的特点与 C/C+ +语言的比较中说法错误的是：( D )A：简单性Java继承了 C/C+ +的语法 ,丢弃了其中不常用又容易引起混淆的功能。B：Java是一种纯面向对象的语言 ,具有封装、继承 ( Inheritance)和多态( Polymorphism)的特点。C：Java应用程序可凭借URL打开并访问网络上的对象。D：解释型Java写成的源代码需要被编译成高阶的字节码 ,它们与机器架构有关。3. 阅读下列代码，选出该代码段正确的文件名( C )。class A{void method1(){System.out.println("Method1 in class A");}}public class B{void method2(){System.out.println("Method2 in class B");}public static void main(String[] args){System.out.println("main() in class B");}}A: A.java B:A.class C: B.java D: B.class4. 如果一个类的文件名为Student.java，但是类的代码为：public class Student {public static void main(String[] args) {System.out.println(8>>2);}}那么下列说法正确的是：( B )A：程序运行结果为8; B：程序运行结果为2;C：程序运行结果为0; D：程序编译错误，不能运行;5. 符合对象和类的关系的是( D )。A:教师和学生 B:书和房子C:狗和猫 D:飞机和交通工具6. 关于垃圾回收机制描述不正确的是( B )A：垃圾回收机制不须通过程序员调用相应方法，也能自动启动。B：java程序员用System.gc()方法一定能进行垃圾回收;C：垃圾回收机制属于jvm自动操作，java程序员可以不进行垃圾回收操作。D：垃圾回收机制并不是由操作系统自动执行。7. 编译下面源程序会得到哪些文件( D )?class A1{}class A2 exdends A1{}public class B{public static void main(String[] args){}}A: 只有B.class文件 B:只有A1.class和A2.class文件C: 编译不成功 D:A1.class、A2.class和B.class文件8. 下列关于基本数据类型的说法中，不正确的一项是( D )。(A)boolean类型变量的值只能取真或假(B)float是带符号的32位浮点数(C)double是带符号的64位浮点数(D)char是8位Unicode字符9. 下列(D )是合法的标识符?A:12class B:void C:-5 D:_blank10. 在编写Java程序时，如果不为类的成员变量定义初始值，Java会给出它们的默认值，下列说法中不正确的一个是( D )。A:byte的默认值是0 B:boolean的默认值是falseC: char类型的默认值是"" D: long类型的默认值是0.0L11. 下列程序执行的结果是：( B )public class News {public static void main(String[] args) {System.out.println(1+2+ "aa"+3);}}A: "12aa3" B: "3aa3 " C: "12aa" D: "aa3"12. 表达式(12==0) && (1/0 < 1)的值为( B )。A: true B: false C: 0 D: 运行时抛出异常13. 下列循环体执行的次数是( C )。int y=2, x=4;while(--x != x/y){ }A : 1 B: 2 C : 3 D : 414. 已知如下代码：switch(m){case 0: System.out.println("Condition 0");case 1: System.out.println("Condition 1");case 2: System.out.println("Condition 2");case 3: System.out.println("Condition 3");break;default:System.out.println("Other Condition");}当m的值为( D )时，输出“Condition 3”(A)2 (B)0、1 (C)0、1、2 (D)0、1、2、315. 下列语句输出的结果是：( C )public class X3 {public static void main(String[] args) {for(int i=0; i<10; i++){if(i==5) break;System.out.print(i);}}}A：编译错误; B：1234;C：01234;D：12345;16. 下列语句输出的结果是：( D )public class Lx1 {public static void main(String[] args) {for(int i=0;i<5;i++){switch(i){case 0:System.out.print("B");case 1:System.out.print("e");break;case 2:System.out.print("g");case 3:System.out.print("!");break;case 4:System.out.print("!");break;default:System.out.print("!");}}}}A：Beg!!! B：Beeg! C：Beg! D：Beeg!!!17. 下面foreach循环的程序输出结果是( D )。public class Lx1{public static void main(String[] args) {String s1[]={"欢迎您","3","G","同","学",};Arrays.sort(s1);for(String s0:s1)System.out.print (s0);}}A：欢迎您3G同学 B：3G欢迎您同学 C：同学欢迎您3G D：3G同学欢迎您18. 阅读以下程序，选择正确的运行结果：( B )public class Lx1 {public static void main(String[] args) {byte d[]="YOUIHE你我他".getBytes();String s=new String(d,6,2);System.out.println(s);}}A：HE; B：你; C：我; D：他19. 设有下列数组定义语句：int a[][]= {{1, 2}, {3}};则对此语句的叙述正确的是( D )。A: 定义了一个名为a的一维数组 B: a数组 a[1][1]为0C: a数组元素的下标为1～3 D: 数组中每个元素的类型都是整数20. 下列程序输出的结果是：( B )public class Lx1 {public static void main(String[] args) {String a[][] ={{"","","",""},{""},{"",""}};System.out.println(a[2].length);}}A：1 B：2 C：3 D：421. 关于以下程序的说明，正确的是( C )1. class StaticStuff2. {3. static int x=10;4. static { x+=5;}5. public static void main(String args[ ])6. {7. System.out.println(“x=” + x);8. }9. static { x/=3;}10. }A、4行与9行不能通过编译，因为缺少方法名和返回类型B、9行不能通过编译，因为只能有一个静态初始化器C、编译通过，执行结果为：x=5D、编译通过，执行结果为：x=322. 给出下面代码，关于该程序以下哪个说法是正确的?( C )public class Person{static int arr[] = new int[5];public static void main(String a[]) {for(int i=0;iSystem.out.print(arr[0]);}}A、编译时将产生错误 B、编译时正确，运行时将产生错误 C、输出零 D、输出空23. 下面程序中类ClassDemo中定义了一个静态变量sum，分析程序段的输出结果。( C )class ClassDemo {public static int sum=1;public ClassDemo() {sum = sum + 5;}}public class ClassDemoTest{public static void main(String args[]) {ClassDemo demo1=new ClassDemo();ClassDemo demo2=new ClassDemo();System.out.println(demo1.sum);}}A: 0 B: 6 C: 11 D: 224. 下面关于方法的说法，不正确的是( C )。A: Java中的构造方法名必须和类名相同B: 方法体是对方法的实现，包括变量声明和合法语句C: 如果一个类定义了构造方法，也可以用该类的默认构造方法D: 类的私有方法不能被其他类直接访问25. 在Java中下列说法正确的是( C )A) 一个子类可以有多个父类，一个父类也可以有多个子类B) 一个子类可以有多个父类，但一个父类只可以有一个子类C) 一个子类可以有一个父类，但一个父类可以有多个子类D) 上述说法都不对

C#如何实现Java中Class类newInstance方法的功能？ C#里也有类似反射的东西 假设有个类TestClass，程式码如下 namespace TestSpace { public class TestClass { private string _value; public TestClass(string value) { _value=value; } } } 动态建立此类物件下面这样写就行了 Type t = Type.GetType(“TestSpace.TestClass”); Object[] constructParms = new object[] {“hello”}; 构造器引数 TestClass obj = (TestClass)Activator.CreateInstance(t,constructParms); 如果类的构造器是无引数的，就呼叫这个 TestClass obj = (TestClass)Activator.CreateInstance(t); 如何实现BeanUtils.copyProperties方法的功能 第一步: BeanUtils.copyProperties()与PropertyUtils.copyProperties() 1、 通过反射将一个物件的值赋值个另外一个物件（前提是物件中属性的名字相同）。 2、 BeanUtils.copyProperties(obj1,obj2); 经常闹混不知道是谁给谁赋值，无意中先到"后 Java如何实现方法的阻塞 使用 synchronized 关键字 是方法头 使用 synchronized，方法将实现 同步，一次只有一个方法可以使用，当多个程序同时访问时，将只有一个程序可以访问，剩下的程序将等待当前程序结束才能进入。 java中如何实现构造方法的呼叫 class A { public A(){} public A(String a){} public A(String a,String b){ this(); } public A(String a,String b,String c){ this(a,b); ...... } 不知道你是不是想问的是这个。构造方法呼叫构造方法的话，可以采用“this”关键字来实现。 } JAVA中能够实现方法的递回呼叫吗？如何实现？ 能 递回函式即自呼叫函式，在函式体内直接或间接的呼叫自己，即函式的巢状是函式本身。递回呼叫又分为直接呼叫和间接呼叫 直接呼叫funca(){ ...... funca();};间接呼叫；funca(){ ...... funcb();}funcb(){ ..... funca(); .....} 汉诺塔原始码public class HanoiY { void Move(char chSour,char chDest){ System.out.println("Move the plate of "+chSour+"-->"+chDest); } void Hanoi(int n,char chA,char chB,char chC) { if(n==1) Move(chA,chC); else { Hanoi(n-1,chA,chC,chB); this.Move(chA,chC); Hanoi(n-1,chB,chA,chC); } } public static void main(String[] args) { int n=Integer.parseInt(args[0]); HanoiY han=new HanoiY(); han.Hanoi(n,"A","B","C"); } } java如何实现函式和方法的同步 java中表示同步方法的关键字是synchronized，在方法前面加此关键字就表示这是个同步方法，如：public synchronized void set(int i){ }；在同步方法的程式码体内必然有个回圈语句，在回圈语句之后就是等待wait()，或者唤醒notify()。 C＃如何实现vb中Event，RaiseEvent功能 C#的事件跟VB有很大不同,用委托,比如: public delegate void EventHandler(Object sender, EventArgs e); public event EventHandler NoDataEventHandler; 就可以在程式中用 if ( NoDataEventHandler != null) { NoDataEventHandler(sender,e); } 来引发事件了 详细的你应该好好看看MSDN中委托和事件一节 C#如何实现画线功能 你们看懂题目没，“画线后如何能得到这条线上的image的所有画素值”，而不是画线，画线谁不会画呀! 还真没考虑这个问题，要不你自己算吧，2点之间确定一条直线，沿X轴回圈起到到终点，X每进步1，计算出Y值来，然后保持到一个数组里面。 精确点就用PointF储存，一般的用Point储存就行了。 比如说两点是(10,10)、(50,100)，就是 for(int x=10,x<=50;x++) { y=一个代数表示式 } C# winForm如何实现续打功能 第三方控制元件 对devexpress 等对续打和表格就有很多功能，你可以下载一个，而且样式比winform多多了

class A//定义一个类{ private int n;//定义一个属性 //定义方法 public int getN() { return this.n; } public void setN(int n) { this.n = n; }}就这么封装调用：A a = new A();a.setN(2);System.Out.Println(a.getN());

Class.forName(C) 要通过这种方法反射B类的时候一定要写B类的完整的名称，就是报名加类名no.yes.flas.B

对于面向对象的写法, 从最基础的类开始, javascript就有很多种方法写一个类, 那到底哪种是最佳的呢? 和同事讨论, 认为以下的写法是最OK的. functionClassA(){var_this=this; //这是为了给ClassA的私有类使用本实例 var_field1; //private的成员变量 varprivateMethod1=function(){//private里调用private，直接用。 _field1=1;privateMethod2(); //private里调用public，用_this.xxx。 _this.publicMethod1();}this.publicMethod1=function(){//public里调用private，直接用。 _field1=1;privateMethod1(); //public里调用public，用this.xxx。 this.publicMethod2();}ClassA.prototype.staticMethod1=function(){//静态方法}}functionuser(){vara=newClassA(); //public的调用，private的外面就看不到了。 a.publicMethod1(); //静态方法，必须加.prototype，没办法, JS能这样已经很不错了. //而且通过实例a.staticMethod1()也能调用。

Class中有个方法 public native boolean isAssignableFrom(Class<?> cls)用来判断子类是否继承于父类的或者父接口的。你会这样子写：Class clazz = ....;clazz.isAssignableFrom(子类名称)；返回true说明是挂号里的类的父类或父接口。clazz.isAssignableFrom(子类名称)里的子类名称跟版本有关，好像是1.5以上的JDK这里的子类名称都是使用的泛型编程。即传的传数是class<T> 类型的，你用的时候自己斟酌下版本问题。而常用的instanceof(class ..)是指该实例是否属于挂号中的类的父类的一个实例。 如上面的例子：class A{}public class B extends A{public static void main(String[] args){Class clazz = B.class; Class class1 = A.class; System.out.println(class1.isAssignableFrom(clazz)); if(class1.isAssignableFrom(clazz)){ System.out.println("A是B的父类"); }else{ System.out.println("A不是B的父类"); }}}接口的话也一样的：如下 public interface A {}public class B implements A{ public static void main(String[] args) { Class clazz = B.class; Class class1 = A.class; System.out.println(class1.isAssignableFrom(clazz)); if(class1.isAssignableFrom(clazz)){ System.out.println("A是B的父类"); }else{ System.out.println("A不是B的父类"); } }}你测试时只需要把extends A和implements A去掉那就是A不是B的父类或者父接口的情况。 这就是java反射机制的精髓啊

。。。。。。。。。。你不加，它上哪找去啊！

举个例子：ClassA obj = new ClassB(xxx); // xxx指可能的ClassB的构造函数参数当ClassA与ClassB不同，有这样几种情形：ClassA是ClassB的基类，即ClassB定义为 ： class ClassB extands ClassA {...}ClassA是ClassB实现的一个interface，即ClassB定义为： class ClassB implements ClassA {...}不论哪种情形，对象obj都是调用ClassB的构造函数生成的。对象obj是存在于内存里的一块连续区域。程序员可以选择用ClassA来引用它，也可以用ClassB来引用它：ClassA refA = (ClassA) obj;ClassB refB = (ClassB) obj;这都是合法的。

没有积分？

没有定义可以接受这种类型的传值。在编写自定义标签的xml文件时定义你的attribute的rtexprvalue属性为true就可以使用了。 这是对该问题的解释：rtexprvalue：决定属性值是否可以为request-time表达式，也就是类似于< %=…% >的表达式如：<tag> <name>authority</name> <tagclass>com.dw.global.tagsupport.AuthorityTag</tagclass> <bodycontent>jsp</bodycontent><!-- 定义属性 --> <attribute><!-- 应用编号 --> <name>applyId</name> <type>String</type> <requried>true</requried> <rtexprvale>true</rtexprvale> </attribute> <attribute><!-- 权限点编号 --> <name>authorityId</name> <type>String</type> <requried>true</requried> <rtexprvale>true</rtexprvale> </attribute> </tag>

设置流编码

要放在%TOMCAT_HOME%/common/lib下这里是公共包的地方.

这个问题50分都不够的亲。自己去百度吧

这个继承好像毫无意义，你要表达什么？

应该是你在jsp页面中非法使用<when>标签 该标签必须是<choose>标签的直接子标签 不能单独是<when>标签 下面给出一个例子 <c:choose> <c:when test="testCondition"> Content1 </c:when> <c:when test="testCondition"> Content2 </c:when> <c:otherwise> Content3 </c:otherwise> </c:choose>

ActionSupport 是用在Struts中使用动态action时候用到的,那么是否可以理解成加Support这个词,是对原有的Class的功能的一种拓展.这个拓展可以使用,也可以不使用.希望可以帮到你.

用全路径名

Logger来自log4j自己的包。如果用Logger.getLogger，需要一个log4j的jar包，用此方式你只能依靠log4j： LogFactory来自common-logging包。如果用LogFactory.getLog，你可以用任何实现了通用日志接口的日志记录器替换log4j，而程序不受影响。apache的common-logging包是通用日志接口，通过这个中间层，你可以随便指定到底用哪个日志系统。增加系统的灵活性。若log4j它不存在, commons-logging 会另行选择其它的日志实现类。 这样保证了程序中不一定要使用log4j这个日志文件了 增强灵活性的理由： 1)首先在 classpath 下寻找自己的配置文件 commons-logging.properties ，如果找到，则使用其中定义的 Log 实现类； 2) 如果找不到 commons-logging.properties 文件，则在查找是否已定义系统环境变量 org.apache.commons.logging.Log ，找到则使用其定义的 Log 实现类； 3) 否则，查看 classpath 中是否有 Log4j 的包，如果发现，则自动使用 Log4j 作为日志实现类； 4) 否则，使用 JDK 自身的日志实现类（ JDK1.4 以后才有日志实现类）； 5) 否则，使用 commons-logging 自己提供的一个简单的日志实现类 SimpleLog ； 为了简化配置 commons-logging ，一般不使用 commons-logging 的配置文件，也不设置与 commons-logging 相关的系统环境变量，而只需将 Log4j 的 Jar 包放置到 classpash 中就可以了。这样就很简单地完成了 commons-logging 与 Log4j 的融合。 根据不同的性质，日志信息通常被分成不同的级别，从低到高依次是：“调试（ DEBUG ）”“信息（ INFO ）”“警告（ WARN ）”“错误（ERROR ）”“致命错误（ FATAL ）”。 基于common-logging的运行方式： package org; import org.apache.commons.logging.Log; import org.apache.log4j.Logger; public class Test extends TagSupport{ public static Log log=LogFactory.getLog(Test.class); public static void test() { log.debug("111"); log.info("125"); log.warn("485"); log.error("error"); } public static void main(String[] a) { Test.test(); } } 基于log4j的运行方式 import org.apache.log4j.Logger; import org.apache.log4j.PropertyConfigurator; public class TestLog4j { static Logger logger = Logger.getLogger(TestLog4j.class); public static void main(String args[]) { PropertyConfigurator.configure("log4j.properties"); logger.debug("Here is some DEBUG"); logger.info("Here is some INFO"); logger.warn("Here is some WARN"); logger.error("Here is some ERROR"); logger.fatal("Here is some FATAL"); } } ----------- commons-logging 仅仅对 Log4j( 当然还包括其它 LOG 实现 ) 作了一层包装，具体的日志输出还是在内部转交给身后的 Log4j 来处理，还有log4j会默认的去classes目录下去寻找log4j.properties 文件

一、在目前的代码中，B类里没有A类的对象，连A类的对象都没有，肯定更没法调用它里边的变量了。二、因为x使用private修饰，所以不能使用正常的方法获取x的值，如果能获取到A类的对象，可以考虑使用反射来获取

instances of 这个方法啊。。

自己编译一下不就全知道了嘛？ 1. Class A:a=1 d=2.02. Class A:a=1 d=2.0 Class B:a=3.0 d=Java progran. 1这个就是典型的继承，Class B 继承了 Class A ，B从写了A的show()方法，又调入了 super show()也就是A的show()方法 其他的就是简单的输出了

首先执行父类（b）

构造方法初始化 吧他赋值给 对象a

java之public class和class声明区别详解 （转） 在编写类的时候可以使用两种方式定义类： public class定义类: class定义类: 如果一个类声明的时候使用了public class进行了声明，则类名称必须与文件名称完全一致。范例：定义一个类(文件名称为：Hello.java)public class HelloDemo{ //声明一个类，类名称的命名规范：所有单词的首字母大写 public static void main(String args[]){ //主方法 System.out.println("Hello World!!!"); //系统输出，在屏幕上打印 }};此类使用public class声明，类名称是Hello Demo，但是文件名称Hello.java，所以，此时编译时会出现如下问题:Hello.java:1 类 HelloDemo 是公共的，应在名为HelloDemo.java文件中声明public class HelloDemo{ //声明一个类，类名称的命名规范：所有单词首字母大写1、错误以上的错误提示表示：因为使用的是public class声明，所以类名称应该与文件名称完全一致，即应该使用"HelloDemo.java"表示类的名称。如果类的声明使用了class的话，则类名称可以与文件名称不一致，但是执行的时候肯定执行的是生成后的名称。范例：有如下代码(文件名称为:Hello.java)class HelloDemo{ public static void main(String args[]){ System.out.println("Hello World!!!"); }};文件名称为Hello.java，文件名称与类名称不一致，但是因为使用了class声明所以，此时编译不会产生任何错误，但是生成之后的*.class文件的名称是和class声明的类名称完全一致的:HelloDemo.class执行的时候不能再执行java Hello，而是应该执行java HelloDemo在一个*.java的文件中，只能有一个public class的声明，但是允许有多个class的声明public class Hello{ public static void main(String args[]){ System.out.println("Hello World!!!"); }};class A{};class B{};

返回与带有给定字符串名的类或接口相关联的 Class 对象。调用此方法等效于： Class.forName(className, true, currentLoader) 其中 currentLoader 表示此类的定义类加载器。 例如，以下代码片段返回 java.lang.Thread 类的运行时 Class 描述符。 Class t = Class.forName("java.lang.Thread") 调用 forName("X") 将导致名为 X 的类被初始化。 参数：className - 所需类的完全限定名。 返回：具有指定名的类的 Class 对象。 通俗的说就是：获得字符串参数中指定的类，并初始化该类

自己也在学习ing...import java.lang.reflect.*;public class Test{ public static void main(String []args) throws Exception{ Class c = Class.forName("Persion"); Persion p = (Persion)c.newInstance(); Method m = c.getMethod("setName",String.class); m.invoke(p,"xiaoli"); Field f = c.getField("age"); f.setInt(p,10); System.out.println(p.toString()); }};class Persion{ public String name; public int age; public Persion(String name,int age){ this.name=name; this.age=age; } public Persion(){ this.name="lili"; this.age=1; } public void setName(String name){ this.name=name; } public String getName(){ return this.name; } public void setAge(int age){ this.age=age; } public int getAge(){ return this.age; } public String toString(){ return "name="+this.name+",age="+this.age; }};

反射楼上的很详细

我也求解释啊，谁告诉你说p0 = p1啊，其实最重要的是你想问的是p0==p1还是p0=p1

亲,你解决了么?可以分享一下么?

import java.lang.reflect.*;/*所谓的反射机制就是 在一个类中调用另一个类里面的方法和属性等，另一个类可能还没有定义好，但是 * 只要知道他里面有方法，就可以调用；调用那个类就要现获得哪个类的完整名字，在创建一个那个类的一个对象 * 如果是调用无参的，实例化对象以后就可以书出了 * 但是如果是有参数的构造，就需要getDeclaredConstructor（）方法得到一个相对应的构造函数，放到Constructor的一个变量里面 * 然后，在创建一个Object对象实例化有刚才得到的构造函数，最后在输出 使用反射机制： 调用无参构造器实例华 House对象； 调用有参数构造起实例华House对象； 调用toString方法 */public class ReflectTestPro { public static void main(String[] args) throws Exception { Class c = Class.forName("chap06.House");//路径// new House(); // 调用无参构造器实例华 House对象； Object h1 = c.newInstance();// 多态表现 父类和子类 System.out.println(h1); // 调用无参构造器实例华 ArrayList对象； Class c1 = Class.forName("java.util.ArrayList");// 类名要完整 Object h2 = c1.newInstance();// 相当于new ArrayList(); System.out.println(h2);// 调用有参数构造起实例华House对象； Constructor cons = c.getDeclaredConstructor(new Class[] { String.class, String.class, double.class });//可其构造函数里面的参数类型一定要一致 Object h3 = cons.newInstance(new Object[] { "shanghai", "3-2-1", new Double(100.0) });//实例化这个类的一个实例 // 相当于常规方式中的new House("shanghai///,"3-2-1",100) System.out.println(h3); // 调用有参构造器实例华 Date对象 Class c4 = Class.forName("java.util.Date"); Constructor cons4 = c4.getDeclaredConstructor(new Class[] { long.class }); Object h4 = cons4.newInstance(new Object[] { new Long(999999l) }); System.out.println(h4);// 调用toString方 Method m = c.getDeclaredMethod("toString", new Class[] {}); String s = (String) m.invoke(h3, new Object[] {});// Stirng // s=h3.toString(); System.out.println(s);}}

package com.Test1;class A {public A(String a) {System.out.println(a);}}class B {public B(String b) {System.out.println(b);}}class C extends A {public C(String x , String y) {super(x);new B(y);}}public class Test2 {public static void main(String[] args) {C c = new C("a","b");}}

多继承虽然能使子类同时拥有多个父类的特征，但是其缺点也是很显著的，主要有两方面：(1)如果在一个子类继承的多个父类中拥有相同名字的实例变量，子类在引用该变量时将产生歧义，无法判断应该使用哪个父类的变量。例如： 类ClassA：public class ClassA { protected int varSame = 0;} 类ClassB：public class ClassB { protected int varSame = 1;} 子类ClassC：（假设允许类与类之间多继承） public class ClassC extends ClassA, ClassB { public void printOut() { System.out.println(super.varSame); } public static void main(String[] args) { ClassC classC = new ClassC(); classC.printOut(); } }上面程序的运行结果会是什么呢？输出0还是1？(2)如果在一个子类继承的多个父类中拥有相同方法，子类中有没有覆盖该方法，那么调用该方法时将产生歧义，无法判断应该调用哪个父类的方法。例如： 类ClassA： public class ClassA { public void printOut() { System.out.println(0); } }类ClassB：public class ClassB { public void printOut() { System.out.println(1); } } 子类ClassC：（假设允许类与类之间多继承）public class ClassC extends ClassA, ClassB { public static void main(String[] args) { ClassA classA = new ClassC(); classA.printOut(); // ------------------------- A行 ClassB classB = new ClassC(); classB.printOut(); // ------------------------- B行 ClassC classC = new ClassC(); classC.printOut(); //------------------------- C行 } } 上面程序的运行结果会是什么呢？A、B、C三行的输出是0还是1？正因为有以上的致命缺点，所以java中禁止一个类继承多个父类；在接口中不能有实例变量，只能有静态的常量，不能有具体的方法（包含方法体），只能有抽象方法，因此也就摒弃了多继承的缺点。对于一个类实现多个接口的情况，因为接口只有抽象方法，具体方法只能由实现接口的类实现，在调用的时候始终只会调用实现类的方法（不存在歧义），因此不存在 多继承的第二个缺点；而又因为接口只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。对于一个接口继承多个父接口的情况也一样不存在这些缺点。

new 出来的是实例，而这个clazz 是类类型的一个对象而已。

前者只是获取该类声明的方法，而后者还包括父类的。

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。1．检测类：1.1 reflection的工作机制考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。import java.lang.reflect.*;public class DumpMethods {public static void main(String args[]) {try {Class c = Class.forName(args[0]);Method m[] = c.getDeclaredMethods();for (int i = 0; i < m.length; i++)System.out.println(m[i].toString());} catch (Throwable e) {System.err.println(e);}}}按如下语句执行：java DumpMethods java.util.Stack它的结果输出为：public java.lang.Object java.util.Stack.push(java.lang.Object)public synchronized java.lang.Object java.util.Stack.pop()public synchronized java.lang.Object java.util.Stack.peek()public boolean java.util.Stack.empty()public synchronized int java.util.Stack.search(java.lang.Object)这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。1.2 Java类反射中的主要方法对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，Constructor[] getConstructors() -- 获得类的所有公共构造函数Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：Field getField(String name) -- 获得命名的公共字段Field[] getFields() -- 获得类的所有公共字段Field getDeclaredField(String name) -- 获得类声明的命名的字段Field[] getDeclaredFields() -- 获得类声明的所有字段用于获得方法信息函数：Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法Method[] getMethods() -- 获得类的所有公共方法Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法Method[] getDeclaredMethods() -- 获得类声明的所有方法1.3开始使用 Reflection：用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。下面就是获得一个 Class 对象的方法之一：Class c = Class.forName(java.lang.String);这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：Class c = int.class;或者Class c = Integer.TYPE;它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。 一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：Class c = Class.forName(java.lang.String);Method m[] = c.getDeclaredMethods();System.out.println(m[0].toString());它将以文本方式打印出 String 中定义的第一个方法的原型。2．处理对象：如果要作一个开发工具像debugger之类的，你必须能发现filed values,以下是三个步骤:a.创建一个Class对象b.通过getField 创建一个Field对象c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).例如：import java.lang.reflect.*;import java.awt.*;class SampleGet {public static void main(String[] args) {Rectangle r = new Rectangle(100, 325);printHeight(r);}static void printHeight(Rectangle r) {Field heightField;Integer heightValue;Class c = r.getClass();try {heightField = c.getField(height);heightValue = (Integer) heightField.get(r);System.out.println(Height: + heightValue.toString());} catch (NoSuchFieldException e) {System.out.println(e);} catch (SecurityException e) {System.out.println(e);} catch (IllegalAccessException e) {System.out.println(e); } } }

1 Java的动态特性Java的动态特性有两种，一是隐式的；另一种是显示的。隐式的(implicit)方法就是当程式设计师用到new 这个Java 关键字时，会让类别载入器依需求载入您所需要的类别，这种方式使用了隐式的(implicit)方法。显式的方法，又分成两种方式，一种是藉由java.lang.Class 里的forName()方法，另一种则是藉由java.lang.ClassLoader 里的loadClass()方法。您可以任意选用其中一种方法。2 隐式的动态特性在执行java文件时，只有单独的变量声明是不会载入相应的类的，只有在用new生成实例时才载入如示例所示：public class Mainpublic static void main(String args[]){A a1 = new A() ;B b1 ;}类A和B相同，如下：public class A{public void print(“using A”);}编译后，可用java _verbose:class Main运行，察看输出结果。可以看到JVM只载入了A，而没有载入B.另外，类的载入只在执行到new一个类时，才载入，如果没有执行到new语句，则不载入。如：//类Officepublic class Office{public static void main(String[] args){Word myword=null;Excel myexcel=null;if (args[0].equals("Word")){myword = new Word();myword.start();}if (args[0].equals("Excel")){myexcel = new Excel();myexcel.start();}}}//类Word和Excel基本相同，如下public class Word{public void start(){System.out.println("using word");}}在dos命令提示符下，输入java _verbose Office Excel可以看到JVM只载入Excel类，而不载入Word类。3 显示的动态特性3.1 java.lang.Class里的forName()方法在上一个Office示例中，进行如下修改：一 加入Assembly类public interface Assembly{public void start();}二 让Word和Excel类实现该接口public class Word implements Assembly{public void start(){System.out.println("using word");}}三 Office 类如下所示public class Office{public static void main(String[] args) throws Exception{java.lang.Class c = java.lang.Class.forName(args[0]);Object o = c.newInstance();Assembly a = (Assembly)o;a.start();}}在命令提示符下输入java _verbose Office Word 输出入下：通过上图你可以看到，interface 如同class 一般，会由编译器产生一个独立的类别档(.class)，当类别载入器载入类别时，如果发现该类别继承了其他类别，或是实作了其他介面，就会先载入代表该介面的类别档，也会载入其父类别的类别档，如果父类别也有其父类别，也会一并优先载入。换句话说，类别载入器会依继承体系最上层的类别往下依序载入，直到所有的祖先类别都载入了，才轮到自己载入。下面介绍一下 forName 函数, 如果您亲自搜寻Java 2 SDK 说明档内部对於Class 这个类别的说明，您可以发现其实有两个forName()方法，一个是只有一个参数的(就是之前程式之中所使用的):public static Class forName(String className)另外一个是需要三个参数的:public static Class forName(String name, boolean initialize,ClassLoader loader)这两个方法，最後都是连接到原生方法forName0()，其宣告如下:private static native Class forName0(String name, boolean initialize, ClassLoader loader)throws ClassNotFoundException;只有一个参数的forName()方法，最後叫用的是:forName0(className, true, ClassLoader.getCallerClassLoader());而具有三个参数的forName()方法，最後叫用的是:forName0(name, initialize, loader);这里initialize参数指，在载入类之后是否进行初始化，对于该参数的作用可用如下示例察看：类里的静态初始化块在类第一次被初始化时才被呼叫，且仅呼叫一次。在Word类里，加入静态初始化块public class Word implements Assembly{static{System.out.println("word static initialization ");}public void start(){System.out.println("using word");}}将类Office作如下改变：public class Office{public static void main(String[] args) throws Exception{Office off= new Office();System.out.println("类别准备载入");java.lang.Class c = java.lang.Class.forName(args[0],true,off.getClass().getClassLoader());System.out.println("类别准备实体化");Object o = c.newInstance();Object o2 = c.newInstance();}}#p#副标题#e#如果第二个参数为true 则输出入下如果为false ，则输出入下：可见，类里的静态初始化块仅在初始化时才执行，且不过初始化几次，它仅执行一次（这里有一个条件，那就是只有它是被同一个类别载入器多次载入时，才是这样，如果被不同的载入器，载入多次，则静态初始化块会执行多次）。关于第三个参数请见下节介绍3.2 直接使用类别载入器 java.lang.ClassLoader在Java 之中，每个类别最後的老祖宗都是Object，而Object 里有一个名为getClass()的方法，就是用来取得某特定实体所属类别的参考，这个参考，指向的是一个名为Class 类别(Class.class) 的实体，您无法自行产生一个Class 类别的实体，因为它的建构式被宣告成private，这个Class 类别的实体是在类别档(.class)第一次载入记忆体时就建立的，往後您在程式中产生任何该类别的实体，这些实体的内部都会有一个栏位记录着这个Class 类别的所在位置。基本上，我们可以把每个Class 类别的实体，当作是某个类别在记忆体中的代理人。每次我们需要查询该类别的资料(如其中的field、method 等)时，就可以请这个实体帮我们代劳。事实上，Java的Reflection 机制，就大量地利用Class 类别。去深入Class 类别的原始码，我们可以发现Class类别的定义中大多数的方法都是原生方法(native method)。在Java 之中，每个类别都是由某个类别载入器(ClassLoader 的实体)来载入，因此，Class 类别的实体中，都会有栏位记录着载入它的ClassLoader 的实体(注意:如果该栏位是null，并不代表它不是由类别载入器所载入，而是代表这个类别由靴带式载入器(bootstrap loader,也有人称rootloader)所载入，只不过因为这个载入器并不是用Java 所写成,是用C++写的，所以逻辑上没有实体)。系统里同时存在多个ClassLoader 的实体，而且一个类别载入器不限於只能载入一个类别，类别载入器可以载入多个类别。所以，只要取得Class 类别实体的参考，就可以利用其getClassLoader()方法篮取得载入该类别之类别载入器的参考。getClassLoader()方法最後会呼叫原生方法getClassLoader0()，其宣告如下:private native ClassLoader getClassLoader0();最後，取得了ClassLoader 的实体，我们就可以叫用其loadClass()方法帮我们载入我们想要的类别，因此上面的Office类可做如下修改：public class Office{public static void main(String[] args) throws Exception{Office off= new Office();System.out.println("类别准备载入");ClassLoader loader = off.getClass().getClassLoader();java.lang.Class c = loader.loadClass(args[0]);System.out.println("类别准备实体化");Object o = c.newInstance();Object o2 = c.newInstance();}}其输出结果同forName方法的第二个参数为false时相同。可见载入器载入类时只进行载入，不进行初始化。获取ClassLoader还可以用如下的方法：public class Office{public static void main(String[] args) throws Exception{java.lang.Class cb = Office.class;System.out.println("类别准备载入");ClassLoader loader = cb.getClassLoader();java.lang.Class c = loader.loadClass(args[0]);System.out.println("类别准备实体化");Object o = c.newInstance();Object o2 = c.newInstance();}}在此之前，当我们谈到使用类别载入器来载入类别时，都是使用既有的类别载入器来帮我们载入我们所指定的类别。那麽，我们可以自己产生类别载入器来帮我们载入类别吗? 答案是肯定的。利用Java 本身提供的.URLClassLoader 类别就可以做到。public class Office{public static void main(String[] args) throws Exception{URL u = new URL("file:/d:/myapp/classload/");URLClassLoader ucl = new URLClassLoader(new URL[]{u});java.lang.Class c = ucl.loadClass(args[0]);Assembly asm = (Assembly)c.newInstance();asm.start();}}在这个范例中，我们自己产生.URLClassLoader 的实体来帮我们载入我们所需要的类别。但是载入前，我们必须告诉URLClassLoader 去哪个地方寻找我们所指定的类别才行，所以我们必须给它一个URL 类别所构成的阵列，代表我们希望它去搜寻的所有位置。URL 可以指向网际网路上的任何位置，也可以指向我们电脑里的档案系统(包含JAR 档)。在上述范例中，我们希望URLClassLoader 到d:mylib 这个目录下去寻找我们需要的类别， 所以指定的URL为”file:/d:/my/lib/”。其实，如果我们请求的位置是主要类别(有public static void main(String args[])方法的那个类别)的相对目录，我们可以在URL 的地方只写”file:lib/”，代表相对於目前的目录。下面我们来看一下系统为我们提供的3个类别载入器：java.exe 是利用几个基本原则来寻找Java Runtime Environment(JRE)，然後把类别档(.class)直接转交给JRE 执行之後，java.exe 就功成身退。类别载入器也是构成JRE 的其中一个重要成员，所以最後类别载入器就会自动从所在之JRE 目录底下的libt.jar 载入基础类别函式库。当我们在命令列输入java xxx.class 的时候，java.exe 根据我们之前所提过的逻辑找到了JRE(Java Runtime Environment)，接着找到位在JRE 之中的jvm.dll(真正的Java 虚拟机器)，最後载入这个动态联结函式库，启动Java 虚拟机器。虚拟机器一启动，会先做一些初始化的动作，比方说抓取系统参数等。一旦初始化动作完成之後，就会产生第一个类别载入器，即所谓的Bootstrap Loader，Bootstrap Loader 是由C++所撰写而成(所以前面我们说，以Java 的观点来看，逻辑上并不存在Bootstrap Loader 的类别实体，所以在Java 程式码里试图印出其内容的时候，我们会看到的输出为null)，这个Bootstrap Loader 所做的初始工作中，除了也做一些基本的初始化动作之外，最重要的就是载入定义在sun.misc 命名空间底下的Launcher.java 之中的ExtClassLoader(因为是inner class，所以编译之後会变成Launcher$ExtClassLoader.class)，并设定其Parent 为null，代表其父载入器为BootstrapLoader。然後Bootstrap Loader 再要求载入定义於sun.misc 命名空间底下的Launcher.java 之中的AppClassLoader(因为是inner class，所以编译之後会变成Launcher$AppClassLoader.class)，并设定其Parent 为之前产生的ExtClassLoader 实体。这里要请大家注意的是，Launcher$ExtClassLoader.class 与Launcher$AppClassLoader.class 都可能是由Bootstrap Loader 所载入，所以Parent 和由哪个类别载入器载入没有关系。三个载入器的层次关系可通过运行下面的例子察看：public class Test{public static void main(String[] args){ClassLoader cl1 = Test.class.getClassLoader();System.out.println(cl1);ClassLoader cl2 = cl1.getParent();System.out.println(cl2);ClassLoader cl3 = cl2.getParent();System.out.println(cl3);}}运行结果：////////////////////////////////////////////////////////////sun.misc.Launcher$AppClassLoader@1a0c10fsun.misc.Launcher$ExtClassLoader@e2eec8null//////////////////////////////////////////////////////////如果在上述程式中，如果您使用程式码:cl1.getClass.getClassLoader()及cl2.getClass.getClassLoader()，您会发现印出的都是null，这代表它们都是由Bootstrap Loader 所载入。这里也再次强调，类别载入器由谁载入(这句话有点诡异，类别载入器也要由类别载入器载入，这是因为除了Bootstrap Loader 之外，其余的类别载入器皆是由Java 撰写而成)，和它的Parent 是谁没有关系，Parent 的存在只是为了某些特殊目的，这个目的我们将在稍後作解释。在此要请大家注意的是，AppClassLoader 和ExtClassLoader 都是URLClassLoader 的子类别。由於它们都是URLClassLoader 的子类别，所以它们也应该有URL 作为搜寻类别档的参考，由原始码中我们可以得知，AppClassLoader 所参考的URL 是从系统参数java.class.path 取出的字串所决定，而java.class.path 则是由我们在执行java.exe 时，利用_cp 或-classpath 或CLASSPATH 环境变数所决定。#p#副标题#e#用如下示例测试：public class AppLoader{public static void main(String[] args){String s = System.getProperty("java.class.path");System.out.println(s);}}/////////////////////////////////////////////////////////////////D:myappclassloadjava AppLoader.;D:myjavaTomcat5.0webappsaxisWEB-INFlibaxis.jar;D:myjavaTomcat5.0webappsaxisWEB-INFlibcommons-logging.jar;D:myjavaTomcat5.0webappsaxisWEB-INFlibcommons-discovery.jar;C:oracleora81jdbclibclasses12.zip;D:myjavaJDBCforSQLserverlibmssqlserver.jar;D:myjavaJDBCforSQLserverlibmsbase.jar;D:myjavaJDBCforSQLserverlibmsutil.jar;D:myjavaTomcat5.0commonlibservlet-api.jar;D:myjavaj2sdk1.4.2_04jrelibt.jar;C:sunappserverlibj2ee.jar;D:myjavaj2sdk1.4.2_04libjaxp.jar;D:myjavaj2sdk1.4.2_04libsax.jar;D:myappclassloadjava -classpath .;d:myapp AppLoader.;d:myapp/////////////////////////////////////////////////////////////////从这个输出结果，我们可以看出，在预设情况下，AppClassLoader 的搜寻路径为”.”(目前所在目录)，如果使用-classpath 选项(与-cp 等效)，就可以改变AppClassLoader 的搜寻路径，如果没有指定-classpath 选项，就会搜寻环境变数CLASSPATH。如果同时有CLASSPATH 的环境设定与-classpath 选项，则以-classpath 选项的内容为主，CLASSPATH 的环境设定与-classpath 选项两者的内容不会有加成的效果。至於ExtClassLoader 也有相同的情形，不过其搜寻路径是参考系统参数java.ext.dirs。系统参数java.ext.dirs 的内容，会指向java.exe 所选择的JRE 所在位置下的libext 子目录。Java.exe使用的JRE是在系统变量path里指定的，可以通过修改path从而修改ExtCLassLoader的搜寻路径，也可以如下命令参数来更改，java _Djava.ext.dirs=c:winnt AppLoader //注意 =号两边不能有空格。-D也不能和java分开。////////////////////////////////////////////////////////////////D:myappclassloadjava ExtLoaderD:myjavaj2sdk1.4.2_04jrelibextD:myappclassloadjava -Djava.ext.dirs=c:winnt ExtLoaderc:winnt////////////////////////////////////////////////////////////////最後一个类别载入器是Bootstrap Loader ， 我们可以经由查询由系统参数sun.boot.class.path 得知Bootstrap Loader 用来搜寻类别的路径。该路径的修改与ExtClassLoader的相同。但修改后不影响Boots

不能。一个类不能直接继承多个类，java是单继承语言。比如说这样：class A extends B,C 不能这样写，因为java不支持多继承。但是可以像下面这样实现继承多个类：class A extends B，class C extends A，这样C就同时继承了B和A两个类了。

楼主贴了一段代码，不知道想问什么问题啊？不过Calendar在set月份的时候要注意1月到12月是对应从0到11的，你写的不对。

多继承会出现“可怕的菱形”结构。假设 B继承A，C也继承AB重写了A中的方法，C也重写了A中的方法。此时 如果D 同时继承B和C的话，那么D中的某个方法（源于A的），究竟是用B的还是C的呢？个人认为Sun在设计接口这个特性时，充分考虑了EJB技术。多继承和反射机制没有什么关系。接口中只能声明静态常量。成员方法 在默认情况下就是抽象的

在主类创建就OK了，别说三个，一百个也是可以的

都有孩子了。

NADA李允烈（奶大）2007年退了，就是因为被有着星际“本座”之称的SaviOr（马在允）击败。FLASH李永浩（教主）是1992年生的，那时教主才不满14岁，还在念初二，JaeDong 李济东（暴君）是1990年生的，那时16岁，念高一。 Bisu金泽龙（隐神）是1989年生的，那时17岁，刚刚进入职业。Stork宋炳具（鸟神）1988年生的，那时18岁，也是刚刚从业余转到职业。 以上四位，基本上都不是和nada李允烈（奶大）一个年代的选手，在我的印象中好像没有和三位在OSL和MSL等正式联赛中交过手。

歌曲名:Come Home歌手:James专辑:James: The Best OfLene Marlin - Come HomeI just wanna lock the doorLeave it all outsideTurn off the lampsI just wanna hideDon"t bother look for meNot even sure that you wereSo I don"t have to tellI am not feeling well this staysJust give me directions I go anywhereI need to find something I can not find hereGive me a chance I prove that you are wrongI manage to find I can be strongAnd maybe I wanna come homeThat maybe I wanna come homeI just wanna stay in backStay right here for nowLeft it with my thoughtsI don"t know howI do face another dayAnd I tragedy for it yetSo I don"t have to show that I am not OK this wayJust give me directions I go anywhereI need to find something I can not find hereGive me a chance I prove that you are wrongI manage to find I can be strongAnd maybe I wanna come homeThat maybe I wanna come homeAh Ah Ah Ah Ah Ah Ah Ah AhJust give me directions I go anywhereI need to find something I can not find hereGive me a chance I prove that you are wrongI manage to find I can be strongAnd maybe I wanna come homeThat maybe I wanna come homeMaybe I wanna come homeListened by John Lee from LK Lyrics Grouphttp://music.baidu.com/song/10300695

加QQ，给分吧，8973894，可以直接给你发文件

outline是在菜单栏下window下的show view 里面的 outline,主要是展示这个类的类名，下面的变量，方法。

java中 简单类型不会被传递 这根C/C++有所不同

public class Employee { private String id = null;// id : String型，代表员工ID号 private String name = null;// name : String型，代表姓名 private int age = 0;// age : int型，代表年龄 private boolean sex = true;// sex : boolen型，代表性别（其中：true表示男，false表示女） private String phone = null;// phone : String型，代表联系电话 private float salary = 0;// salary: float型，代表员工薪水 // 有参数构造方法，分别初始化ID号、姓名、年龄、性别、联系电话和薪水属性。 public Employee(String sId, String sName, int sAge, boolean sSex, String sPhone, float sSalary) { super(); this.id = sId; this.name = sName; this.age = sAge; this.sex = sSex; this.phone = sPhone; this.salary = sSalary; } @Override public String toString() { //以 “姓名：联系电话”的形式作为方法的返回值。 这叫不是太明白你的意思 return "+id:" + name + ":" + age + ":" + sex + ":" + phone + ":" + salary; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public boolean isSex() { return sex; } public void setSex(boolean sex) { this.sex = sex; } public String getPhone() { return phone; } public void setPhone(String phone) { this.phone = phone; } public float getSalary() { return salary; } public void setSalary(float salary) { this.salary = salary; }}希望你能用到

您好，1.首先DBConn.java类中的public void ListUser()返回值是空，应该返回一个list才对修改如下：　　Java code　　public List ListUser() { try { List<Users> list=new ArrayList<List>(); Users user=null; stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery("select * from users"); while (rs.next()) { user=new Users(); user.setName(rs.getString("name")); user.setXXX(rs.getString("XXX")); . . list.add(user)； } } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } return list; }

推荐你用Eclipse这些get set方法都直接可以生成

jazz hiphop主要是指内容风格种类的划分lofi hiphop主要是指制作方式和表现形式也就是说一首歌可以是jazz hipho也可以是lofi hiphop

var arr=[];//This program is made up of recursive arraysvar list=ul.getElementsByTagName("li");/*Javascript is a developed by Netscape LiveScript prototype inheritance of the object-oriented dynamic type case sensitive client script language, the main purpose is to solve the server-side language, Perl, for example, the speed of the legacy problems, to provide customers with more smooth browsing effect. At that time, the service side need to verify this data, because the network speed is quite slow, only 28.8 KBPS, validation step waste too much time. Then Netscape Navigator browser Javascript, provides the basic functions of the data validation.*/(function(){ if(list.length>4){arr.push(list.splice(0,4));arguments.callee(); }else{ arr.push(list); return "browsing effect. At that time"; };})();//The return value of this program is emptyalert(arr[0][1]);//Below is a list of the content of the return

setinterval("fade(1,3)",60) 这样调用

I Will Come To You我会到你身边HansonHanson / I Will Come To YouAlbum: Middle Of Nowhere专辑：消失之间 I Will Come To You我会到你身边When you have no light to guide you当没有光引导你And no one to walk to walk beside you没人在身边陪你走路I will come to you我会到你身边Oh I will come to you哦我会到你身边When the night is dark and stormy当夜晚很黑，狂风暴雨You won"t have to reach out for me你不用去找我I will come to you我会到你身边Oh I will come to you哦我会到你身边Sometimes when all your dreams may have seen better days有时候，当你所有的梦都看到更好的日子And you don"t know how or why, but you"ve lost your way但你不知道怎么和为什么，那时你已经迷路了Have no fear when your tears are fallin"你哭的时候不要害怕I will hear your spirit callin"我会听到你心灵的呼唤And I swear I"ll be there come what may我发誓我会陪着你(Repeat Chorus)重复高潮部分"Cause even if we can"t be together因为，即使我们不能一起We"ll be friends now and forever我们永远是朋友And I swear that I"ll be there come what may我发誓我会陪着你When the night is dark and stormy当夜晚很黑，狂风暴雨You won"t have to reach out for me你不用去找我I will come to you我会到你身边Oh I will come to you哦我会到你身边We all need somebody we can turn to我们需要求助Someone who"ll always understand那个永远明白我的人So if you feel that your soul is dyin"所以当你觉得生命快要枯萎And you need the strength to keep tryin"而你又需要力量去支撑I"ll reach out and take your hand我会出现而且抓住你的手(Repeat Chorus)重复高潮部分

setInterval将会变相对其第一个参数执行eval，所以如果你想给其中的函数加参数是可以的，但是你要按照eval函数接受的方式，将函数和参数拼接为一个字符串，而不是像正常的函数调用一样

Long ago, but not so very long ago The world was different, oh yes it was You settled down and you built a town and made it live And you watched it grow It was your town Time goes by, time brings changes, you change, too Nothing comes that you can"t handle, so on you go Never see it coming, the world caves in on you On your town Nothing you can do. Main street isn"t main street anymore Lights don"t shine as brightly as they shone before Tell the truth, lights don"t shine at all In our town Sun comes up each morning Just like it"s always done Get up, go to work, start the day, Open up for business that"s never gonna come As the world rolls by a million miles away Main street isn"t main street anymore No one seems to need us like they did before It"s hard to find a reason left to stay But it"s our town Love it anyway Come what may, it"s our town. 很久以前，但不是太久 世界不同了，是的它不同了 你建造一个城市在那里安家，并看着它成长，那是属于你的城市 时光流逝，时间带来了变化，你也改变了 没有什么是你处理不了的，还没有，世界向你屈服，向你的城市屈服 你什么都不能做 主要街道己经不在是主要街道 霓虹灯已不再像以前那样闪耀 说实话，在我们的城市霓虹灯从来就没有闪耀过 太阳依旧像每天一样升起 起床，去工作，开始新的一天， 开始你的工作就像什么都没有改变 世界快速旋转 主要街道己经不再 没有人像以前那样需要我们 找不到一个理由生存 但我们依然爱我们的城市 那是我们的城市

try catch fillay

重写Overriding是父类与子类之间多态性的一种表现，如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。Overriding的方法是不可以改变返回值的类型。重载Overloading是一个类中多态性的一种表现，子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

@Override是Java5的元数据，自动加上去的一个标志，告诉你说下面这个方法是从父类/接口 继承过来的，需要你重写一次，这样就可以方便你阅读，也不怕会忘记x0dx0a x0dx0a@Override是伪代码,表示重写(当然不写也可以),不过写上有如下好处: x0dx0a1>可以当注释用,方便阅读 x0dx0ax0dx0a2>编译器可以给你验证@Override下面的方法名是否是你父类中所有的,如果没有则报错 x0dx0ax0dx0a比如你如果没写@Override而你下面的方法名又写错了,这时你的编译器是可以通过的(它以为这个方法是你的子类中自己增加的方法)x0dx0a x0dx0a使用该标记是为了增强程序在编译时候的检查，如果该方法并不是一个覆盖父类的方法，在编译时编译器就会报告错误。 我只是大自然的搬运工。

override是方法的重写，通常发生在子类与父类之中，指的是子类中定义了一个与父类返回值类型，参数类型完全相同的方法overload是方法的重载，通常在同一个类中，定义了一堆方法名相同，但返回值可能不同，参数也可能不同的方法