1.用循环的嵌套,输出输出如下图形
*
* * *
* * * * *
* * * * * * *
* * * * *
* * *
*
public static void main(String[] args) {
int i=0;//用i记录行数
int j=1;//用j记录每一行打印*的个数
while (i<7){//打印7行
if (i<3){//打印1~3行
int x=j;用x记录需要打印*的个数
while (x>0){
System.out.print("*");
x--;//每打印一个*,x--
}
j+=2;//每打印完一行,下一行的*个数加2
} else if (i==3) {//打印到中间一行,直接打印
System.out.print("*******");
} else {//剩下的每打印一行,*的个数-2
int x=j-2;
while (x>0){
System.out.print("*");
x--;//每打印一个*,x--
}
j-=2;//每打印完一行,下一行的*个数减2
}
System.out.println();每打印一行,换行
i++;
}
}
2.写一段程序对数组int[] array内的元素从小到大重新排列
public static void main(String[] args) {
int []array={2,31,3,2,41,23,1,21,31,42,21};//定义一个数组并初始化
Arrays.sort(array);//调用Arrays中的sort方法
System.out.println(Arrays.toString(array));//调用Arrays中的toString方法将数组内容打印
}
3.求 2/1+3/2+5/3+8/5+13/8.....前20项之和?
public static void main(String[] args) {
double sum=0;//定义一个求和变量,因为是分数,所以sum为double
double x=2,y=1;//定义x变量为分子,y为分母
for (int i = 0; i <20 ; i++) {
sum+=x/y;//将每一个项数加到sum里面
double t=x;//提前记录一下x,下一步会修改x的值
x=t+y;//分子为前一项的分子和分母的和
y=t;//分母为前一项的分子
}
System.out.println(sum);
}
4.计算圆周率:
public static double PI(double C,double r){
return C/(2*r);//C为周长,r为半径,π=C/(2*r)
}
5.定义两个数3和10,输出大数和小数
public static void main(String[] args) {
int x1=3;
int x2=10;
if(x1>x2){
System.out.println(x1+"是大数"+","+x2+"是小数");
} else if (x1==x2) {
System.out.println(x1+"和"+x2+"两数相等");
} else {
System.out.println(x1+"是小数"+","+x2+"是大数");
}
}
6. 用if..else语句,判断一个数字是奇数还是偶数
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int x=scanner.nextInt();//输入一个数
if (x%2==0){//如果一个数模2取余为0,则是偶数,否则是奇数
System.out.println(x+"是偶数");
}else {
System.out.println(x+"是奇数");
}
}
7. 定义两个数3和10,用三目运算符输出最大数
public static void main(String[] args) {
int x1=3;
int x2=10;
System.out.println(x1>x2?x1:x2);//使用?三目操作符,x1大于x2吗?大于的话输出x1,否则输出x2
}
8. 定义两个数3和10,用if语句输出最大数
public static void main(String[] args) {
int x=3;
int y=10;
if (x>y){
System.out.println(x);
} else {
System.out.println(y);
}
}
9.用while输出1+2+……+10的和
public static void main(String[] args) {
int sum=0;
int i=1;
while (i<=10){
sum+=i;
i++;
}
System.out.println(sum);
}
10.用do while语句 输出1+2+……+10的和
public static void main(String[] args) {
int sum=0;
int i=1;
do {
sum+=i;
i++;
}while (i<=10);
System.out.println(sum);
}
11. 用for语句 输出1+2+……+10的和
public static void main(String[] args) {
int sum=0;
for (int i = 1; i <10 ; i++) {
sum+=i;
}
System.out.println(sum);
}
12.输出1-100之间不能被3整除的数
public static void main(String[] args) {
for (int i = 1; i <=100 ; i++) {
if (i%3!=0){
System.out.print(i+" ");
}
}
}
13.定义数组,数组元素的值为67,89,87,69,90,100,75,90,用循环找出数组的最大数和最小数
public static void main(String[] args) {
int []array={67,89,87,69,90,100,75,90};
int max=array[0];//假设最大值和最小值都为array[0]
int min=array[0];
for (int i = 1; i <array.length ; i++) {//遍历数组
if (array[i]>max){//如果i下标的值大于max,就将i下标的赋给max
max=array[i];
}
if (array[i]<min){
min=array[i];//如果i下标的值小于min,就将i下标的赋给min
}
}
System.out.println("最小值为:"+min+"最大值为:"+max);
}
14.定义方法addInt()和addFloat(),第一个方法能求两个整数的和, 第二个方法能求两个实数的和,写测试类,调用这两个方法
public class T1 {
public static void main(String[] args) {
System.out.println(addInt(10,20));
System.out.println(addFloat(12.2f,12.6f));//注意float类型的数据需要再后面加f标识
}
public static int addInt(int x,int y){
return x+y;
}
public static float addFloat(float x,float y){
return x+y;
}
}
15.用递归方法求5!
public static void main(String[] args) {
System.out.println(fac(5));
}
public static int fac(int x){
if(x==1){
return 1;
}else {
return x*fac(x-1);
}
}
}
16.定义Person类,Person类有name和age属性,有方法tell()输出Person实例的姓名和年龄,定义测试类,创建Person对象person他的名字叫Tom,年龄18,person调用tell()方法输出它的姓名和年龄
Person类:
public class Person {
public String name;
public int age;
public void tell(){
System.out.println("姓名:"+name+",年龄:"+age);
}
}
测试类:
public class T1 {
public static void main(String[] args) {
Person person=new Person();
person.name="Tom";
person.age=18;
person.tell();
}
}
17. 定义Person类,Person类有name和age属性,
有方法tell()输出Person实例的姓名和年龄,
有构造方法实现对域的初始化
定义测试类,创建Person对象person他的名字叫Tom,年龄18,person调用tell()方法输出它的姓名和年龄
Person类:
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void tell(){
System.out.println("姓名:"+name+",年龄:"+age);
}
}
测试类:
public class T1 {
public static void main(String[] args) {
Person person=new Person("Tom",18);
person.tell();
}
}
18. 定义父类Person和子类Student,父类有非私有的name和age,有两个构造方法,一个是无参的构造方法,一个是有参的构造方法,子类有自己的属性school,有无参的和有三个参数的构造方法
父类:
public class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
}
子类:
public class Student extends Person{
private String school;
public Student(String name, int age, String school) {
super.name=name;
super.age=age;
this.school = school;
}
public Student(String school) {
this.school = school;
}
}
19. 定义父类Person和子类Student,父类有非私有的name和age,有两个构造方法,一个是无参的构造方法,一个是有参的构造方法,子类有自己的属性school,有无参的和有三个参数的构造方法,其中第二个构造方法在初始化时要调用父类的构造方法
父类:
public class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
}
子类:
public class Student extends Person{
private String school;
public Student(String name, int age, String school) {
super(name, age);
this.school = school;
}
public Student(String school) {
this.school = school;
}
}
20. 定义抽象父类Person,子类Student,父类有非私有的name和age,有两个构造方法,一个是无参的构造方法,一个是有参的构造方法,有一个抽象的方法String getInfo(),子类有自己的属性school,有无参的和有三个参数的构造方法,要求在子类中重写抽象方法,并输出子类的各项信息
父类:
public abstract class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
abstract String getInfo();
}
子类:
public class Student extends Person{
private String school;
public Student(String name, int age, String school) {
super.name=name;
super.age=age;
this.school = school;
}
public Student() {
}
@Override
String getInfo() {
System.out.println("姓名:"+name+", 年龄:"+age+",学校:"+school);
return "姓名:"+name+", 年龄:"+age+",学校:"+school;
}
}
21.定义一个接口A,有一个String的常量值为Java的 s,有void 的print()方法和String 的getInfo()方法,类X是A的实现类,类A的print()方法输出常量s,方法getInfo()返回“Hello!!!”
接口A:
public interface A {
final String s = "Java的s";
void print();
String getInfo();
}
类X:
public class X implements A{
@Override
public void print() {
System.out.println(s);
}
@Override
public String getInfo() {
return "Hello!!!";
}
}
22. 定义一个接口A,有一个String的常量值为Java的 s,有void 的print()方法,定义一个接口B,B中有String 的getInfo()方法,类X是接口A和B的实现类,类A的print()方法输出常量s,方法getInfo()返回“Hello!!!”
接口A:
public interface A {
final String s = "Java的s";
void print();
}
接口B:
public interface B {
String getInfo();
}
类X:
public class X implements A,B{
@Override
public void print() {
System.out.println(s);
}
@Override
public String getInfo() {
return "Hello!!!";
}
}
23. 定义一个接口A,有一个String的常量值为Java的 s,有void 的print()方法,定义一个接口B,B是A的子接口,B接口有String 的getInfo()方法,类X是接口A和B的实现类,类X的print()方法输出常量s,方法getInfo()返回“Hello!!!”
接口A:
public interface A {
final String s = "Java的s";
void print();
}
接口B:
public interface B extends A{
String getInfo();
}
类X:
public class X implements A,B{
@Override
public void print() {
System.out.println(s);
}
@Override
public String getInfo() {
return "Hello!!!";
}
}
24. 定义一个接口A,有一个String的常量值为Java的 s,有void 的print()方法,定义一个接口B,抽象类B有String 的抽象方法getInfo(),类X是接口A和类B的实现类,类A的print()方法输出常量s,方法getInfo()返回“Hello!!!”
接口A:
public interface A {
final String s = "Java的s";
void print();
}
接口B:
public interface B {
abstract String getInfo();
}
类X:
public class X implements A,B{
@Override
public void print() {
System.out.println(s);
}
@Override
public String getInfo() {
return "Hello!!!";
}
}
25. 定义一个接口A,有一个String的常量值为Java的 s,有void 的print()方法,定义一个接口B,抽象类B是类A实现类,且有String 的抽象方法getInfo(),类X是类B的实现类,类X的print()方法输出常量s,方法getInfo()返回“Hello!!!”
接口A:
public interface A {
final String s = "Java的s";
void print();
}
接口B:
public interface B extends A{
abstract String getInfo();
}
类X:
public class X implements B{
@Override
public void print() {
System.out.println(s);
}
@Override
public String getInfo() {
return "Hello!!!";
}
}
26.定义一个接口A,有void 的printA()方法,定义一个接口B,有void 的printB()方法,接口C继承接口A和接口B,且有void 的printC()方法,类X是接口C的实现类。
接口A:
public interface A {
void printA();
}
接口B:
public interface B extends A{
void printB();
}
接口C:
public interface C extends A,B{
void printC();
}
类X:
public class X implements C{
@Override
public void printA() {
}
@Override
public void printB() {
}
@Override
public void printC() {
}
27. 定义一个接口A,有void 的printA()方法,定义一个接口B,有void 的printB()方法,类X是接口A和接口B的实现类。
接口A:
public interface A {
void printA();
}
接口B:
public interface B{
void printB();
}
类X:
public class X implements A,B{
@Override
public void printA() {
}
@Override
public void printB() {
}
}
28. 定义一个接口A,有void 的printA()方法,定义一个接口B,有void 的printB()方法,抽象类C有抽象方法void 的printC()方法,X类是接口A和抽象类C的实现类。
接口A:
public interface A {
void printA();
}
接口B:
public interface B{
void printB();
}
抽象类C:
public abstract class C {
abstract void printC();
}
X类:
public class X extends C implements A{
@Override
public void printA() {
}
@Override
void printC() {
}
}
29. 定义一个有5个整型数的数组,将数组元素倒序存放并输出
public static void main(String[] args) {
int []array={1,2,3,4,5};
int l=0;//l为第一个元素下标
int r=array.length-1;//r为最后一个元素下标
while(l<=r){//交换l和r下标的元素,l往后移动,r往前移动
int t=array[l];
array[l]=array[r];
array[r]=t;
l++;
r--;
}
System.out.println(Arrays.toString(array));//打印数组元素
}
30.求1-100间奇数的和
public static void main(String[] args) {
int sum=0;
for (int i = 1; i <=100 ; i++) {//遍历1~100
if(i%2!=0){//如果i%2!=0,那么i就是奇数
sum+=i;//将奇数i加到sum里面
}
}
System.out.println(sum);
}
31.使用do…while循环语句计算正数5的阶乘。
public static void main(String[] args) {
int x=1;
int i=1;
do {
x*=i;
i++;
}while(i<=5);
System.out.println(x);
}
32.
某公司正进行招聘工作,被招聘人员需要填写个人信息,编写“个人简历”的封装类Resume,并编写测试类进行实现。类图及输出效果如下。
类名:Resume
name : String (private)
sex : String (private)
age : int (private)
Resume( ) // 没有参数的空构造方法
Resume(Srting name, String sex, int age)
// 得到各个属性值的方法getXxx( )
introduce( ) : void // 自我介绍(利用属性)
程序运行结果如下:
我是:李四,性别:男,年龄:20
public class Resume {
private String name;
private String sex;
private int age;
public Resume() {
}
public Resume(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public String getSex() {
return sex;
}
public int getAge() {
return age;
}
public void introduce(){
System.out.println("我是:"+name+",性别:"+sex+"年龄:"+age);
}
}
33. 某公司正进行招聘工作,被招聘人员需要填写个人信息,编写“个人简历”的封装类Resume,并编写测试类进行实现。类图及输出效果如下。
类名:Resume
name : String (private)
age : int (private)
Resume( ) // 没有参数的空构造方法
Resume(Srting name, int age)
// 得到各个属性值的方法getXxx( )
introduce( ) : void // 自我介绍(利用属性)
程序运行结果如下:
我是:李四,性别:男,年龄:20
public class Resume {
private String name;
private int age;
public Resume() {
}
public Resume(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void introduce(){
System.out.println("我是:"+name+",性别:男+"年龄:"+age);
}
}
34. 已知函数
x + 3 ( x > 0 )
y= 0 ( x = 0 )
x2 –1 ( x < 0 )
请设计一个方法实现上面的函数,根据传入的值x的不同,返回对应的y值。
public static int xxx(int x){
if (x>0){
return x+3;
} else if (x==0) {
return 0;
}else {
return 2*x-1;
}
}
35. 已知函数
x- 3 ( x > 0 )
y = 5 ( x = 0 )
x ( x < 0 )
请设计一个方法实现上面的函数,根据传入的值x的不同,返回对应的y值。
public static int xxx(int x){
if (x>0){
return x-3;
} else if (x==0) {
return 5;
}else {
return x;
}
}
36.请按照以下要求设计一个学生类Student,并进行测试。
要求如下:
1)Student类中包含姓名、成绩两个属性
2)分别给这两个属性定义两个方法,一个方法用于设置值,另一个方法用于获取值.
3)Student类中定义一个无参的构造方法和一个接收两个参数的构造方法,两个参数分别为姓名和成绩属性赋值
4)在测试类中创建两个Student对象,一个使用无参的构造方法,然后调用方法给姓名和成绩赋值,一个使用有参的构造方法,在构造方法中给姓名和成绩赋值
Student类:
public class Student {
private String name;
private double grades;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getGrades() {
return grades;
}
public void setGrades(double grades) {
this.grades = grades;
}
public Student() {
}
public Student(String name, double grades) {
this.name = name;
this.grades = grades;
}
}
测试类:
public static void main(String[] args) {
Student student1=new Student();
student1.setName("李四");
student1.setGrades(99);
Student student2=new Student("张三",100);
}
37.请按照以下要求设计一个学生类Student,并进行测试。
要求如下:
1)Student类中包含姓名、年龄两个属性
2)分别给这两个属性定义两个方法,一个方法用于设置值,另一个方法用于获取值.
3)Student类中定义一个无参的构造方法和一个接收两个参数的构造方法,两个参数分别为姓名和成绩属性赋值
4)在测试类中创建两个Student对象,一个使用无参的构造方法,然后调用方法给姓名和年龄赋值,一个使用有参的构造方法,在构造方法中给姓名和年龄赋值
和36题一样,只是把成绩换成了年龄
38.
请按照以下要求设计一个学生类Student,并进行测试。
要求如下:
1)Student类中包含姓名、学校两个属性
2)分别给这两个属性定义两个方法,一个方法用于设置值,另一个方法用于获取值.
3)Student类中定义一个无参的构造方法和一个接收两个参数的构造方法,两个参数分别为姓名和学校属性赋值
4)在测试类中创建两个Student对象,一个使用无参的构造方法,然后调用方法给姓名和学校赋值,一个使用有参的构造方法,在构造方法中给姓名和学校赋值
和36题一样,只是把成绩换成了学校
39.请按照以下要求设计一个学生类Student,并进行测试。
要求如下:
1)Student类中包含学号、姓名两个属性
2)分别给这两个属性定义两个方法,一个方法用于设置值,另一个方法用于获取值.
3)Student类中定义一个无参的构造方法和一个接收两个参数的构造方法,两个参数分别为姓名和学号属性赋值
4)在测试类中创建两个Student对象,一个使用无参的构造方法,然后调用方法给姓名和年龄赋值,一个使用有参的构造方法,在构造方法中给姓名和年龄赋值
和36题一样,只是把成绩换成了学号
40. 请按照以下要求设计一个学生类Student,并进行测试。
要求如下:
1)Student类中包含姓名、性别两个属性
2)分别给这两个属性定义两个方法,一个方法用于设置值,另一个方法用于获取值.
3)Student类中定义一个无参的构造方法和一个接收两个参数的构造方法,两个参数分别为姓名和性别属性赋值
4)在测试类中创建两个Student对象,一个使用无参的构造方法,然后调用方法给姓名和年龄赋值,一个使用有参的构造方法,在构造方法中给姓名和性别赋值
和36题一样,只是把成绩换成了性别
41.定义一个Father和Child类,并进行测试。
要求如下:
(1)Father类为外部类,类中定义一个私有的String类型的属性name,name的值为“Join”。
(2)Child类为Father类的内部类,其中定义一个readName()方法,方法中调用Father类的name属性。
(3)定义一个测试类Test,在Test类的main()方法中,创建Child对象,并调用readName ()方法。
成员内部类:
class Father{
private String name="Join";
class Child{
public void readName(){
System.out.println("我是"+name);
}
}
}
测试类:
public static void main(String[] args) {
Father.Child child=new Father().new Child();
child.readName();
}
成员内部类创建格式:
外部类.内部类.对象名=外部类对象.内部类对象()
Outer.Inner oi=new Outer().new Inner();
42.定义一个Father和Child类,并进行测试。
要求如下:
(1)Father类为外部类,类中定义一个私有的int类型的属性age,name的值为40。
(2)Child类为Father类的内部类,其中定义一个readAge()方法,方法中调用Father类的age属性。
3)定义一个测试类Test,在Test类的main()方法中,创建Child对象,并调用readAge()方法。
和41题类似
43.设计一个学生类Student和它的一个子类Undergraduate,要求如下:
Student类有name(姓名)、和age(年龄)属性,一个包含两个参数的构造方法,用于给name和age属性赋值,一个show()方法打印Student的属性信息
本科生类Undergraduate增加一个degree(学位)属性。有一个包含三个参数的构造方法,前两个参数用于给继承的name和age属性赋值,第三个参数给degree专业赋值,一个show()方法用于打印Undergraduate的属性信息
Student类:
public class Student {
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void show(){
System.out.println("姓名:"+name+",年龄:"+age);
}
}
Undergraduate类:
public class Undergraduate extends Student{
private String degree;
public Undergraduate(String name, int age, String degree) {
super(name, age);
this.degree = degree;
}
@Override
public void show() {
System.out.println("姓名:"+super.name+"年龄:"+super.age+"学位:"+degree);
}
}
44. 设计一个学生类Student和它的一个子类Undergraduate,要求如下:
Student类有name(姓名)属性,一个包含一个参数的构造方法,用于给name属性赋值,一个show()方法打印Student的属性信息
本科生类Undergraduate增加一个degree(学位)属性。有一个包含二个参数的构造方法,一个参数用于给继承的name属性赋值,一个参数给degree专业赋值,一个show()方法用于打印Undergraduate的属性信息
定义一个测试类,创建一个Undergraduate对象,并输出该对象的属性信息。
和43题类似,只是少了一个年龄
45.请按照题目的要求编写程序并给出运行结果
编写一个程序,实现字符串大小写的转换并倒序输出,要求如下
1)使用for循环将字符串“HelloWorld”,利用字符串的toCharArray()方法将字符串转为字符数组,然后从最后一个字符开始遍历。
2)遍历的当前字符如果是大写字符,就使用toLowerCase()方法将其转换为小写字符,反之则使用toUpperCase() 方法将其转换为大写字符,并将转换后的字符存放在StrngBuffer字符串里。
public static void main(String[] args) {
String str="HelloWorld";
StringBuffer stringBuffer=new StringBuffer();
char []array=str.toCharArray();
for (int i = array.length-1; i >=0 ; i--) {
if(array[i]>='A'&&array[i]<='Z'){
stringBuffer.append(Character.toLowerCase(array[i]));
} else if (array[i]>='a'&&array[i]<='z') {
stringBuffer.append(Character.toUpperCase(array[i]));
}
}
System.out.println(stringBuffer);
}
46.用for循环打印下面图形
![]()
public static void main(String[] args) {
for (int i = 1; i <10 ; i++) {
for (int j = 1; j <=i ; j++) {
System.out.print("*");
}
System.out.println();
}
}
47.定义一个求矩形面积的方法,方法的参数分别为高和宽,写程序测试方法的正确性。
public static void main(String[] args) {
System.out.println(area(10,21));
}
public static double area(double x,double y){
return x*y;
}
48.定义一个求圆面积的方法,方法的参数为圆的半径,写程序测试方法的正确性。
public static void main(String[] args) {
System.out.println(area(10));
}
public static double area(double r){
return Math.PI*r*r;
}
49.定义一个10个元素的数据,初始化10个元素的值为0-9,用循环将每个元素后移,将“100”插入到数据的第1个元素位置。分别输出插入前和插入后数据组信息。
public static void main(String[] args) {
int []array=new int[11];
for (int i = 0; i <10 ; i++) {
array[i]=i+1;
}
System.out.println(Arrays.toString(array));
for (int i = array.length-1; i >0 ; i--) {
array[i]=array[i-1];
}
array[0]=100;
System.out.println(Arrays.toString(array));
}
50.定义animal类,属性有name、age、final的COLOR=”黑色”及name、age的get、set方法,定义它的子类Dog类,写一个测试类,创建dog对象,设置它的name值为边牧,年龄3岁,输出它的上面信息及COLOR值。
animal类:
public class animal {
public String name;
public int age;
public final String COLOR="黑色";
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;
}
}
Dog类:
public class Dog extends animal{
}
测试类:
public static void main(String[] args) {
Dog dog=new Dog();
dog.setName("边牧");
dog.setAge(3);
System.out.println("姓名:"+dog.name+" 年龄:"+dog.getAge()+" 颜色:"+ dog.COLOR);
}
51. 定义animal类,属性有name、age属性及对应的get、set方法,定义它的子类Dog类,定义它的属性color及对应get、set方法,写一个测试类,创建dog对象,设置它的name值为边牧、年龄3岁,颜色为黑白,输出它的上面信息。
和50题类似,只是将final修饰的COLOR变来和name一样,仿造name的格式
52.定义Animal类,有void 的shout()方法,输出“动物发出叫声”。定义它的子类Cat类,重写父类的shout()方法,输出“喵喵喵”,测试类里创建Cat对象并调用shout()方法。
animal类:
public class Animal {
public void shout(){
System.out.println("动物发出叫声");
}
}
Cat类:
public class Cat extends Animal{
@Override
public void shout() {
System.out.println("喵喵喵");
}
}
测试类:
public static void main(String[] args) {
Cat cat=new Cat();
cat.shout();
}
53. 定义Animal类,有void 的shout()方法,输出“动物发出叫声”。定义它的子类Dog类,重写父类的shout()方法,在方法内调用父类的shout()方法,并输出“汪汪汪”,测试类里创建Dog对象并调用shout()方法。
Animal类:
public class Animal {
public void shout(){
System.out.println("动物发出叫声");
}
Dog类:
public class Dog extends Animal{
@Override
public void shout() {
super.shout();
System.out.println("汪汪汪");
}
}
测试类:
public static void main(String[] args) {
Dog dog=new Dog();
dog.shout();
}
54. 定义Animal类,有name和age属性、构造方法和返回字符串的name和age方法info()。定义它的子类Dog类,子类有自己的color和构造方法和info(),测试类里创建Dog对象并调用它的info()方法,要求能输出dog对象的name、age和color。
Animal类:
public class Animal {
public String name;
public int age;
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String info(){
return "姓名:"+name+" 年龄:"+age;
}
}
Dog类:
public class Dog extends Animal {
public String color;
public Dog(String name, int age, String color) {
super(name, age);
this.color = color;
}
@Override
public String info() {
return "姓名:"+name+" 年龄:"+age+" 颜色:"+color;
}
}
测试类:
public static void main(String[] args) {
Dog dog=new Dog("边牧",2,"黑色");
System.out.println(dog.info());
}
55. 定义Animal类,有name和sex属性、构造方法和返回字符串的name和sex方法info()。定义它的子类Dog类,子类有自己的color和构造方法和info(),测试类里创建Dog对象并调用它的info()方法,要求能输出dog对象的name、sex和color。
和54题类似
56.定义Animal类,有void 的eat()方法,输出“动物都要进食”。定义它的子类Dog类,重写父类的eat()方法,在方法内调用父类的eat()方法,并输出“狗爱吃狗狼”,测试类里创建Dog对象并调用eat()方法。
和53题类似
57. 定义一个求圆的周长的方法,方法的参数为圆的半径,写程序测试方法的正确性。
public static void main(String[] args) {
System.out.println(circumference(2));
}
public static double circumference(double r){
return Math.PI*2*r;
}
58.定义一个求矩形周长的方法,方法的参数分别为高和宽,写程序测试方法的正确性。
public static void main(String[] args) {
System.out.println(circumference(2,2));
}
public static double circumference(double x,double y){
return 2*(x+y);
}
59.定义一个求正方形面积的方法,方法的参数为边长,写程序测试方法的正确性。
public static void main(String[] args) {
System.out.println(area(2));
}
public static double area(double x){
return x*x;
}
60.定义一个求正方形周长的方法,方法的参数为正方形的边长,写程序测试方法的正确性。
public static void main(String[] args) {
System.out.println(circumference(4));
}
public static double circumference(double x){
return 4*x;
}
61.使用Double类型的相关方法将字符串转换为double类型数据。使用键盘录入字符串,将字符串类型数据转换为double类型数据,计算两个double数据的和。用户使用程序时可能会出现数据转换异常,如果出现异常,程序输出"输入数据类型错误!程序结束!“。请在main()方法中使用try...catch结构编写程序实现功能。
public static void main(String[] args) {
try {
Scanner sc=new Scanner(System.in);
String str1=sc.nextLine();
String str2=sc.nextLine();
double x=Double.valueOf(str1)+Double.valueOf(str2);
System.out.println(x);
} catch (NumberFormatException e) {
System.out.println("输入数据类型错误!程序结束!");
}
}
62.使用Double类型的相关方法将字符串转换为double类型数据。使用键盘录入字符串,将字符串类型数据转换为double类型数据,计算两个double数据的和。用户使用程序时可能会出现数据转换异常,如果出现异常,程序输出"输入数据类型错误!程序结束!“。请设计与main()方法在同一类中的public static double jisuan (String str1,String str2)方法,并使用method signature方式处理异常请在main()方法中使用try...catch结构编写程序实现功能。
public static void main(String[] args) {
try {
Scanner sc=new Scanner(System.in);
String str1= sc.nextLine();
String str2=sc.nextLine();
double x=jisuan(str1,str2);
} catch (NumberFormatException e) {
System.out.println("输入数据类型错误!程序结束!");
}
}
public static double jisuan(String str1,String str2)throws NumberFormatException {
double x = Double.valueOf(str1);
double y = Double.valueOf(str2);
return x+y;
}
}
63.使用键盘录入两个int类型数据,并计算二者的商。不考虑输入错误,用户使用程序时可能会出现异常,如果出现异常,程序输出“除数为零,错误!程序结束!”。请在main()方法中使用try...catch结构编写程序实现功能。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
try {
int x= sc.nextInt();
int y= sc.nextInt();
System.out.println(x/y);
} catch (Exception e) {
System.out.println("除数为零,错误!程序结束!");
}
}
64.使用键盘录入两个int类型数据,并计算二者的商。不考虑输入错误,用户使用程序时可能会出现异常,如果出现异常,程序输出“除数为零,错误!程序结束!”。请设计与main()方法在同一类中的public static int divide(int x,int y)方法,并使用method signature方式处理异常。请在main()方法中使用try...catch结构编写程序实现功能。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
try {
int x= sc.nextInt();
int y=sc.nextInt();
System.out.println(divide(x,y));
} catch (ArithmeticException e) {
System.out.println("除数为零,错误!程序结束!");
}
}
public static int divide(int x,int y)throws ArithmeticException{
return x/y;
}
65.使用键盘录入两个int类型数据,并计算二者的商。不考虑输入错误,用户使用程序时可能会出现异常,如果出现异常,程序输出“除数为零,错误!程序结束!”。 请设计与main()方法在同一类中的public static int divide(int x,int y)方法,并在其中使用try...catch结构方式处理异常。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
try {
int x= sc.nextInt();
int y= sc.nextInt();
System.out.println(divide(x, y));
} catch (Exception e) {
System.out.println("除数为零,错误!程序结束!");
}
}
public static int divide(int x,int y){
return x/y;
}
66.编制程序输出1到10的自然数,发现当前自然数是5的倍数时,在输出当前数的同时抛出异常。异常对象中含有信息:"现在的数是5的倍数"。
程序运行结果:
1 2 3 4 5 现在的数是5的倍数
6 7 8 9 10 现在的数是5的倍数
public static void main(String[] args) {
for (int i = 1; i <=10 ; i++) {
try {
System.out.print(i+" ");
if (i%5==0){
throw new RuntimeException("现在的数是5的倍数");
}
} catch (RuntimeException e) {
System.out.println(e.getMessage());
}
}
}
67.使用Double类型的相关方法将字符串转换为double类型数据。使用键盘录入字符串,将字符串类型数据转换为double类型数据,计算两个double数据的和。用户使用程序时可能会出现数据转换异常,如果出现异常,程序输出“输入数据类型错误!程序结束!”。用户使用程序时,无论是否出现异常,程序都会输出信息“欢迎下次使用!”。请在main()方法中使用try...catch结构编写程序实现功能。
public static void main(String[] args) {
try {
Scanner sc=new Scanner(System.in);
String str1=sc.nextLine();
String str2=sc.nextLine();
System.out.println(Double.valueOf(str1)+Double.valueOf(str2));
} catch (NumberFormatException e) {
System.out.println("输入数据类型错误!程序结束!");
}finally {
System.out.println("欢迎下次使用!");
}
}
68.检测从键盘获取的字符串中是否含有数字符号。 如果发现有数字符号在字符串中出现,则抛出异常,异常对象中含有信息:“发现目标!”。 程序输出:"发现目标!"。程序结束。请编制程序,完成需求的功能。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
try {
for (char c:str.toCharArray()) {
if (Character.isDigit(c)){
throw new RuntimeException("发现目标");
}
}
} catch (RuntimeException e) {
System.out.println(e.getMessage());
}
}
69.从键盘获取字符串str及将要在str中进行统计的指定字符串,输出指定字符串在str中出现的次数。例如:“uabcshyduabchdjabcsk”中含有“abc”的次数是3。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();//输入字符串
String ch=sc.nextLine();//输入要查找的字符串
int count=0;//记录目标字符串的参数
int index=str.indexOf(ch);//找到第一次出现的位置
while (index!=-1){//如果没有则返回-1
count++;
index=str.indexOf(ch,index+ch.length());//当前目标字符串位置+目标字符串长度处开始寻找
}
System.out.println(count);
}
70.从键盘获取字符串str及将要在str中进行统计的指定字符,输出指定字符在str中出现的次数。 例如:“uabcshyduabchdjabcsk”中含有‘a’的次数是3。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
char ch=sc.nextLine().charAt(0);
int count=0;
for (int i = 0; i <str.length() ; i++) {
if (str.charAt(i)==ch){
count++;
}
}
System.out.println(count);
}
71. System.currentTimeMillis()能够获取:“the difference, measured in milliseconds, between the current time and midnight, January 1, 1970 UTC.”在不考虑时区的情况下请使用它获取当前的系统时间。
public static void main(String[] args) {
long curr=System.currentTimeMillis();
System.out.println("当前时间:"+curr);
}
72.生成10个 [13,56]的自然数,并在一行输出,数据采用空格进行分隔,最后一个数据后面无空格。
public static void main(String[] args) {
Random random=new Random();
for (int i = 0; i <10 ; i++) {
int ra= random.nextInt(13,56);
if (i==9){
System.out.println(ra);
}else {
System.out.print(ra+" ");
}
}
}
73.生成10个[a,b]之间的自然数,并在一行输出,数据采用空格进行分隔,最后一个数据后面无空格。 a 和 b 从键盘获取。
public static void main(String[] args) {
Random random=new Random();
Scanner sc=new Scanner(System.in);
int a= sc.nextInt();
int b= sc.nextInt();
for (int i = 0; i <10 ; i++) {
int ra= random.nextInt(a,b);
if (i==9){
System.out.println(ra);
}else {
System.out.print(ra+" ");
}
}
}
74.任意角a,请编程计算:sin3a=4sinasin(π/3+a)sin(π/3-a)。 请从键盘获取a,输入为角度。例如输入30 则计算sin3a的值为 1。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a= sc.nextInt();
System.out.println(4*Math.sin(Math.PI/3+a)*Math.sin(Math.PI/3-a));
}
75.Calendar类用于完成日期和时间段的操作,请使用它获取系统当前时间。 输出的格式为:xxxx年xx月xx日空格xx:xx:xx。 例如:2023年7月5日 6:26:52
public static void main(String[] args) {
Calendar ca=Calendar.getInstance();
System.out.println(ca.get(Calendar.YEAR)+"年"+(ca.get(Calendar.MONTH)+1)
+"月"+ ca.get(Calendar.DAY_OF_MONTH)+"日 "+ ca.get(Calendar.HOUR_OF_DAY)+":"
+ ca.get(Calendar.MINUTE)+":"+ ca.get(Calendar.SECOND));
}
76.从键盘获得一个字符串,将其中我们不喜欢的字符串去除,形成一个新的字符串输出。
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
String str1= scanner.nextLine();
String str2=scanner.nextLine();
String []strings=str1.split(str2);
StringBuilder sbr=new StringBuilder();
for (int i = 0; i <strings.length ; i++) {
sbr.append(strings[i]);
}
System.out.println(sbr);
}
77.机器人A和机器人B,它们有共同点,就是都有名字,不同的是A会唱歌,B会走路。 A在唱歌的方法中输出“我想唱歌”;B在走路的方法中输出“脚踏实地!”。请使用接口技术实现它们,并测试。
public interface IK {
void per();
}
public class A implements IK{
@Override
public void per() {
System.out.println("我想唱歌");
}
}
public class B implements IK{
@Override
public void per() {
System.out.println("脚踏实地");
}
}
public static void main(String[] args) {
A a=new A();
B b=new B();
a.per();
b.per();
}
78.机器人A和机器人B,它们有共同点,就是都有名字,不同的是A会唱歌,B会走路。A在唱歌的方法中输出“我想唱歌”;B在走路的方法中输出“脚踏实地!”。请使用继承技术实现它们,并测试。
和上一题类似
79.类A中已有showA()方法,其功能是输出"我是A中的方法!"。在不改变类A结构的前提下,想要扩充一个输出”我是扩充的功能!“的expend()方法。请使用接口技术实现并测试。
class A implements Ikuo{
public static void main(String[] args) {
}
public static void showA(){
System.out.println("我是类A中的showA方法");
}
@Override
public void expend() {
}
}
public interface Ikuo {
void expend();
}
80.类W中已有showA()方法,其功能是输出"我是A中的方法!"。在不改变类A结构的前提下,想要扩充一个输出”我是扩充的功能!“的expend()方法。请使用继承技术实现并测试
和上题类似
81.输入一个整数,判断是不是素数。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int x= sc.nextInt();
if (x%2!=0){
System.out.println(x+"是素数");
}else {
System.out.println(x+"是偶数");
}
}
82.打印1~100之间的素数
public static void main(String[] args) {
for (int i = 1; i <=100 ; i++) {
if (i%2!=0){
System.out.print(i+" ");
}
}
}
83.输入一个年份,判断其是不是闰年
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int year= sc.nextInt();
if ((year%4==0&&year%100!=0)||year%400==0){
System.out.println(year+"是闰年");
}else {
System.out.println(year+"不是闰年");
}
}
84.统计1~1000之间出现了几次数字8
public static void main(String[] args) {
int count=0;
for (int i = 1; i <=1000 ; i++) {
int x=i;
while(x!=0){
if (x%10==8){
count++;
}
x/=10;
}
}
System.out.println(count);
}
85.输入一个位置编号,将数组{10,11,13,14,15}该位置的数据元素删除,输出删除该数据元素后的数组。
public static void main(String[] args) {
int []array={10,11,13,14,15};
int size=array.length;
Scanner sc=new Scanner(System.in);
int pos= sc.nextInt();
for (int i = pos; i <array.length-1 ; i++) {
array[i]=array[i+1];
size--;
}
for (int i = 0; i <=size ; i++) {
System.out.print(array[i]+" ");
}
}
86.求纳税款和实得工资数不同工资s的税率p如下:
s < 1000 p = 0 %
1000 <= s < 2000 p = 5 %
2000 <= s < 3000 p = 8 %
3000 <= s < 5000 p = 10 %
5000 <= s p = 15 %
要求:采用switch选择结构实现。
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
double s= sc.nextDouble();
double s1=0;
double s2=0;
switch ((int) (s/1000)){
case 0:s1=s;s2=0;
break;
case 1:s2=s*0.05;s1=s-s2;
break;
case 2:s2=s*0.08;s1=s-s2;
break;
case 3,4:s2=s*0.1;s1=s-s2;
break;
default:s2=s*0.15;s1=s-s2;
break;
}
System.out.println("实际工资:"+s1+" 纳税款:"+s2);
}
87.定义一个图书类,属性编号、书名、作者、单价。其功能包括获取图书信息,通过构造方法进行初始化。编写测试类进行实现。类图及输出效果如下:
类名:Book
bookNumber : String (private)
bookName: String (private)
author:String (private)
price : double (private)
Book(String bookNumber, String bookName, String author, double price)
setXxx( ):void// 设置各个属性值的方法
getXxx( ):返回值类型与对应属性类型相同// 得到各个属性值的方法
toString():String //方法重写,将图书全部属性信息组成字符串,返回该字符串。
程序运行结果如下:
Book{bookNumber='b001', bookName='Java程序设计基础', author='韩梅', price=54.2}
Book类:
public class Book {
private String bookNumber;
private String bookName;
private String author;
private double price;
public Book(String bookNumber, String bookName, String author, double price) {
this.bookNumber = bookNumber;
this.bookName = bookName;
this.author = author;
this.price = price;
}
public String getBookNumber() {
return bookNumber;
}
public void setBookNumber(String bookNumber) {
this.bookNumber = bookNumber;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"bookNumber='" + bookNumber + '\'' +
", bookName='" + bookName + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
测试:
public static void main(String[] args) {
Book book=new Book("b001","Java程序设计基础", "韩梅", 54.2);
System.out.println(book.toString());
}
88.定义一个圆形类,属性包括圆心点坐标,其功能计算圆心与(0,0)点间距离,通过构造方法进行初始化。编写测试类,实现从键盘输入圆心坐标,输出圆心与(0,0)点距离。类图及输出效果如下:
类名:Circle
centerX: double (private)
centerY: double (private)
Circle(double centerX,double centerY)
Distance():double//计算圆心与(0.0)点间距离。
程序运行结果如下:
请输入圆心的X轴坐标:3
请输入圆心的Y轴坐标:-1
该圆圆心到(0,0)点的距离为:3.1622776601683795
Circle类:
public class Circle {
private double centerX;
private double centerY;
public Circle(double centerX, double centerY) {
this.centerX = centerX;
this.centerY = centerY;
}
double Distance(){
return Math.sqrt(centerX*centerX+centerY*centerY);
}
}
测试类:
public static void main(String[] args) {
Circle circle=new Circle(3,3);
System.out.println(circle.Distance());
}
89.一个景区根据游客的不同年龄段来进行收费,编写一个游客类,能够根据游客年龄设置游客票价。价格标准为:0<age<12,票价20元;12<=age<20,票价40元;20<=age<50,票价80元;50<=age,票价35元。编写测试类,进行测试:通过无参构造方法,构造游客1,通过键盘输入游客年龄及设置票价;通过有参构造方法构造游客2,通过参数初始化年龄并设置票价,输出游客1及2的票价。类图及输出效果如下:
类名:Tourist
age:int (private)
price: int (private)
Tourist()//从键盘输入年龄,设置年龄及票价
Tourist(int age)//由形参设置年龄,设置票价
setPrice():void// 实现根据年龄设置票价属性值
getPrice():int// 返回票价值
程序运行结果如下:
--获取游客1的票价--
请输入年龄:12
游客1的票价:40
--获取游客2的票价--
请输入年龄:67
游客1的票价:35
测试类:
public static void main(String[] args) {
Tourist tourist=new Tourist(13);
tourist.setPrice();
System.out.println(tourist.getPrice());
}
Tourist类:
public class Tourist {
private int age;
private int price;
public Tourist() {
}
public Tourist(int age) {
this.age = age;
}
public int getPrice() {
return price;
}
public void setPrice() {
if (age>0&&age<12){
price=20;
}else if (age>=12&&age<20){
price=40;
} else if (age>=20&&age<50) {
price=80;
}else {
price=35;
}
}
}
90.编写一个类Equation,该类封装了一元二次方程的属性及功能,即该类刻画方程系数的3个成员变量以及计算实根的方法,要求该类所有对象共享常数项。一元二次方程公式如下所示::ax2+bx+c=0,其中a≠0。编写测试类,分别创建两个方程对象,进行测试求解两个方程的实根。
程序运行结果如下:
请输入该方程1的系数a、b:
1 2
请输入该方程2的系数a、b:
1 1
请输入该共享常数项c:
1
方程1的求实根结果是:-1.0,-1.0
方程2的求实根结果是:该方程没有实数根!
Equation类:
public class Equation {
private int a;
private int b;
public static int c;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public int getB() {
return b;
}
public void setB(int b) {
this.b = b;
}
public void jisuan(int i){
int t=b*b-4*a*c;
if (t>0){
System.out.println("方程"+i+"的求实根结果是:"+((-b+Math.sqrt(t))/2*a)+" "+(-b-Math.sqrt(t))/2*a);
}else if (t==0){
System.out.println("方程"+i+"的求实根结果是:"+((-b+Math.sqrt(t))/2*a));
}else {
System.out.println("方程"+i+"的求实根结果是:该方程没有实数根!");
}
}
}
测试类:
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入该方程1的系数a、b:");
Equation e1=new Equation();
e1.setA(sc.nextInt());
e1.setB(sc.nextInt());
Equation e2=new Equation();
System.out.println("请输入该方程2的系数a、b:");
e1.setA(sc.nextInt());
e1.setB(sc.nextInt());
System.out.println("请输入该共享常数项c:");
Equation.c= sc.nextInt();
e1.jisuan(1);
e2.jisuan(2);
}
91.编写两个类:A和B,A创建的对象可以计算两个正整数的最大公约数,B创建的对象可以计算两个数的最小公倍数。已知 最小公倍数=两个数乘积/两个数的最大公约数,因此要求B类中有一个成员变量是用A类声明对象。编写测试类,分别创建A和B对象,求解最大公约数和最小公倍数。
程序运行结果如下:
请输入两个正整数:24 16
最大公约数是:8
最小公倍数是:48
A:
public class A {
public int jisuan(int a,int b){
int t=a%b;
if (t==0){
return b;
}
while (t!=0){
a=b;
b=t;
t=a%b;
}
return a;
}
}
B:
public class B {
public int jisuan(int x,int y){
return x*y/new A().jisuan(x,y);
}
}
测试:
public static void main(String[] args) {
A a=new A();
B b=new B();
Scanner sc=new Scanner(System.in);
System.out.println("请输入两个正整数:");
int x= sc.nextInt();
int y= sc.nextInt();
System.out.println("最大公约数是:"+a.jisuan(x,y));
System.out.println("最小公倍数是:"+b.jisuan(x,y));
}
92.在服装销售过程中,需要对数量进行统计。定义服装类Clothes,其属性包括服装名称及服装销售数量,服装销售量为类共享数据项。该类功能包括构造服装对象及获取当前服装销售数量,每构造一次服装对象相当于销售一件服装。编写测试类,分别创建两件衣服对象,输出销售数量。
程序运行结果如下:
请输入两件销售服装的名称:李宁
anta
李宁销售后服装销售数量为:1
anta销售后服装销售数量为:2
类Clothes:
public class Clothes {
private String name;
public static int count=0;
public Clothes(String name) {
this.name=name;
count++;
}
public void show(){
System.out.println(name+"销售后服装销售数量为"+count);
}
}
测试类:
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入两件销售服装的名称:");
String name1=sc.nextLine();
String name2=sc.nextLine();
Clothes clothes=new Clothes(name1);
clothes.show();
Clothes clothes1=new Clothes(name2);
clothes1.show();
}
93.类Area为面积计算类,可以计算长方形、圆形及梯形面积。要求:
用方法重载的方式定义类Area中三个求解面积方法,每个方法用于求解一种图形面积。
编写测试类,创建一个Area对象,用其计算长方形、圆形及梯形面积,输出计算结果。
程序运行结果如下:
请输入长方形的长和宽:2 3
该长方形的面积是:6.0
请输入圆形的半径:2
该圆形的面积是:12.566370614359172
请输入梯形的上底、下底和高:1 2 2
该梯形的面积是:3.0
Area类:
public class Area {
public void area(double x,double y){
System.out.println("该长方形的面积是:"+x*y);
}
public void area(double r){
System.out.println("该圆形的面积是:"+Math.PI*r*r);
}
public void area(double x,double y,double z){
System.out.println("该梯形的面积是:"+(x+y)*z/2);
}
}
测试类:
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
Area area=new Area();
System.out.println("请输入长方形的长和宽:");
area.area(sc.nextDouble(), sc.nextDouble());
System.out.println("请输入圆形的半径:");
area.area(sc.nextDouble());
System.out.println("请输入梯形的上底、下底和高:");
area.area(sc.nextDouble(), sc.nextDouble(), sc.nextDouble());
}
94.圆柱体类Cylinder,属性包括底和高,底为圆形Circle类的对象,其功能包括计算圆柱体体积,构造时初始化属性值。圆形Circle类,属性包括半径,其功能包括计算圆形面积。要求:
定义圆柱体类Cylinder计算圆柱体体积时,需要调用圆形的求面积方法求解其底的面积。
编写测试类,创建一个Cylinder对象,计算其体积,输出计算结果
程序运行结果如下:
请输入圆柱体底的半径及圆柱体高:2 4
该圆柱体的体积:50.26548245743669
和上面几题类似
95.设计一个抽象类Car,它有两个子类BYD和HongQi,要求如下:
Car类有抽象方法getInfo(),用来返回车辆信息,信息类型为字符串型。
类BYD实现getInfo()方法,返回信息“BYD”。类HongQi实现getInfo()方法,返回信息“HongQi”。
编写测试类,分别创建一个BYD和HongQi对象,调用它们的getInfo()方法获取车辆信息并输出。
程序运行结果如下:
车辆信息分别为:BYD,HongQi
Car类:
public abstract class Car {
abstract String getInfo();
}
HongQi类;
public class HongQi extends Car{
@Override
String getInfo() {
return "HongQi";
}
}
BYD类:
public class BYD extends Car{
@Override
String getInfo() {
return "BYD";
}
}
测试类:
public static void main(String[] args) {
HongQi hongQi=new HongQi();
BYD byd=new BYD();
System.out.println("车辆信息分别为:");
System.out.println(hongQi.getInfo());
System.out.println(byd.getInfo());
}
96.用循环语句输出以下图形。
public static void main(String[] args) {
for (int i = 0; i <4 ; i++) {
for (int j = 0; j <=i ; j++) {
System.out.print("*");
}
System.out.println();
}
}
97. 求1-100之间的偶数和
public static void main(String[] args) {
int sum=0;
for (int i = 1; i <=100 ; i++) {
if (i%2==0){
sum+=i;
}
}
System.out.println(sum);
}
98.定义一个圆类,圆类的属性有半径,圆类有求周长和面积的方法及构造方法,写一个测试类,能求半径为3.0的圆的周长和面积。
public class Round {
private double r;
public Round(double r) {
this.r = r;
}
public void C(){
System.out.println("圆的周长为:"+Math.PI*2*r);
}
public void S(){
System.out.println("圆的面积为:"+Math.PI*r*r);
}
}
99. 定义一个矩形类,矩形类的属性有长和宽,类内有求矩形周长和面积的方法及相应的构造方法,写一个测试类,能求边长为3.0,4.0矩形的周长和面积。
100. 定义一个正方形类,类的属性有边长,类内有求正方形周长和面积的方法及相应的构造方法,写一个测试类,能求边长为为3.0的正方形周长和面积。
99和100题和98题类似