第1个回答 2009-07-08
1 源文件 .java 编译后 .class
2 int i=0 float i=0.1 double i=0.1 string i="ss" char i='c' byte i =1
short i=1 long i=1 boolean i=TRUE
3 string s1="asd" string s2=new string("dsa") 生命s1的方法 比另一个更快
4 int i = Integer.parseInt(s1）
5 1 () [] .
2 ! +(正) -(负) ~ ++ --
3 * / %
4 +(加) -(减)
5 << >> >>>
6 < <= > >= instanceof
7 == !=
8 &(按位与)
9 ^
10 |
11 &&
12 ||
13 ?:
14 = += -= *= /= %= &= |= ^= ~= <<= >>= >>>=
6 public class Test{
int m=0;
for(int i=1;i<=100;i++){
for(int int j=1;j<=i/2;j++){
if(i%j == 0)
m++;
}
if(m == 2){
System.out.print(i+",");
}
m=0;
}
}
7class 类名{} 与 public class 类名{} 返回类型 方法名 （参数列表）
8 同 都是变量 异 作用域
9 名子与类名相同的方法 创建对象时执行
10 同空间下 名字相同 参数列表不同的方法
11 子类继承父类所有特性 先执行父类的无参数构造 然后执行子类构造 如果父类没有无参构造 必须在子类的构造里调用父类有参数构造 否则报错
累了 有机会再说把
第2个回答 2009-07-09
1、java的编译和运行。源文件和字节码的扩展名
Java的编译（javac Java文件名）、Java的运行（java 含有main方法的类名）
源文件扩展名（.java）、字节码的扩展名（.class）
2、java中的常用基本数据类型的定义和赋值
byte -- 8-bit signed two's-complement integers
short -- 16-bit signed two's-complement integers
char -- 16-bit unsigned integers
int -- 32-bit signed two's-complement integers
long -- 64-bit signed two's-complement integers
float -- 32-bit IEEE 754 floating-point numbers
double -- 64-bit IEEE 754 floating-point numbers
boolean -- true and false
3、String类型赋值的两种方法，以及它们是区别
String s = "Hello";
String s = new String("Hello");
第一种方法只生成一个"Hello"对象，存在于String Pool中，第二种方法生成两个"Hello"对象，分别存在于String Pool和堆(Heap)中。
4、String类型和其它类型的转换
以int和String之间的转换为例，其他类似：
int -> String String s = 5 + "";
String -> int int n = Integer.parseInt("5");
5、java的运算符优先级
优先级 运算符 结合性
1 () [] . 从左到右
2 ! +(正) -(负) ~ ++ -- 从右向左
3 * / % 从左向右
4 +(加) -(减) 从左向右
5 << >> >>> 从左向右
6 < <= > >= instanceof 从左向右
7 == != 从左向右
8 &(按位与) 从左向右
9 ^ 从左向右
10 | 从左向右
11 && 从左向右
12 || 从左向右
13 ?: 从右向左
14 = += -= *= /= %= &= |= ^= ~= <<= >>= >>>= 从右向左
6、输出1-100之间的所有素数
public class ForPrime {
public static void main(String[] args) {
for (int i = 2; i < 100; i++) {
if (isPrime((long) i)) {
System.out.println(" isPrime = " + i);
}
}
}
static boolean isPrime(long num) {
double intSqrtOfNum = Math.sqrt((double) num);
int i = 0;
for (i = 2; i < intSqrtOfNum; i++) {
if (num % i == 0)
break;
}
if (i > intSqrtOfNum) {
return true;
}
return false;
}
}
7、类的定义，方法定义
类的定义：一个java文件只可以包含一个public类，不可有多个public，就是如果类声明成public，那么这个java文件的名字要和类名一致，一个java文件可以包含一个public类和多个非public类。
方法的定义：一个方法包括5个部分，访问权限,返回类型,方法名,参数列表,方法体。
8、成员变量和局部变量的异同
1).成员变量可以被public，protect，private，static等修饰符修饰，而局部变量不能被控制修饰符及static修饰；两者都可以定义成final型；
2).成员变量存储在堆，局部变量存储在栈；
3).存在时间不同；
4).成员变量有默认值，（被final修饰且没有static的必须显式赋值），局部变量不会自动赋值 。
9、构造方法的定义和执行
构造方法是一种特殊的方法，与一般的方法不同是：
1).构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有。
2).构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象。
3).不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承。
构造方法可以被重载。没有参数的构造方法称为默认构造方法，与一般的方法一样，构造方法可以进行任何活动，但是经常将他设计为进行各种初始化活动，比如初始化对象的属性。
在Java中,任何变量在被使用前都必须先设置初值.Java提供了为类的成员变量赋初值的专门功能：构造方法(constructor)构造方法是一种特殊的成员方法吗，它的特殊性反映在如下几个方面：
(1)构造方法名与类名相同。
(2)构造方法不返回任何值，也没有返回类型。
(3)每个类可以有零个或多个构造方法。
(4)构造方法在创建对象时自动执行，一般不能显式地直接调用。
10、方法的重载
方法重载是让类以统一的方式处理不同类型数据的一种手段。Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法, 这就是多态性。
注意，Java的方法重载要求同名的方法必须有不同的参数表，仅有返回类型不同是不足以区分两个重载的方法。
方法重载:1.方法名一定要相同。
2.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。
(1).如果参数个数不同，就不管它的参数类型了！
(2).如果参数个数相同，那么参数的类型或者参数的顺序必须不同。
3.方法的返回类型、修饰符可以相同，也可不同。
11、类的继承，构造方法的继承和执行顺序、方法的覆盖
累的继承：1.面向对象最重要的特点之一，就是可以实现对类的复用。
2.通过“继承”一个现有的类，可以使用已经定义的类中的方法和变量。
3.类的方法和属性可以被继承，但是类的构造器不能被继承。
4.在Java中，一个类只能继承继承一个父类，这种方式叫做单继承。这一点和C++不一样。
5.java.lang.Object类是所有类的父类
虽然一个类只可以继承一个父类，但是一个父类却可以被多个子类所继承。
从子类的角度看，它是“继承（extends）”父类；而从父类的角度看，它是“派生（derive）”子类。它们指的都是同一个动作，只是角度不同而已。
构造方法的继承和执行顺序：1.父类的构造方法不能被子类所继承，必须为一个子类定义构造方法，或者使用缺省的构造方法。
2.子类要完成父类继承属性的初始化，必须要调用父类的构造方法。可使用super()显式地调用父类的构造方法。
3.子类调用父类构造方法的意义在于，初始化父类的成员变量。
4.如果子类没有定义构造方法，系统会默认地添加一个无参的构造方法,并在第一句自动调用父类不带参数的构造方法super()。
方法的覆盖：1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
12、多态性
多态性：发送消息给某个对象，让该对象自行决定响应何种行为。
通过将子类对象引用赋值给超类对象变量, 来实现动态方法调用。
java 的这种机制遵循一个原则：当超类对象引用变量, 引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。
1. 如果a是类A的一个引用，那么，a可以指向类A的一个实例,或者说指向类A的一个子类。
2. 如果a是接口A的一个引用，那么,a必须指向实现了接口A的一个类的实例。
13、抽象类的定义，抽象方法的定义
1.定义抽象类要在类定义前加abstract;
2.定义抽象方法要在方法定义前加abstract;
3.一个规则:抽象类中至少有一个抽象方法.
14、接口的定义，接口中的方法定义
1. 接口中可以定义变量
2. 接口中的方法不需要加abstract，因为接口的定位就是给其他类（包括抽象类）实现的。
15、抽象类和接口的异同
1.abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。
2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。
3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。
4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。
5.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。
6.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。
7.接口中的方法默认都是 public,abstract 类型的。
16、public private protected 无 访问权限
默认访问权限没有任何关键字，但通常是指包访问权限。如果一个成员（类，成员方法，成员数据）没有任何权限修饰词来修饰，则它具有的是包访问权限；这意味着当前包中的所有其他类对这个成员都有访问权限，但对于这个包之外的所有类，这个成员却是private。
public: 接口访问权限——使用关键字public，就意味着public之后紧跟着的成员声明自己对每个人都是可用的。
private: 你无法访问——使用private关键字，就意味着除了包含该成员的类之外，其他任何类都无法访问这个成员。
protected: 继承访问权限——使用protected关键字，意味着派生类可以访问基类的protected成员，非派生类则没有这样的权限。protected也提供包访问权限，相同包内的其他类可以访问protected成员。
17、成员内部类的定义和使用
成员内部类可用修饰符public和private,protected,作为外部类的一个成员存在，与外部类的属性、方法并列.
成员内部类中，不能定义静态成员.
成员内部类中，可以访问外部类的所有成员.
内部类和外部类的实例变量可以共存.
在内部类中访问内部类自己的变量直接用变量名.或者用this.变量名
在内部类中访问外部类中与内部类同名的实例变量用 外部类名.this.变量名.如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
外部类的非静态方法中访问成员内部类
public void outer_f3(){
Inner inner = new Inner();
inner.inner_f1();
}
外部类的静态方法中访问成员内部类
public static void outer_f4(){
//建立外部类对象
Outer out = new Outer();
//根据外部类对象建立内部类对象
Inner inner = out.new Inner();
//访问内部类的方法
inner.inner_f1();
}
在外部类外部访问成员内部类
public void outer_outer(){
//建立外部类对象
Outer out = new Outer();
//根据外部类对象建立内部类对象,定义时要用:外部类名.内部类名
Outer.Inner inner = out.new Inner();
//访问内部类的方法
inner.inner_f1();
}
18、final关键字的使用
final修饰符可以使类、方法和变量保持“终态”，对程序的保护有着特殊的作用。但请注意一旦使用了final修饰符就不能再企图改变。
19、GUI编程的几个步骤
1.选择容器；
2.设置布局方式；
3.添加组件。
回答者： Don_Yummy - 试用期 一级 2009-7-8 04:15
检举
1、Java源文件扩展名：.java
2、byte short int long是四中基本数据类型
int a = 0; byte a = 0; short i = 0; long i = 0
string double Boolean 扩展类型
string s = "123"; double db = 1.01f(双精度浮点型);或者 doubledb = 1.0(单精度浮点型小数)
3、string s = new string("123"), string s = "123";
4、 int i = Integer.parseInt(s）;
5、数学运算符按照优先级划分为：% （* /）*= （+ - += -= ）
逻辑运算符按照有限计划分为 && || ！= ==
6、public class Leijia
{
public static void main(String args[])
{
int a,b,i=0 ;
for(a=1;a<=100;a++)
{for(b=2;b<=a/2;b++)
{if(a%b==0)
break;
}
if(b>a/2)
i++;
}
System.out.println(i) ;
}
}
7、类的定义：一个java文件只可以包含一个public类，不可有多个public，就是如果类声明成public，那么这个java文件的名字要和类名一致，一个java文件可以包含一个public类和多个非public类。
方法的定义：一个方法包括5个部分，访问权限,返回类型,方法名,参数列表,方法体。
这么多问题会回答不过来了
<---强人。。。