java seWord文档下载推荐.docx
《java seWord文档下载推荐.docx》由会员分享，可在线阅读，更多相关《java seWord文档下载推荐.docx（111页珍藏版）》请在冰点文库上搜索。
if（i==1）
return1;
returnfact（i-1）*i;
}
2.用递归方法打印出一个数的阶乘和
publicclassFactSum{
FactSumft=newFactSum（）;
intsum=ft.sumFact（3）;
{
publicintsumFact（inti）
if（i==1）return1;
returnfact（i）+sumFact（--i）;
3.for语句打印出一个数的阶乘
publicclassForFact{
ForFactff=newForFact（）;
intresult=ff.sum（10）;
System.out.println（result）;
publicintsum（intk）
intresult=1;
for（inti=1;
i<
=k;
i++）
result=result*i;
}
returnresult;
4.for语句打印出一个数的阶乘的和
publicclassForFactSum{
ForFactSumff=newForFactSum（）;
intresult=ff.sum（4）;
publicintsum（intk）
intsum=0;
for（intj=1;
j<
=4;
j++）
{intresult=1;
k--;
sum=sum+result;
returnsum;
5.键盘输入123，打印出一百二十三
publicstaticvoidmain（String[]args）throwsIOException{
intmoney=12345,i=0;
InputStreamReaderreader=newInputStreamReader（System.in）;
BufferedReaderinput=newBufferedReader（reader）;
System.out.println（"
pleaseinputanewnumber:
"
）;
money=Integer.parseInt（input.readLine（））;
StringBufferout=newStringBuffer（）;
while（money>
0）{
inttemp,k=10;
temp=money%k;
switch（temp）{
case0:
out.append（'
零'
break;
case1:
index_text（out,i）;
壹'
case2:
贰'
case3:
叁'
case4:
肆'
case5:
伍'
case6:
陆'
case7:
柒'
case8:
捌'
case9:
玖'
money=（int）（money/k）;
k=k*10;
i++;
for（intj=out.length（）-1;
j>
=0;
j--）{
Stringstr=out.toString（）;
System.out.print（str.charAt（j））;
//个，十1，百2，千，万，十万，百万，千万，亿，十亿
privatestaticvoidindex_text（StringBufferout,inti）{
switch（i）{
;
//
拾'
case10:
百'
case11:
仟'
case12:
万'
case13:
亿'
default:
你输入的数据过大！
！
6.打印出计算器1亿*1亿的结果
importjava.math.BigInteger;
publicclassCalculate{
publicstaticvoidmain（String[]args）{
BigIntegerbg1=newBigInteger（"
100000000"
BigIntegerbg2=newBigInteger（"
System.out.println（bg1.multiply（bg2））;
7.冒泡排序升序打印出10个数，输入一个数，打印比他小的数
packageTest0926;
importjava.util.Scanner;
publicclassMaopaoSort{
staticint[]number={10,12,15,20,33,25,14,54,30,65};
MaopaoSortmp=newMaopaoSort（）;
mp.sort（）;
请输入一个比较的数"
Scannerreader1=newScanner（System.in）;
inttem=reader1.nextInt（）;
for（inti=0;
10;
if（number[i]<
tem）
System.out.print（number[i]+"
"
else
publicvoidsort（）
for（inti=0;
number.length;
for（intj=0;
number[j]）
inttempt=number[j];
number[j]=number[i];
number[i]=tempt;
8.利用for语句打印出乘法口诀表
publicclassMultiplication{
for（inti=1;
i<
=9;
for（intj=1;
j<
=i;
intresult=i*j;
System.out.print（j+"
*"
+i+"
="
+result+"
System.out.println（）;
9.打印杨辉三角形
publicstaticvoidmain（String[]args）
int[][]array=newint[6][6];
i<
6;
i++）
j<
=i;
j++）
if（i==0||j==0）
array[i][j]=1;
}else
array[i][j]=array[i-1][j-1]+array[i-1][j];
for（intm=6-i;
m>
0;
m--）
System.out.print（"
if（array[i][j]!
=0）
System.out.print（array[i][j]+"
10.冒泡排序
publicvoidsort（）
11.二分排序
publicclassBinSort
{
publicvoidhalf（inta[]）{
intleft,right,mid;
intnumber,j;
a.length;
i++）{
left=0;
right=i-1;
number=a[i];
//通过二分法定位数据number的位置
while（left<
=right）{
mid=（left+right）/2;
if（number<
a[mid]）{
right=mid-1;
}else{
left=mid+1;
for（j=i-1;
=left;
a[j+1]=a[j];
a[left]=number;
//System.out.println（a[left]）;
i++）{
System.out.println（a[i]）;
publicstaticvoidmain（String[]args）{
intarr[]={20,12,36,48,25};
BinSorths=newBinSort（）;
hs.half（arr）;
12.二分查找
publicclassBinSearch{
staticint[]number=newint[10];
staticintkey;
staticintmid;
请输入十个有序的数"
Scannersca=newScanner（System.in）;
for（inti=0;
number[i]=sca.nextInt（）;
//System.out.println（number[i]）;
请输入你要查找的数"
Scannersca1=newScanner（System.in）;
key=sca1.nextInt（）;
BinSearchbin=newBinSearch（）;
bin.Method（）;
找到你要查找的数，它的位置是：
+（mid+1））;
publicintMethod（）{
intlow=0;
inthigh=number.length-1;
while（low<
=high）
mid=（low+high）/2;
if（key==number[mid]）
returnmid;
elseif（key<
=number[mid]）
high=mid-1;
else
low=mid+1;
return-1;
10/08
1.类与对象的理解
类和对象的关系
⑴对象是对现实世界中事物的抽象，是Java程序的基本封装单位，是类的实例。
（2）类是对象的抽象，是数据和操作的封装体。
（3）属性是事物静态特征的抽象，在程序中用数据成员加以描述。
（4）操作是事物动态特征的抽象，在程序中用成员方法来实现。
（5）把客观世界中的事物映射到面向对象的程序设计中就是对象。
（6）对象是面向对象程序设计中用来描述客观事物的程序单位。
（7）客观世界中的许多对象，无论其属性还是其行为常常有许多共同性，抽象出这些对象的共同性便可以构成类。
（8）类是对象的抽象和归纳，对象是类的实例。
定义类
面向对象的程序设计过程中有两个重要概念：
类（class）和对象（object，也被称为实例，instance），其中类是某一批对象的抽象，可以把类理解成某种概念；
对象才是一个具体存在的实体。
Java语言里定义类的简单语法如下：
[修饰符]class类名
零个到多个构造器定义.
零个到多个属性…
零个到多个方法…
对一个类定义而言，可以包含三种最常见的成员：
构造器、属性和方法，三种成员都可以定义零个或多个，如果三种成员都只定义零个，就是定义了一个空类，这没有太大的实际意义。
类里各成员之间的定义顺序没有任何影响，各成员之间可以相互调用，但需要指出的是，static修饰的成员不能访问没有static修饰的成员。
声明对象
声明对象就是确定对象的名称，并指明该对象所属的类。
声明格式如下：
类名对象名表;
类名是指对象所属类的名字，它是在声明类时定义的；
对象名表是指一个或多个对象名，若为多个对象名时，用逗号进行分隔。
声明对象的作用是为将来的编译过程提供必要的信息。
建立对象
建立对象，实际上就是用Java提供的new关键字为对象分配存储空间。
在声明对象时，只确定了对象的名称和它所属的类，并没有为对象分配存储空间，此时对象还不是类的实例。
建立对象的格式如下：
对象名=new构造方法（）;
关键字new的作用是建立对象，为对象分配存储空间。
初始化对象
初始化对象是指由一个类生成对象时，为这个对象确定初始状态，即为它的数据成员赋初始值的过程，当然，它主要由一些赋值语句组成。
由于初始化操作是最常用的操作之一，为简化这一过程，Java还提供了专用的方法来完成它，这个方法被称为构造方法。
对象的初始化与构造方法
构造方法是一个类的方法中方法名与类名相同的类方法。
每当使用new关键字创建一个对象，为新建对象开辟了内存空间之后，Java系统将自动调用构造方法初始化这个新建对象。
构造方法是类的一种特殊方法，它的特殊性主要体现在以下几个方面：
构造方法的方法名与类名相同,构造方法是类的方法，它能够简化对象数据成员的初始化操作,不能对构造方法指定类型，它有隐含的返回值，该值由系统内部使用。
构造方法一般不能由编程人员显式地直接调用，在创建一个类的对象的同时，系统会自动调用该类的构造方法将新对象初始化,构造方法可以重载，即可定义多个具有不同参数的构造方法,构造方法可以继承，即子类可以继承父类的构造方法,如果用户在一个自定义类中未定义该类的构造方法，系统将为这个类定义一个缺省的空构造方法。
10/09
1.设计一个包含多个构造函数的类，并分别用这些构造函数实例化对象
packagecom.chinasoft.homework;
/*
*包含多个构造函数的类，并分别用这些构造函数实例化对象
*/
publicclassClassTest{
//成员变量
publicStringname;
publicintage;
publicintsex;
//不带参数的构造函数
publicClassTest（）{
//TODOAuto-generatedconstructorstub
//一个参数的构造函数
publicClassTest（Stringname）{
this.name=name;
this.age=0;
this.sex=1;
//两个参数
publicClassTest（Stringname,intage）{
this.age=age;
//三个参数
publicClassTest（Stringname,intage,intsex）{
this.sex=sex;
publicvoidshow（）{
System.out.println（this.name+"
+this.age+"
+this.sex）;
/*
*实例化
ClassTestct1=newClassTest（）;
ClassTestct2=newClassTest（"
zhangsan"
ClassTestct3=newClassTest（"
10）;
ClassTestct4=newClassTest（"
10,1）;
ct1.show（）;
ct2.show（）;
ct3.show（）;
ct4.show（）;
2.编写一个类Calculate1，实现加、减两种运算，然后，编写另一个派生类Calculate2，实现乘、除两种运算
publicclassCalculate1{
intnumber1;
intnumber2;
publicCalculate1（）{
publicCalculate1（intnum1,intnum2）{
this.number1=num1;
this.number2=num2;
publicintAdd（）{
intnumber3=number1+number2;
returnnumber3;
//System.out.println（number3）;
publicintsubtract（）{
intnumber4=number1-number2;
returnnumber4;
publicclassCalculate2extendsCalculate1{
publicCalculate2（）{
publicCalcu
升级会员 