java

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的功能的一种拓展.这个拓展可以使用,也可以不使用.希望可以帮到你.

用全路径名

一、在目前的代码中，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了，别说三个，一百个也是可以的

加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方法都直接可以生成

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) 这样调用

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

语法有误，你的move只是一个变量

setInterval(function(){ trans(msObj); },100);这样就可以了...IE和FF都能用..

try catch fillay

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

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

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

Java里的"@override"意思是什么? 有什么用? 这个用于重写父类方法用的 用这个注解可以避免方法名跟引数写错 @Override是Java5的元资料，自动加上去的一个标志，告诉下面这个方法是从父类/介面 继承过来的，需要重写一次，这样就可以方便阅读，也不怕会忘记。 @override是虚拟码,表示重写(当然不写也可以),不过写上有如下好处: 1.可以当注释用,方便阅读 2.编译器可以给你验证@Override下面的方法名是否是你父类中所有的,如果没有则报错 比如如果没写@Override而下面的方法名又写错了,这时编译器是可以通过的(它以为这个方法子类中自己增加的方法) "override"是什么意思 你好。override翻译成中文是：覆盖;推翻，无视;践踏;优先于;佣金;超驰控制装置;撤消，推翻。 ——————希望帮到你，满意请采纳。 "meet with"是什么意思，有什么用法 顺手采纳答案 meet with表示遇到，偶遇 [例句]Now I meet with fewer difficulties in my work. 现在我工作中困难少些了。 "Ruin"是什么意思，有什么用法 ruin 英[u02c8ru:u026an] 美[u02c8ruu026an] vt. 破坏，毁灭; 使破产; 使没落，使堕落; 变成废墟; n. 毁灭，灭亡; 废墟，遗迹; [灭亡] 的原因，祸根; 损失; vi. 破产; 被毁灭; 堕落; [例句]My wife was ruining her health through worry 忧虑严重损害了我妻子的健康。 [其他] 第三人称单数：ruins 复数：ruins 现在分词：ruining 过去式：ruined过去分词：ruined System.out.println("A="+A);中+A是什么意思，有什么用 "+"在两边都是数字时 就是运算子,其他则当做连字元使用 而System.out.println("A="+A)这里的A应该是个变数,"A="是个字串 所以这里的"+"是当做连字元使用的 @override是什么意思？有什么用啊啊？ 没什么用，这是你的IDE编辑器为你自动加上去的一个标志，告诉你说 下面这个方法是从父类/介面 继承过来的，需要你重写一次 这样就可以方便你阅读，也不怕会忘记 联通里的"玩伴号码"是什么意思呢?有什么用呢? 好像有猫腻,小心使用! 请问css中content: " ";是什么意思？有什么用？ content:after是CSs的违类，这个程式码是用来清除底部浮动的，比方说文章页面，由于文章页面的高度无法确认，他是随着文章的长度自动增长的，这个时候如果底部有其他的层这个时候就会出现上下错位的情况，#content:after 就可以用来清除上一层的浮动 这样就不会和下面的层发生位置错位，

　　javascript中的setInterval的函数主要是在制作动画或其他间隔性渲染（操作）效果时，对操作方法按照一定时间间隔进行调用的函数。　　用法：　　setInterval() 方法可按照指定的周期（以毫秒计）来调用函数或计算表达式。　　setInterval() 方法会不停地调用函数，直到 clearInterval() 被调用或窗口被关闭。由 setInterval() 返回的 ID 值可用作 clearInterval() 方法的参数。　　setInterval的表达式格式主要有：　　setInterval(fnname,time,par1,par2,........parn);　　setInterval(obj,fnname,time,par1,par2,......parn);　　第一种是最常见的表达语法，其中fnname参数可以是一个匿名函数的引用或者是一个函数名，time是设定的调用faname的时间间隔，单位为毫秒，默认值为10毫秒，par1.......parn为可选参数，是传递给faname方法的参数。　　第二种是使用对象方法的语法，faname参数是obj对象的方法，其他参数同第一种语法。

