基于《java2实用教程》的java知识点复习整理【 归纳总结篇】
第1章 Java入门
1. 开发与运行Java程序需要经过哪些主要步骤和过程？
答：（1）编写Java源文件:使用文本编辑器（Edit或记事本），拓展名为.java
（2）编译Java源文件:使用Java编译器（javac.exe）。得到字节码文件*.class
（3）运行Java程序:Java应用程序使用Java解释器（java.exe）执行字节码文件；
Java小应用程序使用支持Java标准的浏览器来执行。
2. 怎样区分应用程序和小应用程序？应用程序的主类或小应用程序的主类必须用public修饰吗？
答： ①应用程序必须有main方法，这个方法是程序执行的入口。
小应用程序没有main方法。
②应用程序的主类不一定用public修饰；小应用程序的主类必须用public修饰。
3. Java程序是由什么组成的？一个程序中必须要有public类吗？Java源文件的命名规则是怎样的？
答： ①Java程序由类组成。
②应用程序可以没有public类；小应用程序一定有一个类是public类（主类）。
③应用程序:如果只有一个类，源文件名与该类的类名相同，拓展名为.java；
有多个类时，如果有public类（最多一个）,源文件名与public类的类
名相同，拓展名是.java；没有public类，源文件名与任何一个类的类名
相同即可，拓展名为.java。
小应用程序:源文件名与主类的类名相同，拓展名是.java。
4. 在运行小程序的HTML文件中可以使用codebase属性指定小程序的字节码所驻留的目录。如果不使用codebase属性，小程序的字节码文件必须和运行它的HTML文件在同一目录中。编写一个小程序并将小程序的字节码存放在某个目录中，比如C:\5000；把运行该小程序的HTML文件（注意其中的codebase属性）:
<applet code=你的小程序的字节码 width=200 height=300 codebase=C:\5000>
</applet>
存放在另一个目录中。
答： 以书中小应用程序为例进行说明:
①编写Java小应用程序源代码
import java.applet.*;
import java.awt.*;
public class Boy extends Applet
{
public void paint(Graphics g)
{
g.setColor(Color.red);
g.drawString("我一边喝着咖啡，一边学Java呢",5,30);
g.setColor(Color.blue);
g.drawString("我学得很认真",10,50);
}
}
②将上述代码命名为Boy.java并进行编译得到Boy.class字节码文件；将得到的字节码文件存放在
C:\5000文件夹下；
③编写小应用程序的HTML源文件:
<applet code=Boy.class wdith=200 height=300 codebase=C:\5000> </applet>
④将上述编写好的代码命名为Boy.html；并将此文件存放在C:\5000文件夹以外的任意一个文件夹中（如C:\1000）；
⑤运行Boy.html。
第2章 标识符、关键字和数据类型
1. 什么叫标识符？标识符的规则是什么？
答：①用来标识类名、变量名、、方法名、类型名、数组名、文件名的有效字符序列。
②由字母、下划线、美元符号和数字组成，并且第一个字符不能是数字字符，而且关键字不能作为标识符。
2. 什么叫关键字？请说出5个关键字。
答：①Java语言中已经被赋予特定意义的一些单词。
②class break public return static extends等。
3. Java的基本数据类型都是什么？
答：boolean(逻辑型) char(字符型) float、double(浮点型) byte、short、int、long(整型)。
4. 下列哪些语句是错误的:
int x = 8;
byte b = 127;
b = x;
答:b=x语句错误；原因是高级别的变量赋值给低级别的变量时,一定要用显式转换即b=(byte)x; 。
5. 下列程序的输出结果是什么？
public class E
{
public static void main(String args[])
{
long[] a={1,2,3,4};
long[] b={100,200,300,400,500};
b=a;
System.out.println("数组b的长度:"+b.length);
System.out.println("b[0]="+b[0]);
}
}
答: 数组b的长度:4
b[0]=1
7. System.out.println(“你好”)；可输出字符串，也可以使用System.out.println( )输出变量或表达式的值，只需使用并置符号“+”将变量、表达式或一个常数值与一个字符串并置即可，如: System.out.println(“ ”+x)；System.out.println(“:”+123+“大于”+122)；等。上机调试下列程序，注意观察结果，特别注意System.out.print( )和System.out.println( )的区别。
public class OutputData
{
public static void main(String args[])
{
int x=234,y=432;
System.out.println(x+"<"+(2*x));
System.out.print("我输出结果后不回车");
System.out.println("我输出结果后自动回车到下一行");
System.out.println("x+y= "+(x+y));
System.out.println(" "+x+y+"=234432");
}
}
答: 234<468
我输出结果后不回车我输出结果后自动回车到下一行
x+y= 666
234432=234432
8.一个简单的JAVA程序
答:
public class E
{
public static void main(String args[])
{System .out .println("这是我的第一个程序");}
}
编写一个Java应用程序，输出全部的希腊字母。
public class Hello {
public static void main(String[] args) {
char a='α',b='ω';
System.out.print("全部的希腊字母为:");
for(;a<=b;a++) {
System.out.print(a+" ");
}
}
}
第3章 运算符、表达式和语句
1. 下列程序的输出结果是什么？
public class E
{
public static void main(String args[])
{
char x='你',y='e',z='吃';
if(x>'A')
{
y='爱';
z='情';
}
else
y='我';
z='她';
System.out.println(" "+x+y+z);
}
}
答: 你爱她
2. 下列程序的输出结果是什么？
public class E3
{
public static void main(String args[])
{
char c='\0';
for(int i=1;i<=4;i++)
{
switch(i)
{
case 1:c='b';
System.out.print(c);
case 2:c='e';
System.out.print(c);
break;
case 3:c='p';
System.out.print(c);
default:
System.out.print("!");
}
}
}
}
答:beep！！
3. 编写应用程序，求1！+2！+…+10！。
答:
class Fact
{
public static void main(String args[])
{
int fact,sum=0;
for(int i=1;i<=10;i++)
{
fact=1;
for(int j=1;j<=i;j++)
fact*=j;
sum+=fact;
}
System.out.println("1到10的阶乘之和是:"+sum);
}
}
4. 编写一个应用程序，求100以内的全部素数。
答:
class Primes
{
public static void main(String args[])
{
int w=1;
for(int i=2;i<=100;i++)
{
for(int j=2;j<i;j++)
{
w=i%j;
if(w==0)
break;
}
if(w!=0)
System.out.println(i+"是素数");
}
}
}
5. 分别用do―while和for循环计算1+1/2！+1/3！+1/4！+…的前20项和。
答: ①for循环
class Sum
{
public static void main(String args[])
{
int fact;
double sum=0;
for(int i=1;i<=20;i++)
{
fact=1;
for(int j=1;j<=i;j++)
fact*=j;
sum+=1.0/fact;
}
System.out.println(sum);
}
}
②do―while循环
class Sum
{
public static void main(String args[])
{
int i=1;
int fact;
double sum=0;
do
{
fact=1;
int j=0;
while(++j<=i)
fact*=j;
sum+=1.0/fact;
}
while(++i<=20);
System.out.println(sum);
}
}
6. 一个数如果恰好等于它的因子之和，这个数就称为“完数”。编写应用程序，求1000之内的所有完数。
答:
class Wanshu
{
public static void main(String args[])
{
int x,i,sum;
for(x=1;x<=1000;x++)
{
sum=0;
for(i=1;i<x;i++)
{
if(x%i==0)
sum+=i;
}
if(x==sum)
System.out.println(x+"是完数");
}
}
}
7. 编写应用程序，分别使用while和for循环计算8+88+888+…前10项之和。
答: ①for循环
class TheSum
{
public static void main(String args[])
{
long sum=0,data=8;
for(int i=1;i<=10;i++)
{
sum=sum+data;
data=data*10+8;
}
System.out.println(sum);
}
}
②while循环
class TheSum
{
public static void main(String args[])
{
long sum=0,data=8,i=0;
while(++i<=10)
{
sum=sum+data;
data=data*10+8;
}
System.out.println(sum);
}
}
8. 编写应用程序，输出满足1+2+3+…+n<8888的最大正整数n。
答:
class Maxn
{
public static void main(String args[])
{
int k=1,sum=0;
while((sum+=k)<8888)
k++;
k--;
System.out.println("最大能取到:"+k);
}
}
第4章 类、对象和接口
1. 类中的实例变量在什么时候会被分配内存空间？
答: 当该类创建对象之后，实例变量才会被分配相应的内存空间。
2. 什么叫方法的重载？构造方法可以重载吗？
答:①一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同（方法的重载体现了多态性，即功能多态性）。
②构造方法可以重载。
3. 类中的实例方法可以操作类变量(static变量)吗？类方法(static方法)可以操作实例变量吗？
答:①类中的实例方法可以操作类变量。
②类方法不可以操作实例变量
4. 类中的实例方法可以用类名直接调用吗？
答: 类中的实例方法不可以用类名直接调用。
5. 举例说明protected方法和友好方法的区别。
答: 当子类与父类不在同一个包中时，子类可以继承父类的protected方法；而友好方法此时则不能被子类继承。
6. 举例说明类变量和实例变量的区别。
答:⑴书写: 定义成员变量时，类变量有static修饰；实例变量没有static修饰。
例: class A
{
int x; //实例变量
static int y; //类变量
}
⑵内存: 不创建对象，类的实例变量不会被分配内存空间；类变量被分配相应的内存空间。
不同对象的实例变量被分配不同的内存空间；不同对象的类变量被分配相同的内存空间。
任何一个对象改变类变量，其他对象的相应类变量也发生相应变化。
一个对象的实例变量发生改变，不影响其他对象的相应实例变量。
例: 执行语句： A1.x=10; A1.y=20;
这时A2.x的值也是10；而A2.y的值保持原来的初值。
⑶使用: 类变量可以被类方法操作；而实例变量不能被类方法操作。
例： class A
{
int x;
static int y;
static void func()
{
b=10; //合法
a=20; //非法
}
}
类变量可以通过类名访问；实例变量不能通过类名访问。
例: class A
{
int x;
static int y;
}
class B
{
public void func();
{
A.x=10; //非法
A.y=20; //合法
}
}
7. 子类将继承父类的哪些成员变量和方法？子类在什么情况下隐藏父类的成员变量和方法？在子类中是否允许有一个方法和父类的方法名字相同，而类型不同？
答:①子类和父类在同一个包中时，子类可以继承父类的除private属性的所有方法和成员变量，当子类与
父类不在同一个包中时，子类只能继承父类的protected和public属性的成员变量和方法。
②子类中定义的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量；子类中定义一个方法，并且这个方法的名字、返回类型、参数个数和类型与从父类继承的方法完全相同，子类就隐藏从父类继承来的方法（方法的重写）。
③在子类中允许有一个方法和父类的方法名字相同而类型不同。
8. 父类的final方法可以被子类重写吗？
答: 父类的final方法不能被子类重写。
9. 什么类中可以有abstract方法？
答: abstract类中可以有abstract方法。
10.什么叫对象的上转型对象？
答: B类是A类的子类或间接子类，当用子类B创建一个对象b并把这个对象的引用放到A类的对象a中时，称A类对象a是子类对象b的上转型对象。
11.什么叫接口的回调？
答: 可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中。
12.下列程序有什么错误？
public class Takecare
{
int a=90;
static float b=10.98f;
public static void main(String args[])
{
float c=a+b;
System.out.println("c="+c);
}
}
答: 语句float c=a+b;错误。原因是类方法main操作了实例变量a。
13. 请写出下列程序的输出结果。
class A
{
public int f(int x)
{
return x+1;
}
}
class B extends A
{
public int f(int x)
{
return x*x;
}
}
public class E
{
public static void main(String args[])
{
A a=new B();
int m=a.f(10);
System.out.println(m);
}
}
答: 100
14. 请写出下列程序的输出结果。
class A
{
int x;
public void setX(int x)
{
this.x=x;
}
int getX()
{
return x;
}
}
class B
{
public void f(A a)
{
a.setX(100);
}
}
public class E
{
public static void main(String args[])
{
A a=new A();
a.setX(8);
System.out.println(a.getX());
B b=new B();
b.f(a);
System.out.println(a.getX());
}
}
答: 8
100
15.使用接口有哪些注意事项？模仿例子4.27，编写一个类实现两个接口的程序。
答:①一个类使用接口时，要有implements关键字，当一个类使用多个接口时，接口名要用逗号“，”隔开；使用接口的类除abstract类外，必须实现接口的所有方法，并且实现接口的方法时，方法名字、返回类型、参数个数及类型必须与接口中的完全一致；类在实现接口时，方法体一定要用public修饰，如果接口方法的返回类型不是void型，在类中实现接口时，方法体至少有一个return语句。
② interface 表面积
{
double allArea(double r);
}
interface 体积
{
double volu(double r);
}
class Sph implements 表面积,体积
{
double PI=3.14159;
public double allArea(double r)
{
return 4*PI*r*r;
}
public double volu(double r)
{
return 4.0/3*PI*r*r*r;
}
}
public class Test
{
public static void main(String args[])
{
double r=5.0;
Sph a=new Sph();
System.out.println("半径为5的球的表面积是:"+a.allArea(r));
System.out.println("半径为5的球的体积是:"+a.volu(r));
}
}
16.编写一个类A，该类创建的对象可以调用方法f输出英文字母表，然后再编写一个该类的子类B，要求子类B必须继承A类的方法f(不允许重写)，子类创建的对象不仅可以调用方法f输出英文字母表，而且调用子类新增的方法g输出希腊字母表。
答: class A
{
int m;
void f()
{
for(m=65;m<91;m++)
System.out.print((char)m+" ");
for(m=97;m<123;m++)
System.out.print((char)m+" ");
System.out.println(" ");
}
}
class B extends A
{
int i;
void g()
{
for(i=913;i<930;i++)
System.out.print((char)i+" ");
for(i=931;i<938;i++)
System.out.print((char)i+" ");
for(i=945;i<962;i++)
System.out.print((char)i+" ");
for(i=963;i<970;i++)
System.out.print((char)i+" ");
System.out.println(" ");
}
}
public class Test
{
public static void main(String args[])
{
B b=new B();
System.out.println("我调用方法f输出英文字母表:");
b.f();
System.out.println("我调用方法g输出希腊字母表:");
b.g();
}
}
17.编写一个异常类MyException，再编写一个类Student，该类有一个产生异常的方法public void speak(int m) throws MyException，要求参数m的值大于1000时，方法抛出一个MyException对象。最后编写主类，在主类的main方法中用Student创建一个对象，让该对象调用speak方法。
答: class MyException extends Exception
{
String str1;
MyException(int m)
{
str1=m+"出现错误 可能造成的原因是取值大于1000";
}
public void showStr1()
{
System.out.println(str1);
}
}
class Student
{
public void speak(int m) throws MyException
{
if(m>1000)
{
MyException exception=new MyException(m);
throw exception;
}
else
System.out.println(m);
}
}
public class Test
{
public static void main(String agrs[])
{
int m;
Student stu1=new Student();
m=987;
try
{
stu1.speak(m);
m=1234;
stu1.speak(m);
}
catch(MyException e)
{
e.showStr1();
}
}
}
18.编写一个类，该类有一个方法public int f(int a,int b)，该方法返回a和b的最大公约数。然后再编写一个该类的子类，要求子类重写方法f，而且重写的方法将返回a和b的最小公倍数。要求在重写的方法的方法体中首先调用被隐藏的方法返回a和b的最大公约数m，然后将乘积(a*b)/m返回。要求在应用程序的主类中分别使用父类和子类创建对象，并分别调用方法f计算两个正整数的最大公约数和最小公倍数。
答: class A
{
public int f(int a,int b)
{
if(a<b)
{
int temp=0;
temp=a;
a=b;
b=temp;
}
int r=a%b;
while(r!=0)
{
a=b;
b=r;
r=a%b;
}
return b;
}
}
class B extends A
{
public int f(int a,int b)
{
int m;
m=super.f(a,b);
return (a*b)/m;
}
}
public class Test
{
public static void main(String args[])
{
A a=new A();
System.out.println("18和102的最大公约数是:"+a.f(18,102));
B b=new B();
System.out.println("18和102的最小公倍数是:"+b.f(18,102));
}
}
第5章 字符串
1. 使用String类的public String toUpperCase()方法可以将一个字符串中的小写字母变成大写字母，使用public String toLowerCase()方法可以将一个字符串中的大写字母变成小写字母。编写一个程序，使用这两个方法实现大小写的转换。
答: class Test
{
public static void main(String args[])
{
String str="I can use Java";
System.out.println("要转换的字符串是:"+str);
String s=str.toUpperCase();
System.out.println("转换成大写字符串是:"+s);
s=str.toLowerCase();
System.out.println("转换成小写字符串是:"+s);
}
}
2. 使用String类的public String concat(String str)方法可以把调用该方法的字符串与参数指定的字符串连接，把str指定的串连接到当前串的尾部获得一个新的串。编写一个程序通过连接两个串得到一个新串，并输出这个新串。
答: class Test
{
public static void main(String args[])
{
String str1="I can u";
String str2="se Java";
String s=str1.concat(str2);
System.out.println("将字符串"+str1+"与字符串"+str2+"连接后得到的新字符串是:");
System.out.println(s);
}
}
3. String类的public char charAt(int index)方法可以得到当前字符串index位置上的一个字符。说出下列程序的输出结果。
public class E3
{
public static void main(String args[])
{
String s="中国科学技术大学";
char a=s.charAt(2),b=s.charAt(6);
System.out.print(a);
System.out.println(b);
}
}
答: 科大
4. 使用java.util包中的Arrays类的静态方法public static void sort(double a[])可以把参数a指定的double型数组按升序排序，使用java.util包中的Arrays类的静态方法public static void sort(double a[],int start,int end)可以把参数a指定的double型数组中从位置start到end-1位置的数按升序排序。写出下列程序的输出结果。
import java.util.*;
public class E4
{
public static void main(String args[])
{
int a[]={23,67,89,90,-987};
double b[]={12.89,90.87,34,678.987,-98.78,0.89};
Arrays.sort(a);
Arrays.sort(b,1,4);
for(int i=0;i<=4;i++)
{
System.out.print(a[i]+",");
}
for(int i=0;i<b.length;i++)
{
System.out.print(b[i]+",");
}
}
}
答: -987,23,67,89,90,12.89,34.0,90.87,678.987,-98.78,0.89,
5. 使用java.lang包中System类的静态方法arraycopy可以实现数组的快速复制，上机实习下列程序，并总结出arraycopy方法参数的使用规则。
public class ArrayCopy
{
public static void main(String args[])
{
char a1[]={'a','b','c','d','e','f'},b1[]={'1','2','3','4','5','6'};
System.arraycopy(a1,0,b1,1,a1.length-1);
System.out.println(new String(a1));
System.out.println(new String(b1));
byte a2[]={97,98,99,100,101,102},b2[]={65,67,68,69,70,71};
System.arraycopy(b2,0,a2,3,b2.length-3);
System.out.println(new String(a2));
System.out.println(new String(b2));
}
}
答:①运行结果:abcdef
1abcde
abcACD
ACDEFG
②arraycopy的方法是public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)。其中五个参数分别表示:
src - 被复制的数组
srcPos - 从第几个元素开始复制
dest - 要复制到的数组
destPos - 从第几个元素开始粘贴
length - 一共需要复制的元素个数
第6章 时间、日期和数字
1. 用Data类不带参数的构造方法创建日期，要求日期的输出格式是:星期 小时 分 秒。
答: import java.util.*;
import java.text.*;
class Test
{
public static void main(String args[])
{
Date 时间=new Date();
SimpleDateFormat s=new SimpleDateFormat("E HH时 mm分 ss秒");
System.out.println(s.format(时间));
}
}
2. 输出2006年2月的日历页，程序需处理闰年问题。
答: import java.util.*;
class Test
{
public static void main(String args[])
{
int year=2006,month=2;
int allDay;
if((year%4==0&&year%100!=0)||(year%400==0))
allDay=29;
else
allDay=28;
Calendar feb=Calendar.getInstance();
feb.set(2006,1,1);
int dat=feb.get(Calendar.DAY_OF_WEEK)-1;
String a[]=new String[dat+allDay];
for(int i=0;i<dat;i++)
{
a[i]=" ";
}
for(int i=dat,n=1;i<(dat+allDay);i++)
{
if(n<=9)
a[i]=String.valueOf(n)+" ";
else
a[i]=String.valueOf(n)+" ";
n++;
}
System.out.println(" "+year+" 年 "+month+"月");
System.out.println("日 一 二 三 四 五 六");
for(int j=0;j<a.length;j++)
{
if(j%7==0)
{
System.out.println(" ");
}
System.out.print(a[j]);
}
}
}
3. 计算某年、某月、某日和某年、某月、某日之间的天数间隔。要求年、月、日通过main方法的参数传递到程序中。
答: import java.util.*;
class Test
{
public static void main(String args[])
{
Calendar c=Calendar.getInstance();
c.set(2000,0,1);
long time1=c.getTimeInMillis();
c.set(2008,7,8);
long time2=c.getTimeInMillis();
long dayCous=(time2-time1)/(1000*60*60*24);
System.out.println("2008年8月8日和2000年1月1日相隔"+dayCous+"天");
}
}
4. 编程练习 Math类的常用方法。
答: import java.text.*;
public class Test
{
public static void main(String args[])
{
double a=Math.abs(-10);
System.out.println("-10的绝对值是:"+a);
double maxNum=Math.max(123.456,-5.4321);
System.out.println("123.456与-5.4321中的最大值是:"+maxNum);
double minNum=Math.min(123.456,-5.4321);
System.out.println("123.456与-5.4321中的最小值是:"+minNum);
int randomNum=(int)(Math.random()*10)+1;
System.out.println("输出一个1到10的随机数是:"+randomNum);
double powNum=Math.pow(2,10);
System.out.println("2的10次幂是:"+powNum);
double sqrtNum=Math.sqrt(10);
System.out.println("10的平方根是:"+sqrtNum);
double logNum=Math.log(2);
System.out.println("2的对数是:"+logNum);
double sinNum=Math.sin(-10);
System.out.println("-10的正弦值是:"+sinNum);
double asinNum=Math.asin(0.5);
System.out.println("0.5的反正弦值是:"+asinNum);
System.out.println("格式化之前的数是:"+sqrtNum);
NumberFormat f=NumberFormat.getInstance();
f.setMaximumFractionDigits(10);
f.setMinimumIntegerDigits(4);
String s=f.format(sqrtNum);
System.out.println("格式化后:"+s);
}
}
5. 使用BigInteger类计算1！+3！+5！+7！+…的前30项的和。
答: import java.math.*;
public class Test
{
public static void main(String args[])
{
BigInteger sum=new BigInteger("0"),
jieCheng=new BigInteger("1"),
ONE=new BigInteger("1"),
i=ONE;
int k=0;
while(++k<=30)
{
sum=sum.add(jieCheng);
i=i.add(ONE);
jieCheng=jieCheng.multiply(i);
i=i.add(ONE);
jieCheng=jieCheng.multiply(i);
}
System.out.println(sum);
}
}
第7章 AWT组件及事件处理
1. Frame类对象的默认布局是什么布局？和Panel类对象的默认布局相同吗？
答:①Frame类对象的默认布局是BorderLayout布局;
②不相同，Panel类对象的默认布局是FlowLayout布局。
2. 一个容器对象是否可以使用add方法添加一个Frame窗口？
答: 不可以。
3. Checkbox对象可以触发ItemEvent事件吗？
答: 可以。
一个动物声音“模拟器”。希望模拟器可以模拟许多动物的叫声，要求如下
Animal.java
public abstract class Animal {
abstract void cry();
abstract void getAnimaName();
}
Dog.java
public class Dog extends Animal{
void cry(){
System.out.println("狗的叫声：汪汪汪");
}
void getAnimaName(){
System.out.println("名字：狗");
}
}
Cat.java
public class Cat extends Animal{
void cry(){
System.out.println("猫的叫声：喵喵喵");
}
void getAnimaName(){
System.out.println("名字：猫");
}
}
Simulator,java
public class Simulator {
void playSound(Animal animal){
animal.getAnimaName();
animal.cry();
}
}
public class Application {
public static void main(String args[]){
Simulator simulator=new Simulator();
simulator.playSound(new Cat());
simulator.playSound(new Dog());
}
}
计一个动物声音“模拟器”，需要用到接口。希望模拟器可以模拟许多动物的叫声，要求如下。
Animal.java
public interface Animal{
public abstract void cry();
public abstract String getAnimalName();
}
Simulator.java
public class Simulator{
public void playSound(Animal animal){
System.out.print("现在播放"+animal.getAnimalName()+"类的声音:");
animal.cry();
}
}
Dog.java
public class Dog implements Animal{
public void cry(){
System.out.println("汪汪...汪汪");
}
public String getAnimalName(){
return "狗";
}
}
Cat.java
public class Cat implements Animal{
public void cry(){
System.out.println("喵喵...喵喵");
}
public String getAnimalName(){
return "猫";
}
}
Application.java
public class E{
public static void main(String args[]){
Simulator simulator = new Simulator();
simulator.playSound(new Dog());
simulator.playSound(new Cat());
}
}
第3章中的例子9的程序允许用户在键盘依次输入若干个数字（每输入一个数字都需要按回车键确认），程序将计算出这些数的和以及平均值。请在第3章的例子9中增加断言语句，当用户输入的数字大于100或小于0时，程序立刻终止执行，并提示这是一个非法的成绩数据。
import java.util.*;
public class E{
public static void main(String args[]){
Scanner reader = new Scanner(System.in);
double sum = 0;
int m = 0;
while(reader.hasNextDouble()){
double x = reader.nextDouble();
assert x< 100:"数据不合理";
m = m+1;
sum = sum+x;
}
System.out.printf("%d个数的和为%f\n",m,sum);
System.out.printf("%d个数的平均值为%f\n",m,sum/m);
}
}
编写应用程序，有一个标题为“计算的窗口”的窗口，窗口的布局为FlowLayout布局。窗口中添加两个文本区，当我们在一个文本区中输入若干个数时，另一个文本区，同时对输入的数进行求和运算并求出平均值，也就是说随着输入的变化，另一个文本区不断地更新求和及平均值。
答: import java.awt.*;
import java.awt.event.*;
import java.util.*;
class Calculated extends Frame implements TextListener
{
TextArea text1,text2; //定义了2个文本区
Calculated(String s) //标题为“计算的窗口”的窗口
{
super(s);
setLayout(new FlowLayout()); //窗口布局为FlowLayout
text1=new TextArea(5,23);
text2=new TextArea(5,23);
add(text1);
add(text2);
text2.setEditable(false); //显示求和结果和平均值的文本区禁止编辑
text1.addTextListener(this);
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
}
);
setBounds(100,100,400,160);
setVisible(true);
validate();
}
public void textValueChanged(TextEvent e)
{
String s=text1.getText();
StringTokenizer geshu=new StringTokenizer(s);
int n=geshu.countTokens();
double a[]=new double[n];
for(int i=0;i<n;i++)
{
String temp=geshu.nextToken();
double date=Double.parseDouble(temp);
a[i]=date;
}
double sum=0,average;
for(int i=0;i<n;i++)
{
sum=sum+a[i];
}
average=sum/n;
text2.setText(null);
text2.append("和:"+sum+"\n"+"平均数:"+average);
}
}
public class Test
{
public static void main(String args[])
{
Calculated calc=new Calculated("计算的窗口");
}
}
判断回文数
import java.util.Scanner;
public class Number {
public static void main(String args[]) {
int number = 0, d5, d4, d3, d2, d1;
Scanner reader = new Scanner(System.in);
System.out.println("输入一个1至99999之间的数");
number = reader.nextInt();
if (number >= 1 && number <= 99999) //判断number在1 ~ 99999之间的条件
{
d5 = number / 10000; //计算number的最高位（万位）d5
d4 = number % 10000 / 1000;//计算number的千位d4
d3 = number % 1000 / 100;//计算number的百位d3
d2 = number % 100 / 10;
d1 = number % 10;
if (number > 9999) //判断number是5位数的条件
{
System.out.println(number + "是5位数");
if (d5 == d1 && d4 == d2) //判断number是回文数的条件
{
System.out.println(number + "是回文数");
} else {
System.out.println(number + "不是回文数");
}
} else if (number < 10000 && number > 999) //判断number是4位数的条件
{
System.out.println(number + "是4位数");
if (d4 == d1 && d3 == d2) //判断number是回文数的条件
{
System.out.println(number + "是回文数");
} else {
System.out.println(number + "不是回文数");
}
} else if (number < 1000 && number > 99) //判断number是3位数的条件
{
System.out.println(number + "是3位数");
if (d3 == d1) //判断number是回文数的条件
{
System.out.println(number + "是回文数");
} else {
System.out.println(number + "不是回文数");
}
} else if (d2 != 0) {
System.out.println(number + "是2位数");
if (d1 == d2) {
System.out.println(number + "是回文数");
} else {
System.out.println(number + "不是回文数");
}
} else if (d1 != 0) {
System.out.println(number + "是1位数");
System.out.println(number + "是回文数");
}
//}
else {
System.out.printf("\n%d在不1~99999之间", number);
}
}
}
}
输出希腊字母表
```java
public class GreekAlphabet {
public static void main(String args[]) {
int startPosition = 0, endPosition = 0;
char cStart = 'α', cEnd = 'ω';
//cStart做int转换运算，并将结果赋值给startPosition
startPosition=(int)cStart;
//cEnd做int转换运算，并将结果赋值给endPosition
endPosition=(int)cEnd;
System.out.println("希腊字母\'α\'在unicode表的顺序位置：" + startPosition);
System.out.println("希腊字母\'ω\'在unicode表的顺序位置：" + endPosition);
System.out.println("希腊字母表：");
for (int i = startPosition; i <= endPosition; i++) {
char c = '\0';
//i做char型转换运算，并将结果赋值给c
c=(char)i;
System.out.print(" " + c);
if ((i - startPosition + 1) % 10 == 0) {
System.out.println("");
}
}
}
}
实验2.2 数组的引用与元素
public class InputArray {
public static void main(String args[]) {
int[] a = {100, 200, 300};
//输出数组a的长度
System.out.println("数组a的长度="+a.length);
//输出数组a的引用
System.out.println("数组a的位置="+a);
int b[][] = {{1}, {1,1}, {1,2,1}, {1,3,3,1}, {1,4,6,4,1}};
//输出二维数组b的一维数组的个数
System.out.println(b[0].length);
System.out.println(b[4][2]);
//将数组a的引用赋给b[4];
b[4]=a;
System.out.println(b[4][2]);
}
}
实验4.1 机动车
public class Vehicle {
double speed;//声明double型变量speed，刻画速度
int power; //声明int型变量power，刻画功率
void speedUp(int s) {
speed = s+speed;//将参数s的值与成员变量speed的和赋值给成员变量speed
}
void speedDown(int d) {
speed= speed-d; //将成员变量speed与参数d的差赋值给成员变量speed
}
void setPower(int p) {
power = p; //将参数p的值赋值给成员变量power
}
int getPower() {
return power; //返回成员变量power的值
}
double getSpeed() {
return speed;
}
}
public class User {
public static void main(String args[]) {
Vehicle car1, car2;
car1 = new Vehicle(); //使用new运算符和默认的构造方法创建对象car1
car2 = new Vehicle();//使用new运算符和默认的构造方法创建对象car2
car1.setPower(128);
car2.setPower(76);
System.out.println("car1的功率是："+car1.getPower());
System.out.println("car2的功率是："+car2.getPower());
car1.speedUp(80);//car1调用speedUp()方法将自己的speed的值增加80
car2.speedUp(80);//car2调用speedUp()方法将自己的speed的值增加80
System.out.println("car1目前的速度："+car1.getSpeed());
System.out.println("car2目前的速度："+car2.getSpeed());
car1.speedDown(10);
car2.speedDown(20);
System.out.println("car1目前的速度："+car1.getSpeed());
System.out.println("car2目前的速度："+car2.getSpeed());
}
}
实验3.2 猜数字游戏
import java.util.Scanner;
import java.util.Random;
public class GuessNumber {
public static void main(String args[]) {
Scanner reader = new Scanner(System.in);
Random random = new Random();
System.out.println("给你一个1至100之间的整数，请猜测这个数");
int realNumber = random.nextInt(100) + 1; //random.nextInt(100)是[0,100)
//中的随机整数
int yourGuess = 0;
System.out.print("输入您的猜测：");
yourGuess = reader.nextInt();
while (yourGuess != realNumber) //循环条件
{
if (yourGuess > realNumber)
{
System.out.print("猜大了，再输入你的猜测：");
yourGuess = reader.nextInt();
}
else if (yourGuess < realNumber)
{
System.out.print("猜小了，再输入你的猜测：");
yourGuess = reader.nextInt();
}
}
System.out.println("猜对了");
}
}
while放在外面，是因为while的循环条件是yourGuess != realNumber。如果要放在while循环里里面则要改变循环条件，同时要放进判断语句里面。
