写了几个，还有几个还在研究中。
14: 将1 到1000 之间的奇数打印出来。
public class OddNumber
{
public static void main(String[] args)
{
for(int i=1;i<=100;i++)
{
if(i%2==0) continue;
{
System.out.print(i+" ");
}
}
}
}
15: 判断一个数能否同时被3和5 整除。
import java.util.Scanner;
public class Practice
{
public static void main(String[] args)
{
while(true)
{
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个数字，按回车提交!");
if(sc.hasNextInt())
{
int a=sc.nextInt();
if(a%3==0&&a%5==0)
{
System.out.println("这个数字既能被3整除又能被5整除!!");
break;
}
else
{
System.out.println("这个数字不能同时被3和5整除!!");
break;
}
}
else
{
System.out.println("您输入的不是数字,请重新输入！");
}
}
}
}
16: 输入10个数，找出最大一个数，并打印出来。
import java.util.Scanner;
public class Practice
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
while(true)
{
System.out.println("请输入十个数字，以','分隔,按回车提交!");
String[] str=sc.next().split(",");
int[] a=new int[10];
if(str.length==10)
{
if(JudgeNum(str))
{
for(int i=0;itemp)
{
temp=x[i];
}
}
return temp;
}
}
17: 给出一百分制成绩，要求输出成绩等级’A’,’B’,’C’,’D’,’E’。90 分以上为’A’,80~89 分为’B’,70~79 分为’C’,60~69 分为’D’,60分以下为’E’。
import java.util.Scanner;
public class LevelDemo
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("请输入您的分数:");
if(sc.hasNextInt())
{
int a=sc.nextInt();
if(a<60)
{
System.out.println("您输入的分数等级为:E");
}
else if(a>=60&&a<=69)
{
System.out.println("您输入的分数等级为:D");
}
else if(a>=70&&a<=79)
{
System.out.println("您输入的分数等级为:C");
}
else if(a>=80&&a<=89)
{
System.out.println("您输入的分数等级为:B");
}
else if(a>=90)
{
System.out.println("您输入的分数等级为:A");
}
}
else
{
System.out.println("输入错误,请重新输入!");
}
}
}
18: 输出图案：
*
**
***
****
*
**
***
****
public class PrintStar
{
public static void main(String[] args)
{
StringBuilder str1=new StringBuilder("");
StringBuilder str2=new StringBuilder("");
for(int i=0;i<4;i++)
{
str1.append("*");
System.out.println(str1);
}
for(int j=0;j<4;j++)
{
str2.append("*");
System.out.println(str2);
}
}
}
//这个写的太脑残了，我还得想想
1：写一个MyPoint 完全封装类，其中含有私有的int类型的x 和y 属性，分别用公有的getX 和setX、getY 和setY 方法访问，定义一个toString 方法用来显示这个对象的x、y 的值，如显示（1，2），最后用main 方法测试。
class MyPoint
{
private int x;
private int y;
public MyPoint(int x,int y)
{
this.setX(x);
this.setY(y);
}
public void setX(int x)
{
this.x=x;
}
public void setY(int y)
{
this.y=y;
}
public int getX()
{
return this.x;
}
public int getY()
{
return this.y;
}
public String toString()
{
return "该点的x坐标是:"+this.getX()+",y坐标是:"+this.getY();
}
}
public class PointTest
{
public static void main(String[] args)
{
MyPoint mp=new MyPoint(1,2);
System.out.println(mp);
}
}
2：在MyPoint 类中增加equals()、toString()方法，根据命令行参数个数测试：若不传参数，则显示（0，0）；若传一个参数，则打印（此参数值，0）；若传两个参数，则打印（第一个参数值，第二个参数值）。
class MyPoint//没有equals()
{
private int x;
private int y;
public MyPoint(int x,int y)
{
this.setX(x);
this.setY(y);
}
public void setX(int x)
{
this.x=x;
}
public void setY(int y)
{
this.y=y;
}
public int getX()
{
return this.x;
}
public int getY()
{
return this.y;
}
public String toString()
{
return "该点的x坐标是:"+this.getX()+",y坐标是:"+this.getY();
}
}
public class PointTest
{
public static void main(String[] args)
{
if(args.length==0)
{
MyPoint mp=new MyPoint(0,0);
System.out.println(mp);
}
else
{
if(args.length==1)
{
if(isNum(args[0]))
{
MyPoint mp=new MyPoint(Integer.parseInt(args[0]),0);
System.out.println(mp);
}
else
{
System.out.println("输入不合法");
}
}
if(args.length==2)
{
if(isNum(args[0])&&isNum(args[1]))
{
MyPoint mp=new MyPoint(Integer.parseInt(args[0]),Integer.parseInt(args[1]));
System.out.println(mp);
}
else
{
System.out.println("输入不合法");
}
}
if(args.length>2)
{
System.out.println("输入错误");
}
}
}
public static boolean isNum(String s)
{
try
{
Integer.parseInt(s);
return true;
}
catch(Exception e)
{
return false;
}
}
}
3: 有一个序列，首两项为0，1，以后各项值为前两项值之和。写一个方法来实现求这个序列的和
public class RecursionTest
{
public static void main(String[] args)
{
System.out.println(sum(10));
}
public static int sum(int n)
{
int sum=0;
for(int i=n;i>0;i--)
{
sum+=fun1(i);
}
return sum;
}
public static int fun1(int n)
{
if(n==1)
{
return 0;
}
if(n==2)
{
return 1;
}
return fun1(n-1)+fun1(n-2);
}
}
递归实现:
public class RecursionTest
{
public static void main(String[] args)
{
System.out.println(sum(30));
}
public static int sum(int n)
{
if(n==1)
{
return 0;
}
return sum(n-1)+fun1(n);
}
public static int fun1(int n)
{
if(n==1)
{
return 0;
}
if(n==2)
{
return 1;
}
return fun1(n-1)+fun1(n-2);
}
}
4：请编写一个方法实现如下功能：将1至7 的数字转换为星期日到星期六的字符串。
import java.util.Scanner;
public class MaxNum
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("请输入0-7之间的整数:");
if(sc.hasNextInt())
{
int a=sc.nextInt();
switch(a)
{
case 1:
System.out.println("星期天");
break;
case 2:
System.out.println("星期一");
break;
case 3:
System.out.println("星期二");
break;
case 4:
System.out.println("星期三");
break;
case 5:
System.out.println("星期四");
break;
case 6:
System.out.println("星期五");
break;
case 7:
System.out.println("星期六");
break;
default :
System.out.println("输入错误");
break;
}
}
else
{
System.out.println("输入错误,请重新输入");
}
}
}
5：请编写一个方法实现如下功能：有任意三个整数a,b,c,请输出其中最大的
public class MaxNum
{
public static void main(String[] args)
{
int a=10;
int b=1;
int c=110;
System.out.println(Math.max(Math.max(a,c),b));
}
}
6：请编写一个方法实现如下功能：将任意三个整数a,b,c按从小到大的顺序输出。
import java.util.Arrays;
public class MaxNum
{
public static void main(String[] args)
{
int[] str={1000,178,-1};
Arrays.sort(str);
for(int x:str)
System.out.println(x);
}
}
8：请编写一个方法实现如下功能：计算1 加到n （ n>=2的整数）的总和。
import java.util.Scanner;
public class MaxNum
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个整数:");
int a=sc.nextInt();
System.out.println("从1加到"+a+"和等于:"+fun(a));
}
public static long fun(long n)
{
long sum=0;
for(int i=0;i<=n;i++)
{
sum=sum+i;
}
return sum;
}
}
9：请编写一个方法实现如下功能：得到一个整数的绝对值。
import java.util.Scanner;
public class MaxNum
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个负整数:");
int a=sc.nextInt();
System.out.println(a+"绝对值等于:"+Math.abs(a));
}
}
1：创建一个构造方法重载的类，并用另一个类调用
class Test
{
private String name;
public Test()
{
this.name="ss";
}
public Test(String name)
{
this.name=name;
}
public String getName()
{
return this.name;
}
}
public class OverloadTest
{
public static void main(String[] args)
{
Test t1=new Test();
System.out.println(t1.getName());
Test t2=new Test("张三");
System.out.println(t2.getName());
}
}
2：创建Rodent（啮齿动物）：Mouse（老鼠），Gerbil（鼹鼠），Hamster（大颊鼠）等的一个继承分级结构。在基础类中，提供适用于所有Rodent 的方法，并在衍生类中覆盖它们，从而根据不同类型的Rodent 采取不同的行动。创建一个Rodent 数组，在其中填充不同类型的Rodent，然后调用自己的基础类方法，看看会有什么情况发生。
abstract class Rodent
{
public abstract void bite();
}
class Mouse extends Rodent
{
public void bite()
{
System.out.println("老鼠咬!");
}
}
class Gerbil extends Rodent
{
public void bite()
{
System.out.println("鼹鼠咬!");
}
}
class Hamster extends Rodent
{
public void bite()
{
System.out.println("大颊鼠咬!");
}
}
public class InheritanceTest
{
public static void main(String[] args)
{
Rodent[] rd={new Mouse(),new Gerbil(),new Hamster()};
for(int i=0;i
3：编写MyPoint的一个子类MyXYZ，表示三维坐标点，重写toString方法用来显示这个对象的x、y、z 的值，如显示（1，2，3），最后用main方法测试
class MyPoint
{
private int x;
private int y;
public MyPoint(int x,int y)
{
this.setX(x);
this.setY(y);
}
public void setX(int x)
{
this.x=x;
}
public void setY(int y)
{
this.y=y;
}
public int getX()
{
return this.x;
}
public int getY()
{
return this.y;
}
public String toString()
{
return "该点的x坐标是:"+this.getX()+",y坐标是:"+this.getY();
}
}
class MyXYZ extends MyPoint
{
private int z;
public MyXYZ(int x,int y,int z)
{
super(x,y);
this.z=z;
}
public int getZ()
{
return this.z;
}
public String toString()
{
return "该点的x坐标是:"+this.getX()+",y坐标是:"+this.getY()+",z坐标是:"+this.getZ();
}
}
public class ThreePointTest
{
public static void main(String[] args)
{
MyPoint mp=new MyXYZ(1,9,66);
System.out.println(mp);
}
}
15：设计个Circle类，其属性为圆心点（类型为前面设计的类MyPoint）和半径，并为此类
编写以下三个方法：
一是计算圆面积的calArea()方法；
二是计算周长的calLength()；
三是boolean inCircle(MyPoint mp)方法，功能是测试作为参数的某个点是否在当前对象圆内（圆内，包括圆上返回true；在圆外，返回false）
class MyPoint
{
private int x;
private int y;
public MyPoint(int x,int y)
{
this.setX(x);
this.setY(y);
}
public void setX(int x)
{
this.x=x;
}
public void setY(int y)
{
this.y=y;
}
public int getX()
{
return this.x;
}
public int getY()
{
return this.y;
}
public String toString()
{
return "该点的x坐标是:"+this.getX()+",y坐标是:"+this.getY();
}
}
class Circle
{
private MyPoint cp;
private double radius;
public Circle(MyPoint mp,double r)
{
this.cp=mp;
this.radius=r;
}
public double calArea()
{
return Math.PI*Math.pow(radius,2);
}
public double calLength()
{
return Math.PI*radius*2;
}
public boolean inCircle(MyPoint mp)
{
if((Math.pow(mp.getX()-this.cp.getX(),2)+Math.pow(mp.getY()-this.cp.getY(),2))
1：写一个方法，在方法内部定义一个一维的int 数组，然后为这个数组赋上初始值，最后再循环取值并打印出来
public class ArrayTest10
{
public static void main(String[] args)
{
ArrayFun();
}
public static void ArrayFun()
{
int[] a={0,9,6,7,1,5,86,2,45,3,4};
for(int i:a)
System.out.print(i+" ");
}
}
3：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词；然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”
public class ArrayTest10
{
public static void main(String[] args)
{
String[] str={"abc","printStackTrace","default","final","finally","abstract","assert","interface","GregorianCalendar","NullPointereFormatException "};
if(args.length==0)
{
System.out.println("您没有输入要查找的单词");
}
else if(args.length==1)
{
StringBuffer sBu=new StringBuffer(10);
for(String s:str)
sBu.append(s);
if(sBu.indexOf(args[0])!=-1)
{
System.out.println("Yes");
}
else
{
System.out.println("No");
}
}
else
{
System.out.println("输入不合法");
}
}
}
5：用二重循环求出二维数组b所有元素的和：int[][] b={ {11},{21,22},{31,32,33}}
public class ArraySum
{
public static void main(String[] args)
{
int[][] b={
{11},{21,22},{31,32,33}};
int sum=0;
for(int i=0;i
方法二:用for-each输出和
public class ArraySum
{
public static void main(String[] args)
{
int[][] b={
{11},{21,22},{31,32,33}};
int sum=0;
for(int[] a:b)
for(int s:a)
sum+=s;
System.out.println("此数组元素的和为:"+sum);
}
}
6：编写一个方法实现将班级同学的名单存放在数组中，并利用随机数(Math.random())随机输出一位同学的姓名。
public class RondomName
{
public static void main(String[] args)
{
String[] str={"张三","李四","歌友会","也盘","听音乐","与的","同样","亚特","额头","帅哥"};
int i=(int)Math.round(Math.random()*10);
if(i=0)
System.out.println(str[i]);
}
}
7：生成一百个随机数，放到数组中，然后排序输出。
import java.util.Arrays;
public class RoundmTest
{
public static void main(String[] args)
{
double [] du=new double[100];
for(int i=0;i<100;i++)
{
du[i]=Math.random();
}
Arrays.sort(du);
for(double dl: du)
System.out.println(dl);
}
}
8：统计字符串中英文字母、空格、数字和其它字符的个数。
public class StatisticsString
{
public static void main(String[] args)
{
String str="ASD FAJKD SMjdsnce jglk1 6572 10 SD F%$ !#\\$_ *&^%^&LM 0 2D\"F 0AFG 15GH R1A Sfhrh .!@#$%^&*((*&^";
int a=0;
int b=0;
int num=0;
int s=0;
int sp=0;
for(int i=0;i?
1：设计一个银行帐户类，具有户名，帐号，余额等属性，以及存款、取款等方法，并对此类进行测试
class BankAccount
{
private String name;
private String bankId;
private double balance;//余额
public BankAccount(String name,String bankId)
{
this.setName(name);
this.setBankId(bankId);
this.balance=0;
}
public String getName()
{
return this.name;
}
public String getBankId()
{
return this.bankId;
}
public double getBalance()
{
return this.balance;
}
public void pringBankAccount()
{
System.out.println("账户信息如下:\n"+"开户人姓名:"+this.getName()+" 账户编号:"+this.getBankId()+" 账户余额:"+this.getBalance());
System.out.println("--------------------------==========--------------------------");
}
public void getWithdrawals (double du)//取款
{
if(this.getBalance()>=du)
{
this.balance-=du;
System.out.println("取款金额为:"+du+",取款后余额为:"+this.getBalance()+"\n");
}
else
{
this.pringBankAccount();
System.out.println("余额不足，操作失败!");
}
}
public void setName(String name)
{
this.name=name;
}
public void setBankId(String bankId)
{
this.bankId=bankId;
}
public void setDeposit (double balance)//存款
{
this.pringBankAccount();
this.balance+=balance;
System.out.println("存款金额为:"+balance+"存款后余额为:"+this.getBalance()+"\n");
}
}
public class BankAccountTest
{
public static void main(String[] args)
{
BankAccount ba=new BankAccount("张三","042041251218502510022");
ba.setDeposit(10000);
ba.getWithdrawals(199.3);
ba.getWithdrawals(1999999.3);
}
}
2：写一个方法，功能：定义一个一维的int 数组，长度为3，把任意三个整数a,b,c赋值给数组,然后将它们按从小到大的顺序输出（使用冒泡排序）
public class SortTest
{
public static void main(String[] args)
{
int[] a=new int[3];
for(int i=0;ia[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
for(int i: a)
System.out.print(i+" ");
}
}
冒泡思路分析:
0 1 2 3 4
=======
7 2 9 8 3
5个数最少比较4趟
第一趟: i=1 j=0,1,2,3(j<4[5-1])
2 7 8 3 9
第二趟: i=2 j=0,1,2(j<3[5-2])
2 7 3 8 9
第三趟: i=3 j=0,1(j<2[5-3])
2 3 7 8 9
第四趟: i=4 j=0(j<1[5-4])
2 3 7 8 9
5：已知两个对像String s1,String s2,已用ASC码排序好了，编写程序将两个String 合并，得到的结果。例如：s1="abc" s2="abc" 得s="aabbcc";结果也是排序的
import java.util.Arrays;
public class CombinationString
{
public static void main(String[] args)
{
StringBuffer s1=new StringBuffer("aadfeghhhbc");
s1.append("adabce");
char[] ch=new char[s1.length()];
for(int i=0;i
1：定义一个对象“交通工具”，并定义接口，说明交通工具可以移动。继承交通工具而产生汽车、飞机、轮船，并定义类来实现其移动的方法。
interface Move
{
public void FastMove();
}
abstract class TrafficTools implements Move
{
public void FastMove() {}
}
class Car extends TrafficTools
{
public void FastMove()
{
System.out.println("汽车移动");
}
}
class Plane extends TrafficTools
{
public void FastMove()
{
System.out.println("飞机移动");
}
}
class Boat extends TrafficTools
{
public void FastMove()
{
System.out.println("轮船移动");
}
}
public class TrafficTest
{
public static void main(String[] args)
{
TrafficTools tt1=new Car();
TrafficTools tt2=new Plane();
TrafficTools tt3=new Boat();
tt1.FastMove();
tt2.FastMove();
tt3.FastMove();
}
}
2：定义一个类来使用上面的接口
interface Move
{
public void FastMove();
}
class TrafficTools
{
public void FindMove(Move m)
{
m.FastMove();
}
}
class Car implements Move
{
public void FastMove()
{
System.out.println("汽车移动");
}
}
class Plane implements Move
{
public void FastMove()
{
System.out.println("飞机移动");
}
}
class Boat implements Move
{
public void FastMove()
{
System.out.println("轮船移动");
}
}
public class TrafficToolsTest
{
public static void main(String[] args)
{
Move m1=new Car();
Move m2=new Plane();
Move m3=new Boat();
TrafficTools tt=new TrafficTools();
tt.FindMove(m1);
tt.FindMove(m2);
tt.FindMove(m3);
}
}
1：用extends 关键字创建自己的例外类；
class MyException extends Exception
{
public MyException()
{
super("抛出自定义异常");
}
}
public class TestException
{
public static void main(String[] args)
{
MyException me=new MyException();
try
{
throw me;
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
}
2：用main()创建一个类，令其掷出try 块内的Exception 类的一个对象。为Exception 的构建器赋予一个字串参数。在catch从句内捕获异常，并打印出字串参数。添加一个finally从句，并打印一条消息，证明自己真正到达那里。
class MyException extends Exception
{
public MyException(String msg)
{
super(msg);
}
public void Fun() throws MyException
{
try
{
throw new MyException("异常二");
}
finally
{
System.out.println("又出异常了");
}
}
}
public class TestException
{
public static void main(String[] args)
{
MyException me=new MyException("出异常了！");
try
{
throw me;
}
catch (Exception ex)
{
System.out.println(ex);
}
finally
{
System.out.println("出不出异常我照样运行!");
}
try
{
me.Fun();
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
}
4：编写应用程序，从命令行传入两个整型数作为除数和被除数。要求程序中捕获NumberFormatException 异常和ArithmeticException 异常在命令行输入不同的参数时能输出如下各种结果：
java A
总是被执行
Exception in thread "main" java.lang.ArrayIndexOutofBoundsException at
A.main(A.java:7)
java A 1 2
0
总是被执行
java A 1 3a
java.lang.NumberFormatException: 3a
at java.lang.Integer.parseInt(Integer.java:435)
at java.lang.Integer.parseInt(Integer.java:476)
at A.main(A.java:8)
总是被执行
java A 1 0
java.lang.ArithmeticException: / by zero at A.main(A.java:9)
总是被执行
public class ExceptionCapture
{
public static void main(String[] args)
{
int a=0;
int b=0;
int temp=0;
boolean bl=true;
try
{
a=Integer.parseInt(args[0]);
b=Integer.parseInt(args[1]);
temp=a/b;
}
catch(ArithmeticException ae)
{
System.out.println(ae);
bl=false;
}
catch(NumberFormatException nfe)
{
System.out.println(nfe);
bl=false;
}
catch(ArrayIndexOutOfBoundsException ai)
{
System.out.println(ai);
bl=false;
}
catch(Exception e)
{
e.printStackTrace();
bl=false;
}
finally
{
System.out.println("总是被执行!");
}
if(bl)
System.out.println("您输入的两个整数"+args[0]+","+args[1]+"相除的结果是:"+temp);
}
}
还有一些题目待我写完了一起发上来，有一些题目写了也不好，但这些题目对我巩固基础应该还是有帮助的。