不会对运行有问题.除非你需要用到@override意思是什么? 有什么用?JAVA中 @Override 的作用如果想重写父类的方法，比如toString()方法的话，在方法前面加上@Override 系统可以帮你检查方法的正确性，@Overridepublic String toString(){...}这是正确的一旦写错 写成这样@Overridepublic String tostring(){...}编译器可以检测出这种写法是错误的 这样能保证你的确重写的方确而如果不加@Overridepublic String tostring(){...}这样编译器是不会报错的 它只会认为这是你自己新加的一个方法而已------------------------------------------------------------@Override的用法：Override：java.lang.Override是一个marker annotation类型，它被用作标注方法。它说明了被标注的方法重载了父类的方法，起到了断言的作用。如果我们使用了这种annotation在一个没有覆盖父类方法的方法时，java编译器将以一个编译错误来警示。这个annotaton常常在我们试图覆盖父类方法而确又写错了方法名时发挥威力。使用方法极其简单：在使用此annotation时只要在被修饰的方法前面加上@Override。下面的代码是一个使用@Override修饰一个企图重载父类的toString方法，而又存在拼写错误的sample：清单1：@Override public String toSting() { // 注意方法名拼写错了 return "[" + super.toString() + "]";}

override是方法（重写）重载，如果集成或者实现接口的方法功能不能满足，那么就可以对该方法进行重写

override是方法的重写，通常发生在子类与父类之中，指的是子类中定义了一个与父类返回值类型，参数类型完全相同的方法这个不是关键字！！子类重写父类的方法时可以加override，也可以不加但应该是@override

alt+/快捷键。你先打一个@符合，然后按那个alt+/快捷键，再输入一个开头ov。就能把override打出来。Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。

//@Override:覆盖(重写)父类中的一个方法。//下面有一个例子。//在你的类A中定义一个签名为//@Override//public boolean equals(Object obj)的方法就能重写（覆盖）Object类的同名方法了，//以后调用equals方法比较两个类A的对象的相等性时，就会调用你重写的方法了。//看例子。public class Demo{public static void main(String[] args){A a1=new A(1,"a"),a2=new A(1,"b"),a3=new A(1,"a");//调用类A的重写的equals方法比较3个对象的相等性//falseSystem.out.println(""+a1.equals(a2));//trueSystem.out.println(""+a1.equals(a3));//falseSystem.out.println(""+a2.equals(a3));}}class A{A(int n,char c){this.n=n;this.c=c;}//@Override可省略@Overridepublic boolean equals(Object obj){System.out.println("调用了重写的类A的equals方法。");boolean r=false;A a;if(obj instanceof A){a=(A)obj;r=(this.n==a.n && this.c==a.c);}return r;}private int n;private char c;}

1。进入公司后，首先要搞好人际关系，与同事，领导关系融洽2。第一条做到后，就要多看一些别人写的程序代码，与同事关系处好了，他们也就愿意帮助你，你的进步会很快的3。尽管熟悉自己的工作环境，掌握公司要求使用的编辑工具啊，学会编写技术文档以及公司自己开发的框架等，这是建立在第2条的基础上4。尽自己最大努力做好项目经理分配给自己的项目，把自己该做的任务做好，上面3条做到了，这个也自然水到渠成。5。上面都成功了，你就开始在这个公司站稳脚跟了

IE中设的代理，一般只对IE有效。称局部代理，要安装全局代理工具Proxifier后，设上代理参数，才能对其他程序（如FTP）有效。

csdn 比较全面

eclipse java oxygen使用：官方还没有出Oxygen的汉化包可以将就的先使用Neno的汉化包汉化一下亲测可以用只是没有那么汉化的理想后面Oxygen的汉化包出来后再换就可以了

强！！！楼上的够狠！我调一下，看能通过不！

1 获取本地字符集2 设置到font中

你说是的可能来自awt或swing中某个类的pack()函数吧？大致用来调整布局显示的~

很明显是写错了tostring是为了显示成字符串，所以就不应该有你说的那个代码正确的应该是publicstringtostring(){return"长方形：x="+x+";y="+y+" "+"area="+area();}}

Java中的一个包就是一个类库单元，包内包含有一组类，它们在单一的名称空间之下被组织在了一起。这个名称空间就是包名。可以使用import关键字来导入一个包。例如使用import java.util.*就可以导入名称空间java.util包里面的所有类。所谓导入这个包里面的所有类，就是在import声明这个包名以后，在接下来的程序中可以直接使用该包中的类。例如：[java] view plain copyimport java.util.* public class SingleImport { public static void main(Strin[] args) { ArrayList list=nwe ArrayList(); } } 这里ArrayList就是java.util包中的一个类，但是由于对程序使用了import关键字加载了java.util包，所以这里并没有见到对ArrayList类的定义和声明，也没有见到该类前面有什么限定名，就可以直接使用这个类。 我们之所以要导入包名，就是要提供一个管理名称空间的机制。我们知道，如果有两个类A类和B类都含有一个具有相同特征标记（参数列表）的方法f()，即便在同一段代码中同时使用这两个方法f()，也不会发生冲突，原因就在于有两个不同的类名罩在前面作为限定名，所以两个方法即便同名也不回发生冲突。但是如果类名称相互冲突又该怎么办呢？假设你编写了一个Apple类并安装到了一台机器上，而该机器上已经有一个其他人编写的Apple类，我们该如何解决呢？因为你如果想弄清楚一台机器上到底已经安装了那些类，并不是一件很容易的事情，所以名字之间总是有存在潜在的冲突的可能。在Java中对名称空间进行完全控制并为每个类创建唯一的标识符组合就成为了非常重要的事情。如果你要编写对于同一台机器上共存的其他Java程序友好的类库或程序的话，就需要考虑如何防止类名称之间的冲突问题。 当编写一个Java源代码文件时，此文件通常被称为编译单元。每个编译单元都必须有一个后缀名.java，而在编译单元内有且仅有一个public类，否则编译器就不会接受。该public类的名称必须与文件的名称相同（包括大小写，但不包括后缀名.java）。如果在该编译单元之中还有额外的类的话，那么在包之外的世界是无法看见这些类的，因为它们不是public类，而且它们主要用来为主public类提供支持。 当编译一个.java文件（即一个编译单元）时，在.java文件中的每个类都会有一个输出文件，而该输出文件的名称与.java文件中每个类的名称相同，只是多了一个后缀名.class。因此在编译少量.java文件之后，会得到大量的.class文件。每一个.java文件编译以后都会有一个public类，以及任意数量的非public类。因此每个.java文件都是一个构件，如果希望许许多多的这样的构件从属于同一个群组，就可以在每一个.java文件中使用关键字package。而这个群组就是一个类库。 如果使用package语句，它必须是.java文件中除注释以外的第一句程序代码。如果在文件的起始处写： package fruit;就表示你在声明该编译单元是名为fruit的类库的一部分，或者换句话说，你正在声明该编译单元中的public类名称是位于fruit名称的保护伞下，由fruit名称罩着。任何想要使用该public类名称的人都必须指定全名或者与fruit结合使用关键字import。 例如，假设文件的名称是Apple.java，这就意味着在该文件中有且仅有一个public类，该类的名称必须是Apple（注意大小写）：[java] view plain copypackage fruit; public class Apple { //... } 上面的代码已经将Apple类包含在了fruit包中，现在如果有人想使用Apple或者是fruit中的任何其他public类，就必须使用关键字import来使fruit中的名称可用。[java] view plain copyimport fruit.*; public class ImportApple { public static void main(String[] args) { Apple a=new Apple(); } } 或者使用完整限定名称：[java] view plain copypublic class QualifiedApple { public static void main(String[] args) { fruit.Apple a=new fruit.Apple(); } } 显然使用关键字import使代码更加简洁。 作为一名程序员，我们应该牢记：package和import关键字允许做的是将单一的全局名称空间分割成各自独立封闭的名称空间，使得无论多少人使用Internet以及Java开始编写类，都不会出现与我们的类名称相冲突的问题，因为我们的类是被封闭在我们自己定义的独立的名称空间里面的，而非在公共的全局名称空间里面。 到这里也许你会发现，其实所谓关键字package打包从未将被打包的东西包装成一个单一的文件，并且一个包可以由许多.class文件构成，这就存在将两个名称相同的类打进一个包中的可能。为了避免这种情况的发生，一种合乎逻辑的做法就是将特定的所有.class文件都置于一个目录下。也就是说利用操作系统的层次化的文件结构来解决这一问题。这是Java解决混乱问题的一种方式（这里暂且先不讨论JAR包工具）。 将所有的文件收入一个子目录还可以解决另外两个问题：一、怎样创建独一无二的名称；二、怎样查找有可能隐藏于目录结构中某处的类。 这些任务是通过将.class文件所在的路径位置编码称package的名称来实现的。 按照惯例，package名称的第一部分是类的创建者的反顺序的Internet域名。为什么要用Internet域名呢？因为如果你遵照惯例，Internet域名应该是独一无二的，因此你的package名称也将是独一无二的，也就是前面提到的我们自定义的独立封闭的名称空间将是独一无二的，这样就不会出现名称冲突的问题了。当然，如果你没有自己的域名，你就得构造一组不大可能与他人重复的组合（例如你的姓名），来创立独一无二的package名称。如果你打算发布你的Java程序代码，稍微花费些代价去取得一个域名还是很有必要的。 另外，如果你的Java程序代码只是在本地计算机上运行，你还可以把package名称分解为你机器上的一个目录。所以当Java程序运行并且需要加载.class文件的时候，它就可以根据package名称确定.class文件在目录上的所处位置。 程序在运行的时候具体是如何确定.class文件位置的呢？ 来看看Java解释器的运行过程吧：首先，找出环境变量CLASSPATH（可以通过操作系统来设置）。CLASSPATH包含一个或多个目录，用作查找.class文件的根目录。从根目录开始，解释器获取包名称并将每个句点替换成反斜杠，以从CLASSPATH根中产生一个路径（例如，package fruit.Apple就变成为fruit/Apple或fruit/Apple或其他，这将取决于操作系统）。得到的路径会与CLASSPATH中的各个不同的根目录路径相连接以获得一个完整的目录路径，解释器就在这些目录中查找与你所需要的类名称相同的.class文件。（此外，解释器还会去查找某些涉及Java解释器所在位置的标准目录。） 为了理解这一点，以域名Food.net为例。把它的顺序倒过来，并且全部转换为小写，net.food就成了我们创建类的一个独一无二的名称空间。如果我们决定再创建一个名为fruit的类库，我们可以将该名称进一步细分，于是得到一个包名如下： package net.food.fruit; 现在，这个包名称就可以用作下面Apple这个文件的名称空间保护伞了：[java] view plain copypackage net.food.fruit; public class Apple { public Apple() { System.out.println("net.food.fruit.Apple"); } } 这个文件可能被置于计算机系统中的如下目录中： C:/DOC/JavaT/net/food/fruit 之所以要放在这个目录下面是因为前面提到的，便于系统通过CLASSPATH环境变量来找到这个文件。沿着此路径往回看就能看到包名net.food.fruit，但是路径的前半部分怎么办呢？交给环境变量CLASSPATH吧，我们可以在计算机中将环境变量CLASSPATH设置如下： CHASSPATH=.;D:/JAVA/LIB;C:/DOC/JavaT CLASSPATH可以包含多个可供选择的查询路径。每个路径都用分号隔开，可以看到，上面这个CLASSPATH环境值的第三个路径就是我们前面文件的根目录。如前所述，Java解释器将首先找到这个根目录C:/DOC/JavaT，然后将其与包名net.food.fruit相连接，连接的时候将包名中的句点转换成斜杠，就得到完整的class文件路径C:/DOC/JavaT/net/food/fruit。 需要补充说明的一点，这里CLASSPATH环境变量关照的是package中的class文件，如果关照的是JAR包中的class文件，则会有一点变化，即，必须在CLASSPATH环境变量路径中将JAR文件的实际名称写清楚，而不仅仅是指明JAR包所在位置目录。可以想象，因为JAR包所在目录位置上可能存在很多别的JAR包，而我们需要使用的那个class文件只会存在于其中一个JAR包里面，因此可以这样理解，这里JAR包实际上也充当了一级文件目录的角色，因此要在CLASSPATH环境变量中写清楚JAR包文件名。例如如果Apple文件存在于名为fruit.jar的JAR文件中，则CLASSPATH应写作： CLASSPATH=.;D:/JAVA/LIB;C:/DOC/JavaT/net/food/fruit.jar 一旦路径得以正确建立，下面的文件就可以放于任何目录之下：[java] view plain copyimport net.food.fruit.*; public class LibTest { public static void main(String[] args) { Apple a=new Apple(); } } 当编译器碰到fruit库的import语句时，就开始在CLASSPATH所指定的目录中查找，查找过程中分别将CLASSPATH中设定的各项根目录与包名转换来的子目录net/food/fruit相连接，在连接后的完整目录中查找已编译的文件（即class文件）找出名称相符者（对Apple而言就是Apple.class）。找到了这个文件即匹配到了Apple类。

打包用的将不同的文件打到同一个包里

表明你的类放在哪一个文件夹中

当一个大型程序交由数个不同的程序人员开发时，用到相同的类名是很有可能的，那么如果发生了这样的事件我们该怎么办那？，在我们java程序开发中为了避免上述事件，提供了一个包的概念（package），那么既然有了这样一种方法能避免上述事件，那么我们怎样使用package那？，使用方法很简单我们只需要在我们写的程序第一行使用package关键字来声明一个包就行了，例如我们来声明一个名为pack1的包名，package pack1;好了下面我们就利用范例来说明package的使用方法，及其编译运行的方法，　假设我们在d盘下的新建一个文件（pack1），在pack1文件内包含两个java程序一个是Showmethod.java和Testshow.java；Showmethod.javapackage pack1;//在这里把Showmethod类纳入到pack1包内class Showmethod{ public void show(){ System.out.println("I"m a show method() of Showmethod class"); }}Testshow.java； package pack1;//在这里把Testshow类也纳入到pack1包内public class Testshow{ public static void main(String args[]){ Showmethod sm=new Showmethod(); sm.show(); }}下面我们就先来看一下如何编译这两个位于同一个包内的java程序，1:javac pack1Showmethod.java2:javac pack1Testshow.java这就是编译的方法　 pack1是包名，包名后面跟的就是我们要编译的那个类名，编译好后pack1目录下回声成两个class文件，运行方法：java pack1.Testshow注意运行时要指出包名，包名后有一个点＂．＂然后是类名， 2:下面我们来看一下如何访问不在同一个包内的类，在Ｄ盘分别建立pack1,pack2两个文件，建立好之后将Showmethod.java放到pack1包内，　　Showmethod.java的代码如下：package pack1;public class Showmethod{ public void show(){ System.out.println("I"m a show method() of Showmethod class"); }}　　将Testshow.java放到pack2包内Testshow.java的代码如下：package pack2;public class Testshow{ public static void main(String args[]){ pack1.Showmethod sm=new pack1.Showmethod(); sm.show(); }}由于此类需要调用位于pack1包中的Showmethod类的show方法，所以这里pack1.Showmethod sm=new pack1.Showmethod();这样写，我们还可以使用import 语句将pack1包内的Showmethod方法导入进来，这样这个地方pack1.Showmethod sm=new pack1.Showmethod();我们就可以这样写了Showmethod sm=new Showmethod（）；对于import我们下一范例进行说明，　还有一点我们必须注意，在访问不同　package里的类时，被访问的类必须被声明为public（就是公有类型的），否则在编译回报告错误，　编译方法＂１javac pack1Showmethod.java2: javac pack2Testshow.java编译好之后pack1,pack2目录下回分别产声一个．class文件，运行方法：java pack2.Testshow

这是乌龟的屁股 ：规定（龟腚）A 是正确的标准的B 明显缺斤少两C 脱了裤子放屁 只要后面那一句就可以了D Package的作用就是把若干类按包结构进行分类管理。其中最重要的用途是为了解决同名但作用不同的类同时存在的问题。一定是放第一句的这是编程习惯

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。包的作用1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。详情见：http://www.runoob.com/java/java-package.html######

package是包，包里面是装类文件的。

package是java语言所特有的。他的作用就是把若干类按包结构进行分类管理。其中最重要的用途是为了解决同名但作用不同的类同时存在的问题。假如有一个类叫：ClassA，目前该类已经在程序中使用，由于某些原因还需要创建一个名为ClassA的类，用于实现其他功能（但又不能把两个类的内容和并）。此时就会出现类的管理上的问题。通过引入package这种概念，可以区分出这两个类，虽然他们名字相同，但package不同，所以可以区分出两个类

package的作用有:创建你自己的程序库集(注意要创建独一无二的包名)如:packagecom.mypackage.simple;publicclassMyClass{.....经过长期的编程实践,com.mypackage.simple包里的pulic类会越来越多,如果有人想有MyClass或者是com.mypackage.simple中的任何其他pulic类,可以使用关键字import来加载包名.

public class TestPoint { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub MyPoint mp = new MyPoint(); mp.setStart(new Point(10,10)); mp.setEnd(new Point(20,20)); System.out.println(mp.getStart()); System.out.println(mp.getEnd()); }}class Point{ @Override public String toString() { // TODO Auto-generated method stub return "x: "+x + " y: "+y; } private int x; private int y; 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 Point(int x, int y) { super(); this.x = x; this.y = y; }}class MyPoint{ private Point start; private Point end; public Point getStart() { return start; } public void setStart(Point start) { this.start = start; } public Point getEnd() { return end; } public void setEnd(Point end) { this.end = end; } public MyPoint(){ } public MyPoint(Point start, Point end) { super(); this.start = start; this.end = end; }}