🥰🥰在此恭敬奉上平台链接:头歌实践教学平台
鄙人普通本科计算机在读学生一枚,第一次写这种文章有点小紧张,初衷当然是记录一下,未来也希望是越来越好。
最近正值暑假突然想回忆一下之前学的java,就把之前学校课程java实验课做的一些题搬上来了,希望也能给做到这些题不知道怎么下手的uu一些帮助。
实验一~实验十二
目录
实验一 java 基本数据结构
1-1 认识java程序
编写简单的java程序
/* 请在程序中的注释下面补充代码*/
public class Welcome {
public static void main(String[] args) {
// 输出一行字符:欢迎来到java程序设计课堂
System.out.print("欢迎来到java程序设计课堂");
}
}
1-2 java程序编写与运行
输出简单菜单
/* 请在程序中的注释下面补充代码,输出以下菜单:
****打字练习****
1.字母练习
2.字母+数字练习
3.全键盘练习
4.过关练习
**************
*/
public class PrintMenu{
public static void main(String[] args) {
//请在下面补充代码
System.out.print("****打字练习****\n");
System.out.print("1.字母练习\n");
System.out.print("2.字母+数字练习\n");
System.out.print("3.全键盘练习\n");
System.out.print("4.过关练习\n");
System.out.print("**************");
}
}
2-1 基本类型数据的输入输出
输入输出教材信息
/*请在下面标注序号的位置补充代码,实现注释中要求的功能*/
import java.util.Scanner;
public class Book {
public static void main(String[] args) {
//定义4个变量,分别表示书名、书号、价格、页数
Scanner sc = new Scanner(System.in);
// String name;
// String number;
// double price;
// int page ;
//输入书名、书号、价格、页数,每行输入一个数据
String name = sc.next();
String number = sc.next();
double page = sc.nextDouble();
int price = sc.nextInt();
//输出书名、书号、价格、页数,每个数据输出为一行
System.out.println("书名:"+ name);
System.out.println("书号:"+ number);
System.out.println("价格:"+ page);
System.out.println("页数:"+ price);
sc.close();
}
}
2-2 用println()实现简单计算器
/*编程实现一个简单的计算器:输入两个整数a和b,输出以下格式的表达式(假设a,b分别为6,4):
6 + 4 = 10
6 – 4 = 2
6 * 4 = 24
6 / 4 = 1
6 % 4 = 2
格式要求:数据和运算符之间有一个空格。
*/
import java.util.Scanner;
public class Calculator
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
// int a,b;
//读取键盘输入的两个整数,第1个赋给a,第2个赋给b
int a = sc.nextInt();
int b = sc.nextInt();
//按照示例中的顺序( = - * / %)计算并输出表达式
System.out.println(a+" + "+b+" = " +(a+b));
System.out.println(a+" - "+b+" = " +(a-b));
System.out.println(a+" * "+b+ " = " +(a*b));
System.out.println(a+" / "+b+" = " +(a/b));
System.out.println(a+" % "+b+" = " +(a%b));
}
}
实验二 基本的运算符和表达式
3-1 算术运算符与算术表达式
计算方程的根
/*计算方程的两个实根*/
public class Equation {
public static void main(String[] args) {
int a=1,b=3,c=2;
double delta;
double x1,x2;
//计算delta的值, 即: b的平方减4ac
delta = Math.pow(b,2) -4*a*c;
//计算x1和x2,其中x1是: (-b+delta的开平方)除以2a
x1 = (-b+Math.sqrt(delta))/(2*a);
x2 = (-b-Math.sqrt(delta))/(2*a);
System.out.println("x1="+x1);
System.out.println("x2="+x2);
}
}
3-2 赋值运算符与赋值表达式
货币兑换
/*货币兑换:输入人民币和日元的汇率,输入人民币数量,计算并输出日元数*/
import java.util.Scanner;
public class ExchangeMoney {
public static void main(String[] args) {
float exchangeRate, yen,rmb;
//3个变量分别表示1元人民币兑换的日元数(汇率)、兑换后的日元数、输入待兑换的人民币数
Scanner sc = new Scanner(System.in);
//(1)输入日元汇率 exchangeRate
exchangeRate=sc.nextFloat();
//(2)输入待兑换的人民币数 rmb
rmb=sc.nextFloat();
//(3)计算可兑换的日元数 yen
yen = rmb*exchangeRate;
//(4)输出结果
System.out.printf("%.1f人民币 = %.1f日元", rmb , yen );
}
}
3-3 综合应用
交换两个变量的值
/*交换两个变量的值。输入任意两个整数,分别存入变量data1 和data2,交换两个变量的值。输出交换前和交换后的两个变量的值。*/
import java.util.Scanner;
public class ExchangeData {
public static void main(String[] args) {
int data1,data2,temp; //data1和data2表示输入的两个整数,temp为中间变量
//(1)输入 两个整数,分别赋给data1和data2
Scanner sc = new Scanner(System.in);
data1 = sc.nextInt();
data2 = sc.nextInt();
System.out.printf("交换前:data1=%d,data2=%d\n",data1,data2);
//(2)交换 data1 和data2的值
temp = data1;
data1 = data2;
data2 = temp;
//输出结果
System.out.printf("交换后:data1=%d,data2=%d\n",data1,data2);
}
}
整数拆分
/*整数拆分。输入任意一个三位的整数,计算其百位、十位、个位数。
* 若输入478,则输出格式为:百位4十位7个位8*/
import java.util.Scanner;
public class SplitInteger {
public static void main(String[] args) {
int data; //data表示输入的整数
int bai,shi,ge; //表示百位、十位、个位数
//(1)输入整数,赋给data
Scanner sc = new Scanner(System.in);
data = sc.nextInt();
//(2)拆分:计算百位、十位、个位数
bai = data/100;
shi = data/10%10;
ge = data%10;
//(3)输出结果
System.out.printf("百位"+bai+"十位"+shi+"个位"+ge, bai,shi,ge);
}
}
数字字符转换为整数
import java.util.Scanner;
/*数字与数字字符转换。输入任意一个数字字符,将其转换为对应的整数。比如,输入字符’8’, 输出整数:8*/
public class CharToInt
{
public static void main(String[] args)
{
char ch; //ch表示从键盘读入的字符
int data; //转换后的整数
//(1)输入字符,赋给ch
Scanner sc = new Scanner(System.in);
ch = sc.next().charAt(0);
//(2)计算字符ch对应的整数data
data=(int)ch-48;
System.out.printf("%d",data );
}
}
译密码
/*译密码。输入一个小写英文字符,将其转换为其后的第3个字符。*/
import java.util.Scanner;
public class TranslateChar {
public static void main(String[] args) {
char ch1,ch2; // 分别表示输入的字符、翻译后的字符
//(1)输入字符,赋给ch1
Scanner sc = new Scanner(System.in);
ch1 = sc.next().charAt(0);
//(2)翻译: 计算其后的第三个字符
int a;
if((int)ch1==120){
a=97;
}
else if((int)ch1==121){
a=98;
}
else if((int)ch1==122){
a=99;
}
else{
a=(int)ch1+3;
}
ch2=(char)a;
//输出结果
System.out.println(ch2);
}
}
实验三 分支语句
4-1 if语句入门
判闰年
/*输入一个年份year,判断是否是闰年。判断某年是润年应满足以下两个条件之一:
该年份year能被4整除但不能被100整除,或该年份year能被400整除。
*/
import java.util.Scanner;
public class LeapYear
{
public static void main(String[] args)
{
int year;
int flag = 0;
//(1)输入年份year
Scanner input = new Scanner(System.in);
//(2)判断并输出结果
if(input.hasNextInt()){
year = input.nextInt();
if(year%4==0&&year%100!=0){
flag = 1;
}else if(year%400==0){
flag = 1;
}
if(flag==1){
System.out.println(year+"是闰年");
}else {
System.out.println(year+"不是闰年");
}
}
}
}
网购运费计算
/*网购商品计算运费的标准如下:。其中x表示货物的金额,
* 由用户从键盘输入,y表示需要的运费,计算后输出x和y的值(格式: 货物金额: 150元, 运费:5元)。
* */
import java.util.Scanner;
public class Fee
{
public static void main(String[] args)
{
float x,y;
//(1)输入货物金额x
Scanner sc = new Scanner(System.in);
x = sc.nextFloat();
//(2) 计算运费y
if(x<100){
y=10;
}else if(x>300){
y=0;
}else{
y=5;
}
//(3)输出结果
System.out.println("货物金额:"+x+"元,运费:"+y+"元");
}
}
成绩等级判断、幼儿园编班
/*编程实现:用户输入一个百分制成绩,判断并输出成绩等级。
* 成绩等级的判定规则: 90~100为“优秀”,80~90(不含90)为“良好”,
* 70~80(不含80)为“中等”,60~70(不含70)为“及格”,60以下为“不及格”。
* 当用户输入的成绩不是百分制的有效成绩时,提示用户“输入错误:超出了0~100”
* */
import java.util.Scanner;
public class ScoreGrade {
public static void main(String[] args) {
float score;
Scanner sc = new Scanner(System.in);
System.out.println("输入成绩(0~100):");
// 输入成绩score 并判断等级
score = sc.nextFloat();
if(score<0 || score>100) {
System.out.println("输入错误:超出了 0~100");
} else if (score>=90 && score<100) {
System.out.println("优秀");
}else if (score>=80 && score<90) {
System.out.println("良好");
} else if (score>=70 && score<80) {
System.out.println("中等");
} else if (score>=60 && score<70) {
System.out.println("及格");
}else {
System.out.println("不及格");
}
}
}
/*幼儿园分班问题。某幼儿园只接收2~6岁的小孩,其中2~3岁编入小班,
* 4~5岁编入中班,6岁编入大班。编程实现,对用户输入的任意一个年龄,
* 输出该编入什么班,或者告知“不收”。
*
*/
import java.util.Scanner;
public class ChildClass {
public static void main(String[] args) {
int age;
//(1)输入小孩的年龄 age
System.out.println("输入小孩年龄");
Scanner sc = new Scanner(System.in);
age = sc.nextInt();
//(2)判断并输出结果
if(age>=2 && age<=6){
if(age<=3 && age>= 2){
System.out.println("小班");
} else if (age<=5 && age>3) {
System.out.println("中班");
}else{
System.out.println("大班");
}
}else {
System.out.println("不收");
}
}
}
4-2 选择结构综合应用
编写算术练习的菜单程序
/**编程实现: 显示菜单(如下图),提示用户选择菜单项,根据用户的选择输出不同的结果。若用户输入2,则输出“开始减法练习……”。
若输入的数据超出1~5,则输出“输入错误,超出菜单范围”。 要求用if语句实现。
小学生算术练习系统
1.加法练习
2.减法练习
3.乘法练习
4.除法练习
5.退出系统 *
*/
import java.util.Scanner;
public class Menu {
public static void main(String[] args) {
int choice; //choice表示用户输入的选择
//显示菜单
System.out.println("小学生算术练习系统");
System.out.println("1.加法练习");
System.out.println("2.减法练习");
System.out.println("3.乘法练习");
System.out.println("4.除法练习");
System.out.println("5.退出系统");
//提示用户输入选择(1-5)
System.out.println("请选择(1-5)");
Scanner sc = new Scanner(System.in);
choice = sc.nextInt();
//根据用户的选择输出对应的信息
if(choice == 1){
System.out.println("开始加法练习");
} else if (choice == 2) {
System.out.println("开始减法练习");
} else if (choice == 3) {
System.out.println("开始乘法练习");
} else if (choice == 4) {
System.out.println("开始除法练习");
} else if (choice == 5) {
System.out.println("谢谢使用");
}else {
System.out.println("输入错误,超出菜单范围");
}
}
}
用switch语句编写菜单程序
/*编程实现: 显示菜单(如下图),提示用户选择菜单项,根据用户的选择输出不同的结果。
若用户输入2,则输出“开始减法练习……”。若输入的数据超出1~5,则输出“输入错误,超出菜单范围”
小学生算术练习系统
1.加法练习
2.减法练习
3.乘法练习
4.除法练习
5.退出系统
*/
import java.util.Scanner;
public class Menu2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int choice;
System.out.println("小学生算术练习系统");
System.out.println("1.加法练习");
System.out.println("2.减法练习");
System.out.println("3.乘法练习");
System.out.println("4.除法练习");
System.out.println("5.退出系统");
//提示用户输入选择(1-5)
System.out.println("请选择(1-5)");
Scanner sc = new Scanner(System.in);
choice = sc.nextInt();
//根据用户的选择输出对应的信息
switch (choice) {
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;
default:
System.out.println("输入错误,超出菜单范围");break;
}
}
}
邮费计算
/*编程实现邮局寄包裹的邮费计算:用户输入包裹的重量,按如下规定计算邮费。
* 邮局对包裹邮费规定如下:重量(千克)不超过10,收费标准为0.80元/千克;
* 不超过20,收费标准为0.75元/千克;不超过30,收费标准为0.70元/千克;
* 超过30千克不予邮寄。另对每件包裹收手续费0.2元。
* 若能邮寄,则输出格式为:包裹重量10.5KG,邮费8.1元
*/
import java.util.Scanner;
public class PostFee {
public static void main(String[] args) {
float weight, rate=0,postFee; //3个变量分表表示包裹的重量、邮费标准、需支付的邮费
//提示用户输入包裹重量
System.out.println("输入包裹重量(KG)");
Scanner sc = new Scanner(System.in);
weight=sc.nextFloat();
//根据包裹的重量判断是否能够邮寄,若能邮寄则选择不同的计费标准 rate并计算邮费
if(weight<=10){
postFee=0.8f*weight+0.2f;
System.out.printf("包裹重量"+"%.1f"+"KG,邮费"+"%.1f"+"元",weight,postFee);
} else if (weight<=20 && weight>10) {
postFee=0.75f*weight+0.2f;
System.out.printf("包裹重量"+"%.1f"+"KG,邮费"+"%.1f"+"元",weight,postFee);
} else if (weight<=30 && weight>20) {
postFee=0.7f*weight+0.2f;
System.out.printf("包裹重量"+"%.1f"+"KG,邮费"+"%.1f"+"元",weight,postFee);
}else{
System.out.println("不予邮寄");
}
}
}
实验四 循环语句与for语句
5-1认识for循环
输出符合条件的整数
/*找出100~200之间能被3整除且个位数位6的整数
输出格式:所有数据输出到一行中,且每个数据占5列*/
public class SearchData
{
public static void main(String[] args)
{
//请在以下位置填写代码
int index = 1;
for (int i = 100; i <= 200; i++) {
if (i % 3 == 0 && i%10==6) {
System.out.print(" "+i);
}
}
}
}
找输入5个整数并求平均值(新补*)
/*数入5个整数并求平均值。 输出格式无要求*/
import java.util.Scanner;
public class Average
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int[] arr=new int[5];
int avg=0;
for(int i=0;i<arr.length;i++){
arr[i]=sc.nextInt();
avg+=arr[i];
}
System.out.println(avg/5);
sc.close();
}
}
找水仙花数
/*找出所有的水仙花数,输出格式要求:每个整数占6列*/
public class NarcissisticNumber
{
public static void main(String[] args)
{
int n,ge,shi,bai,sum;//n是一个三位数的整数,ge、shi、bai表示n的个位、十位、百位数字,sum表示三位数字的立方和
//请在以下位置添加代码
for(int i=100;i<1000;i++){
bai=i/100;
shi=i/10%10;
ge=i%10;
if ((ge*ge*ge+shi*shi*shi+bai*bai*bai)==i){
System.out.printf("%6d",i);
}
}
}
}
找整数n的因子
/*输入一个整数n,输出n的所有因子(比如,输入6,输出的因子有 1,2,3,6,)*/
import java.util.Scanner;
public class IntFact
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
for(int i=1;i<=n;i++){
if(n%i==0)
System.out.printf("%d,",i);
}
}
}
计算阶乘的和
/*6. 编程计算:1!+2!+……+10!。*/
public class Sum
{
public static void main(String[] args)
{
int sum = 0;
int result = 1;
for (int i = 1; i <= 10; i++) {
result = 1;
for (int j = 1; j <= i; j++) {
result *= j;
}
sum += result;
}
System.out.println(sum);
}
}
打印九九乘法表
import java.util.Scanner;
public class MultipleTable {
public static void main(String[] args) {
int n,row,col;
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
//输出第一行
System.out.print(" *");
for(int i =1;i<=n;i++){
System.out.printf("%5d",i);
}
System.out.println();
for(int i =1; i<=n;i++){
System.out.print(" "+i);
for(int j = 1; j<=i;j++){
int t = i*j;
System.out.printf("%5d",t);
}
System.out.println();
}
//输出下面的n行
}
}
整数拆分
/*输入一个整数,从个位开始,逐步拆分出每一位数字,每个数字输出占一行*/
import java.util.Scanner;
public class SplitInteger {
public static void main(String[] args) {
int n;
//输入整数n
Scanner input = new Scanner(System.in);
int num = input.nextInt();
while (num!=0)
{
System.out.println(num % 10);
num /= 10;
}
}
}
5-2 while与do while
多项式求和
/*输入自然数n,计算多项式的和。 提示:输出结果保留4位小数*/
import java.util.Scanner;
public class Sum
{
public static void main(String[] args)
{
//用while语句求和
Scanner scanner = new Scanner(System.in);
int sc = scanner.nextInt();
int i;
double sum=0;i=1;
while(i<=sc)
{
sum=sum+1.0/(i);
i++;
}
System.out.printf("%.4f",sum);
//输出结果 sum
}
}
找整数n的因子
import java.util.Scanner;
public class Facts
{
public static void main(String[] args)
{
int n=0,k ; //n表示输入的整数,k表示因子
float sum; //sum表示和
//输入n
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
//找n的因子
sum = 0;
k=1;
do
{
if(n % k==0){
System.out.printf("%4d",k);
}
k++;
}while(k <= n);
sc.close();
}
}
整数逆序
/*输入自然数n,将n的各位数字逆序输出,每行输出一个数字*/
import java.util.Scanner;
public class ReverseInt
{
public static void main(String[] args)
{
//n表示输入的整数
//输入正整数n
//逆序输出
Scanner input = new Scanner(System.in);
int n = input.nextInt();
while (n!=0)
{
System.out.println(n % 10);
n /= 10;
}
}
}
/*输入任意位数的正整数n,从个位开始逆序得到各位数字并生成整数m。比如,输入n为123,生成整数m为321*/
import java.util.Scanner;
public class ReverseInt2
{
public static void main(String[] args)
{
//输入正整数n
Scanner input = new Scanner(System.in);
int num = input.nextInt();
System.out.printf("逆序后为");
while (num!=0)
{
System.out.print(num % 10);
num /= 10;
}
}
}
找素数
import java.util.Scanner;
public class SearchPrime
{
public static void main(String[] args)
{
int n ,m,k ; //m表示输入的整数
//输入正整数m
Scanner sc = new Scanner(System.in);
m = sc.nextInt();
boolean a;
//找出小于m的所有素数并输出,每个数据占4列
for(int i = 2;i < m; i++){
a = true;
for(int j = 2; j < i;j++){
if(i % j == 0){
a =false;
}
}
if(a){
System.out.printf("%6d",i);
}
}
sc.close();
}
}
5-3 循环结构综合应用
求最小公倍数
/*输入两个正整数,求它们的最小公倍数*/
import java.util.Scanner;
public class Multiple {
public static void main(String[] args) {
//输入两个整数,分别赋给m、n
Scanner cin=new Scanner(System.in);
int m,n,t;
m=cin.nextInt();
n=cin.nextInt();
if(m<n) {
t=m;m=n;n=t;
}
t=gong(m,n);
System.out.println(m*n/t);
cin.close();
//找出m和n中的较大值big
//找m和n最小公倍数
}
public static int gong(int a,int b) {
int k;
while((a%b)!=0) {
k=a%b;
a=b;
b=k;
}
return b;
}
}
统计字符
import java.util.Scanner;
public class CountChar {
public static void main(String[] args) {
int a = 0 ;
int b = 0 ;
int c = 0 ;
int d = 0 ;
Scanner sc = new Scanner(System.in) ;
String s = sc.nextLine() ;
char[] sr = s.toCharArray() ;
for(int i = 0 ;i<sr.length ; i ++ ) {
if('A'<=sr[i] && 'Z'>=sr[i] || 'a'<=sr[i] && 'z'>=sr[i] ) {
a++ ;
}else if('0'<=sr[i] && '9'>=sr[i]) {
b++ ;
}else if(sr[i] == ' ') {
c++ ;
}else {
d++ ;
}
}
System.out.println("字母" + a +"数字"+b+"空格"+c+"其他"+d);
}
}
实验五 数组
6-1 数组逆序输出
/*
输入10个自然数,存入数组中,逆序输出。
比如,输入的数据为:1 2 3 4 5 6 7 8 9 10
输出结果是:10 9 8 7 6 5 4 3 2 1
*/
import java.util.Scanner;
public class Reverse {
public static void main(String[] args) {
int k; //下标
//(1)创建数组data:
//(2)输入10个整数
Scanner sc = new Scanner(System.in);
int arr[]=new int[10];
System.out.println("输入10个整数:");
for(k=0;k<10;k++){
arr[k]=sc.nextInt();
}
//(3)逆序输出数组元素
for( k=9;k>=0;k--){
System.out.print(arr[k]+" ");
}
}
}
6-2 一维数组应用
统计不及格人数
/*从键盘输入一个班N个(5)学生的java课程成绩,存入数组score,然后统计不及格的人数,并输出不及格的成绩 */
import java.util.Scanner;
public class CountFail {
public static void main(String[] args) {
int k; //下标
final int N=5; //成绩个数
//(1)创建数组score,长度为N,数组元素为浮点型
float []score=new float[N];
//(2)输入一个班的高数成绩
Scanner sc = new Scanner(System.in);
System.out.printf("输入%d个成绩:\n",N);
for(k = 0 ; k<score.length; k++){
score[k] = sc.nextFloat();
}
//(3)统计不及格的人数,并输出不及格的成绩(成绩间用空格分隔)
int countFail=0; //不及格的人数,初值为0
for(k=0;k<score.length;k++){
if(score[k]<60.0f){
System.out.printf("%.1f ",score[k]);
countFail++;
}
}
System.out.print("\n不及格人数"+countFail);
}
}
求最低分
/*从键盘输入一个班N个(10)学生的java课程成绩,存入数组score,然后求出最低分。*/
import java.util.Scanner;
public class MinScore {
public static void main(String[] args) {
int k; //下标
final int N=10; //成绩个数
//(1)创建数组score:
float []score=new float[N];
//(2)输入一个班的高数成绩
Scanner sc = new Scanner(System.in);
System.out.printf("输入%d个成绩:\n",N);
for(k=0;k<score.length;k++){
score[k] = sc.nextFloat();
}
float minScore = score[0];
//(3)求最低分
for(k=0;k<score.length;k++){
if(minScore>score[k]){
minScore = score[k];
}
}
System.out.print("最低分"+minScore);
}
}
冒泡排序
/*输入N个整数,用冒泡法升序排序,在下面的【】处填写代码*/
import java.util.Scanner;
public class Sort2 {
public static void main(String[] args) {
final int N=5;
//创建数组整型data,长度为N
int[]data = new int[N];
int k,temp; //下标
//输入N个整数
Scanner sc = new Scanner(System.in);
System.out.printf("输入%d个整数\n",N);
for(k=0;k<5;k++){
data[k]=sc.nextInt();
}
//冒泡排序:排N-1趟,每一趟排好一个数据
for(int m=0;m<data.length-1;m++)
{
//第m趟排序:从待排序数列data[0]~data[N-m]中的data[0]开始,循环比较相邻的两个元素,若不符合升序的顺序,则交换
for(k=0;k<data.length-1;k++)
if(data[k]>data[k+1])
{
temp = data[k];
data[k] =data[k+1];
data[k+1] = temp;
}
}
//输出排序后的数据
for(k=0;k<data.length;k++){
System.out.print(data[k]+" ");
}
}
}
6-3 二维数组应用
二维数组元素求和
/*设二维数组data[4][3]中的元素为{ { 1, 3, 5 }, { -3, 6, 0 }, { 13, -5, 7 }, { -2, 19, 25 } },
(1)按矩阵的格式输出二维数组的元素(每个数据占5列),(2)求所有数组元素之和
*/
public class Sum {
public static void main(String[] args) {
//创建二维数组data并初始化
int[][] data={ { 1, 3, 5 }, { -3, 6, 0 }, { 13, -5, 7 }, { -2, 19, 25 } };
int m,n;
int count = 0;
//(1)按4行3列的矩阵格式输出二维数组
for(m=0;m<4;m++){
for(n=0;n<3;n++){
System.out.printf("%5d",data[m][n]);
}
System.out.printf("\n");
}
//(2)数组元素求和
int sum=0;
for(m=0;m<4;m++){
for(n=0;n<3;n++){
sum=sum+data[m][n];
}
}
System.out.println("元素之和为"+sum);
}
}
二维数组元素的计算和输出
/*计算某行或某列倍数。输入12个整数,存入二维数组data[3][4];
按矩阵格式二维数组的元素;
将第3行(行下标为2)的元素乘以2;
输出计算后的二维数组。
请在下面【】处填写代码。
*/
import java.util.Scanner;
public class Matrix {
public static void main(String[] args) {
//创建二维数组data
int[][] data;
data = new int[3][4];
int row,col;
Scanner sc = new Scanner(System.in);
//(1)输入12个整数,存入3行4列的数组data中
for(row=0;row<3;row++){
for(col=0;col<4;col++){
data[row][col]= sc.nextInt();
}
}
//(2)输出计算前的二维数组
System.out.println("计算前的矩阵");
for(row=0;row<3;row++){
for(col=0;col<4;col++){
System.out.printf("%5d",data[row][col]); }
System.out.printf("\n");
}
//(3)将第3行(行下标为2)的元素乘以2;
for(col=0;col<4;col++){
data[2][col] = data[2][col]*2;
}
//(4)输出计算后的二维数组
System.out.println("计算后的矩阵");
for(row=0;row<3;row++){
for(col=0;col<4;col++){
System.out.printf("%5d",data[row][col]);
}
System.out.printf("\n");
}
}
}
二维数组中计算平均成绩
/*从键盘输入一个班N(5)个学生的 4门课程的成绩,存入数组score[][]。 计算每个学生的平均分。
请在下面【】处填写代码。
*/
import java.util.Scanner;
public class MatrixScore {
public static void main(String[] args) {
int row,col; //行、列下标变量
final int N=5; //N表示人数
//创建数组score,N行4列
float score[][] = new float[5][4];
//(1)输入4门课,每门课N个成绩
Scanner sc = new Scanner(System.in);
System.out.println("输入"+N+"个学生4门课的成绩");
for(row=0;row<5;row++){
for(col=0;col<4;col++){
score[row][col]= sc.nextFloat();
}
}
//(2)求个学生的平均分,即每一行的平均值
float[ ] average; //用一维数组保存每个学生的平均分
average= new float[N];
float sum;
//计算每一行的平均值,
for(row=0;row<N;row++)
{ //求第row行的平均值,存入对应的数组元素average[row]中
sum=0;
for(col=0;col<4;col++){
sum+=score[row][col];
}
average[row]=sum/4.0f;
}
//输出每个人的平均成绩
for(row=0;row<N;row++)
{
System.out.printf("第%d个学生的平均成绩为%.1f\n",row+1,average[row]);
}
sc.close();
}
}
统计字符串中的各类字符
/*输入一行字符,统计其中大写字母、小写字母、数字、空格和其他字符的个数,结果用数组保存。按格式输出结果(每个数据占6列)。
请在下面的【】处填写代码。
*/
import java.util.Scanner;
public class CountString {
public static void main(String[] args) {
//创建一维数组count,分别表示 大写字母、小写字母、数字、空格和其他字符的个数
int count[]=new int [5];
char ch; //从字符串读取的一个字符
String str;
//输入一行字符,赋给字符串str
Scanner sc=new Scanner(System.in);
str=sc.nextLine();
//统计数组初始化:元素清0
for(int k=0;k<5;k++){
count[k]=0;
}
//遍历字符串中的字符并将统计结果存入数组count中
for(int i=0;i<str.length();i++){
ch=str.charAt(i);
if('A'<=ch&&'Z'>=ch){
count[0]++;
}
else if('a'<=ch&&'z'>=ch){
count[1]++;
}
else if('0'<=ch&&'9'>=ch){
count[2]++;
}
else if(ch==' '){
count[3]++;
}else{
count[4]++;
}
}
System.out.println( "大写字母,小写字母, 数字 , 空格 , 其他");
//输出count数组的每个元素,占6列
for(int k:count)
System.out.printf("%6d",k);
}
}
6-4 数组综合应用
求转置矩阵
/*请在以下【】处填入代码*/
import java.util.Scanner;
public class ExchangeMatrix {
public static void main(String[] args) {
// 创建3行3列的二维数组ma,mb
int[][] ma,mb;
ma = new int[3][3];
mb = new int[3][3];
int row, col;
Scanner sc = new Scanner(System.in);
// 输入9个整数,存入3行3列的数组ma中
for (row = 0; row < 3; row++){
for (col = 0; col < 3; col++){
ma[row][col]=sc.nextInt();
}
}
// 输出转置前的矩阵ma
System.out.println("原始矩阵");
for(row=0;row<3;row++){
for(col=0;col<3;col++){
System.out.printf("%5d",ma[row][col]);
}
System.out.printf("\n");
}
//计算转置矩阵mb
for(row=0;row<3;row++){
for(col=0;col<3;col++){
mb[row][col]=ma[col][row];
}
}
// 输出转置后的矩阵
System.out.println("转置后的矩阵");
for(row=0;row<3;row++){
for(col=0;col<3;col++){
System.out.printf("%5d",mb[row][col]);
}
System.out.printf("\n");
}
sc.close();
}
}
字符串压缩
/*输入字符串:“aabbbccdaa” ,生成字符串:“a2b3c2d1a2”*/
import java.util.Scanner;
public class StringPress {
public static void main(String[] args) {
String s1=""; //s1表示输入的字符串,s2表示结果字符串,赋初值为空字符串
Scanner sc = new Scanner(System.in);
StringBuffer s2=new StringBuffer();
System.out.println("输入一行字符");
s1 = sc.nextLine();
char ch=s1.charAt(0); //表示s1中的一个字符
//统计s1中的字符,并将字符和该字符的个数连接到字符串s2中
int sum=0;
for(int k=0;k<s1.length();k++)
{
if(ch==s1.charAt(k)){
sum++;
}else{
s2.append(ch);
s2.append(sum);
sum=1;
ch=s1.charAt(k);
}
}
s2.append(ch);
s2.append(sum);
System.out.println("压缩后的字符串"+s2);
}
}
实验六 静态方法
7-1 认识静态方法
/*编写函数fun(),求1+3+5+7+……+n.
在main()方法中输入n的值(要求为奇数),调用fun()求和,在main()方法中并输出结果。
请在下面【】处填入代码。
*/
import java.util.Scanner;
public class SumOdd {
public static void main(String[] args) {
/**
int n; //表示输入的奇数
System.out.println("输入一个整数(奇数)");
Scanner sc= new Scanner(System.in);
//调用fun()求和,并输出结果
System.out.printf("%d\n" ,);
sc.close();
}
public static int fun(int m) {
int sum=0;
//计算1+3+5+7+……+m
for(int i=0;i<m;i++){
++i;
}
//返回结果
return sum ;
}
*/
int n; //表示输入的奇数
System.out.println("输入一个整数(奇数)");
Scanner sc = new Scanner(System.in);
//调用fun()求和,并输出结果
int m = sc.nextInt();
System.out.println(fun(m));
}
public static int fun(int m) {
int sum=0;
//计算1+3+5+7+……+m
for(int i=0;i<m;i++){
++i;
sum+=i;
}
//返回结果
return sum ;
}
}
判素数
/*编写方法prime(int n),判断一个整数n是否是素数。若n是素数,则返回true,否则返回false。
然后在main()方法中输入任一整数n,调用prime()方法,根据其返回值判断n是否为素数 。
请在下面的【】处填写代码
*/
import java.util.Scanner;
public class IsPrime {
public static void main(String[] args) {
System.out.println("输入一个大于2的自然数n");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
//调用prime(),并根据其返回值判断n是否为素数
if (prime(n)) {
System.out.println(n+"是素数");
} else {
System.out.println(n+"不是素数");
}
}
//判素数,是则返回true,不是则返回false
public static boolean prime(int m) {
for(int i=2;i<m;i++){
if(m%i==0){
return false;
}
}
return true;
}
}
数组排序
import java.util.Scanner;
public class Sort2 {
public static void main(String[] args) {
int[] data = new int[10];
Scanner sc = new Scanner(System.in);
//输入10个整数
for(int k=0;k<data.length;k++)
data[k] = sc.nextInt();
//调用sort()方法,对data数组排序
sort(data);
//输出排序后的数组元素
for(int k=0;k<data.length;k++)
System.out.print(data[k]+",");
}
//降序排序方法 sort()
static void sort(int[] dd)
{
int i, j, n = dd.length, temp;
for (i = 1; i < n; i++)
{
for (j = 0; j < n - i; j++)
if (dd[j] < dd[j + 1])
{
temp = dd[j];
dd[j] = dd[j + 1];
dd[j + 1] = temp;
}
}
}
}
7-2 递归方法
猴子摘桃
/* 猴子吃桃问题:小猴子摘了一堆桃子。第一天吃掉一半又多吃了1个,第二天吃了剩下的一半又多吃1个,以后每天都吃掉剩下的一半多一个。第10天发现只剩一个桃子了。问第一天摘了多少桃子?第二天还有多少桃子?第三天……
编写方法peach(int day),计算第day天的桃子数。
在main()方法中输入day(1~10),即你想知道第day天小猴子有多少桃子,调用peach()方法求该天的桃子数。
*/
/*请在下面的【】处填写代码*/
import java.util.Scanner;
public class Peach {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("你想知道小猴子第几天的桃子数?请输入(1~10)");
int day = sc.nextInt();
System.out.println("第"+day+"天的桃子数是"+peach(day));
}
public static int peach(int x){
if(x==10){
return 1;
} else {
return 2* peach(x+1) + 2;
}
}
}
用递归将整数逆序输出
/*编写递归的方法 reverse(int n):将一个整数n的各位数字逆序输出。*/
/*请在下面的【】处填写代码*/
import java.util.Scanner;
public class Reverse {
public static void main(String[] args) {
int n;
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
//调用reverse(),将整数n的各位数字逆序输出
reverse(n);
sc.close();
}
//逆序输出各位数字
static void reverse(int n)
{
if(n > 0)
{
System.out.printf("%4d",n%10);
reverse(n/10);
}
}
}
实验七 类与对象
8-1 认识类与对象
通讯录中的朋友信息类
/*朋友信息类,请在下面的【】处补充代码*/
public class Friends {
//数据成员:姓名、电话、单位、年龄、备注
String name;
String tel;
String workUnit;
int age;
String note;
//方法成员
//设置朋友信息
void set(String new_name,String new_tel,String new_workUnit,int new_age,String new_note)
{
name =new String(new_name);
tel = new String(new_tel);
workUnit =new String(new_workUnit);
age = new_age;
note =new String(new_note);
}
//显示信息
void display()
{
System.out.printf( "name:%s tel:%s workUnit:%s age:%d note:%s\n", name,tel,workUnit,age,note);
}
}
/*主程序类,请在下面的【】处补充代码*/
public class TestFriends {
public static void main(String[] args) {
//声明两个Friends类的对象f1,f2
Friends f1,f2;
//创建对象f1
f1=new Friends();
//通过f1调用方法
f1.set("王丽艳", "13245876655", "山东交通学院信电学院",21 ,"计算机19"); //调用对象f1的方法set给对象s1赋值
f1.display(); // 调用对象f1的方法display显示对象f1的值
//创建对象f2,并调用f2的方法实现对f2的赋值和显示
f2=new Friends();
f2.set("逄瀚","15678908899","机动车检测中心", 34 ,"经理");
f2.display();
}
}
复数类
//复数类的定义,请在下面的【】处填写代码
public class Complex {
//数据成员: 实部、虚部,都是double类型
double real;
double imag;
//以下是方法成员
// 设置复数
void set(double r, double i)
{
real=r;
imag=i;
}
void display( ) // 显示复数,格式为 a + bi
{
System.out.printf("%.2f + %.2fi\n", real,imag);
}
Complex add(Complex c2) // 两个复数相加
{
Complex c3 = new Complex();
c3.real =this.real+c2.real;
c3.imag =this.imag+c2.imag;
return c3;
}
Complex sub(Complex c2) // 两个复数相减
{
Complex c4 = new Complex();
c4.real =this.real-c2.real;
c4.imag =this.imag-c2.imag;
return c4;
}
//复数的乘积 (a+bi)*(c+di)=(ac-bd)+(bc+ad)i
Complex mul(Complex c2)
{
Complex c5 = new Complex();
c5.real =this.real*c2.real-this.imag*c2.imag;
c5.imag =this.imag*c2.real+c2.imag*this.real;
return c5;
}
/*复数的商:分子分母同时乘以分母的共轭复数
(a+bi)/(c+di) =((a+ bi)(c- di))/((c+ di)(c- di))
=(ac+bd)/(c^2+d^2)+ ((bc-ad)/(c^2+d^2))i
*/
Complex div(Complex c2)
{
Complex c6 = new Complex();
c6.real=((this.real)*(c2.real)+(this.imag)*(c2.imag))/((c2.real)*(c2.real)+(c2.imag)*(c2.imag));
c6.imag=((this.imag)*(c2.real)-(this.real)*(c2.imag))/((c2.real)*(c2.real)+(c2.imag)*(c2.imag));
return c6;
}
}
//调用复数类,请在下面的【】处填写代码
public class TestComplex {
public static void main(String[] args) {
//声明6个Complex类的对象c1~c6,其中前两个表示要运算的两个复数,后4个表示加减乘除的结果
Complex c1,c2,c3,c4,c5,c6;
//创建2个对象c1和c2
c1=new Complex();
c2=new Complex();
//设置c1,c2的值,分别为 8+10i 、4+6i
c1.set(8,10);
c2.set(4,6);
//调用add()方法计算两个复数的和,存入c3
c3=c1.add(c2);
//调用c3的方法display()显示c3的值
c3.display();
//调用减法,计算c1-c2,结果存入c4,显示c4的值
c4=c1.sub(c2);
c4.display();
//调用乘法,计算c1*c2,结果存入c5,显示c5的值
c5=c1.mul(c2);
c5.display();
//调用除法
c6=c1.div(c2);
c6.display();
}
}
8-2 构造方法与方法重载
时钟类(用默认的构造方法)
/*(1) 定义一个时钟类MyClock,包含3个数据成员(即成员变量:时,分,秒);
包含2个方法, 一个设置时间的方法setClock(),一个显示时间的方法display(),按照“ 12:28:45 ”的格式显示时间。
请在下面的【】处补充代码。
*/
public class MyClock {
//数据成员:hour minute second
int hour;
int minute;
int second;
//方法成员:设置时间
public void setClock(int hour,int minute,int second)
{
this.hour=hour;
this.minute=minute;
this.second=second;
}
//方法成员: 显示时间
public void display()
{
System.out.printf("%2d:%2d:%2d",hour,minute,second);
System.out.println();
}
}
//主程序类,定义两个时钟对象,输入一个时间值,初始化时钟对象1,然后输出两个时钟的值。
import java.util.Scanner;
public class MyClockTest {
public static void main(String[] args) {
MyClock clock1,clock2;
clock1=new MyClock();
clock2=new MyClock();
clock1.setClock(0,0,0);
//输入一个时间:时 分 秒
Scanner sc = new Scanner(System.in);
int hour,minute,second;
System.out.println("输入一个时间:(时 分 秒用空格分隔)");
hour=sc.nextInt();
minute=sc.nextInt();
second=sc.nextInt();
//用输入的时间设置时间对象clock1
clock1.setClock(hour,minute,second);
//显示两个时间对象
clock1.display();
clock2.display();
}
}
时钟类(自定义重载的构造方法)
/* 在上一关的基础上,添加一个不带参数的构造方法,给数据成员置0;一个带参数的构造方法;
在主程序类中定义两个时钟对象,输入一个时间,初始化时钟对象2,然后输出两个时钟的值。
*/
public class MyClock {
//数据成员: 时 分 秒
int hour;
int minute;
int second;
//方法成员:构造方法1--不带参数的,初始化时钟为 0:0:0
MyClock(){
this.hour=0;
this.minute=0;
this.second=0;
}
//方法成员:构造方法2-- 带参数的,三个参数分别( 时,分,秒)
MyClock(int hour,int minute,int second){
this.hour=hour;
this.minute=minute;
this.second=second;
}
//方法成员:设置时间
public void setClock(int hour,int minute,int second)
{
this.hour=hour;
this.minute=minute;
this.second=second;
}
//方法成员: 显示时间
public void display()
{
System.out.printf("%2d:%2d:%2d",hour,minute,second);
System.out.println();
}
}
/*
在主程序类中定义两个时钟对象,时钟对象1初始化为(0:0:0);输入一个时间,初始化时钟对象2,然后输出两个时钟的值。
*/
import java.util.Scanner;
public class MyClockTest {
public static void main(String[] args) {
MyClock clock1,clock2;
clock1 = new MyClock();
clock2 = new MyClock();
//输入一个时间:时 分 秒
Scanner sc = new Scanner(System.in);
int hour,minute,second;
System.out.println("输入一个时间:(时 分 秒用空格分隔)");
hour=sc.nextInt();
minute=sc.nextInt();
second=sc.nextInt();
//用输入的时间初始化时间对象clock2
clock2.setClock(hour,minute,second);
//显示两个时间对象
clock1.display();
clock2.display();
//用输入的时间设置clock1并显示
clock1.setClock(hour,minute,second);
clock1.display();
}
}
时钟类(用对象作为构造方法的参数)
/*(1)定义一个时钟类MyClock,包含3个数据成员(即成员变量:时,分,秒);包含2个方法,一个显示时间的方法display(),按照“ 12:28:45 ”的格式显示时间。
(2)在前面两关的基础上,添加一个用时钟对象作为参数的构造方法。
*/
public class MyClock {
//数据成员:时,分,秒
int hour;
int minute;
int second;
//方法成员:构造方法1--不带参数的,初始化对象为 0:0:0
MyClock(){
hour=0;
minute=0;
second=0;
}
//方法成员:构造方法2-- 带参数的,用时、分、秒初始化对象
MyClock(int hour,int minute,int second){
this.hour=hour;
this.minute=minute;
this.second=second;
}
//方法成员:构造方法3-- 用对象作为参数
MyClock(MyClock clock)
{
this.hour=clock.hour;
this.minute=clock.minute;
this.second=clock.second;
}
//方法成员: 显示时间
public void display()
{
System.out.printf("%2d:%2d:%2d",hour,minute,second);
System.out.println();
}
}
/*在主程序类中输入一个时间,初始化clock1;然后用clock1 作为参数初始化clock2,然后输出两个时钟的值。
请在下面的【】处补充代码。
*/
import java.util.Scanner;
public class MyClockTest {
public static void main(String[] args) {
MyClock clock1,clock2;
//输入一个时间:时 分 秒
Scanner sc = new Scanner(System.in);
int hour,minute,second;
System.out.println("输入一个时间:(时 分 秒用空格分隔)");
hour=sc.nextInt();
minute=sc.nextInt();
second=sc.nextInt();
//用输入的时间初始化时间对象clock1
clock1 = new MyClock(hour,minute,second);
//用clock1初始化clock2
clock2 = new MyClock(clock1);
//显示两个时间对象
clock1.display();
clock2.display();
}
}
圆锥类
/*定义圆类,数据成员有半径radius、面积area;
方法有3个,设置圆的信息(参数是半径),获取圆的面积
*/
public class Circle {
double radius;
double area;
//设置圆的信息
public void setRadius(double radius)
{
this.radius=radius;
}
//获取圆的面积
public double getArea()
{
return area=3.14*radius*radius;
}
public void display()
{
System.out.printf("圆的半径:%.2f面积:%.2f",radius ,getArea());
}
}
/*定义圆锥,数据包括底(圆 buttom)、高度height、体积;
不含参数的构造方法;设置圆锥的方法(参数包括底面半径、高);
显示圆锥的半径、底面积、高、体积,格式见任务说明。
*/
public class Cone {
Circle buttom; //圆锥的底,圆
double height;
double volume;
//圆锥的构造方法 ,
public Cone()
{
buttom=new Circle();
this.height=height;
this.volume=volume;
}
//设置圆锥信息
public void set(double radius,double height)
{
buttom.setRadius(radius);
this.height=height;
}
public double getVolume()
{
return volume=buttom.getArea()*height/3;
}
public void disaplay()
{
buttom.display();
System.out.printf("高:%.2f体积:%.2f\n",height,getVolume());
}
}
/*测试圆锥类,设置半径为2,高度为5,输出圆锥的半径、底面积、高、体积*/
public class ConeTest {
public static void main(String[] args) {
Cone cone = new Cone();
cone.set(3, 5);
cone.disaplay();
}
}
实验八 内部类与异常类
9-1 内部类与异常类的应用
基于父类的匿名内部类的应用
/* 请在下面标记【】的位置补充代码*/
//父类Speak
class Speak{
public void speak() {
System.out.println("");
}
}
//测试类
public class TestSpeak {
public static void main(String[] args) {
new Speak(){
public void speak(){
System.out.print("大家好,请多关照!");
}
}.speak();
Speak hello = new Speak(){
public void Speak(){
System.out.print("大家好,请多关照!");
}
};
hello.speak();
}
}
基于接口的匿名内部类的应用
/*请在下面标注【】的位置添加代码*/
//定义接口Speak,包含一个方法speak()
interface Speak{
public void speak();
}
//测试类
public class TestInterface{
public static void main(String[] args) {
Speak hello=new Speak(){
public void speak(){
System.out.print("大家好,请多关照!");
}
};
hello.speak();
}
}
9-2 异常处理机制
除数为0的异常处理
import java.util.Scanner;
public class DivExceptionTest {
public static void main(String[] args) {
int num1,num2;
/********* Begin *********/
//输入两个整数num1,num2
Scanner sc=new Scanner(System.in);
num1=sc.nextInt();
num2=sc.nextInt();
//计算并输出结果,对除数为0的异常进行处理
try{
if(num2==0){
throw new ArithmeticException();
}System.out.println(num1/num2);
}catch(ArithmeticException e){
System.out.print("除数不能为0");
}
/********* End *********/
}
}
抛出异常
package step3;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Task {
/********* Begin *********/
//请在合适的部位添加代码
public static void main(String[] args) throws FileNotFoundException{
test();
}
public static void test() throws FileNotFoundException{
File file = new File("abc");
if(!file.exists()){ //判断文件是否存在
//文件不存在,则 抛出 文件不存在异常
throw new FileNotFoundException("该文件不存在");
}else{
FileInputStream fs = new FileInputStream(file);
}
}
/********* End *********/
}
自定义异常
package step4;
import java.util.Scanner;
public class Task {
/********* Begin *********/
public static void main(String[] args) throws MyException {
Scanner sc = new Scanner(System.in);
String username = sc.nextLine();
if(username.length()<3){ throw new MyException("用户名小于三位Exception");
}
else{
System.out.println("用户名格式正确");
}
//判断用户名
}
}
class MyException extends Exception{
public MyException(){
}
public MyException(String msg){
super(msg);
}
}
/********* End *********/
实验九 继承与接口
10-1 继承与抽象类
房屋,住宅,写字楼类的编写与应用
/* 请在下面的【】处补充代码
*/
//测试类
public class BuildingTest {
public static void main(String[] args) {
Building build = new Building();
build.setBuilding(5, 5000);
build.show();
House house = new House();
house.setHouse(6,6000,120,60);
house.show();
OfficeBuilding office = new OfficeBuilding();
office.setOffice(10, 15000, 50, 200);
office.show();
}
}
//楼房类:描述一座楼房的层数、总平方米数
class Building {
int layers; //层数
int area; //面积(平方米数)
//设置楼房信息
public void setBuilding(int layers, int area) {
this.layers=layers;
this.area=area;
}
//显示楼房信息
public void show() {
System.out.printf("层数:%d,总面积:%d",layers,area);
}
}
//住宅除了具有楼房的属性(层数、总面积)外,还有卧室数、浴室数
class House extends Building{
int bedRooms;
int bathRooms;
public void setHouse(int layers, int area, int bedRooms,int bathRooms) {
this.layers=layers;
this.area=area;
this.bedRooms=bedRooms;
this.bathRooms=bathRooms;
}
@Override
public void show() {
System.out.print("\n住宅:");
System.out.printf("层数:%d,总面积:%d卧室数:%d,浴室数:%d",layers,area,bedRooms,bathRooms);
}
}
//写字楼除了具有楼房的属性(层数、面积)外,还有房间数和灭火器的数量
class OfficeBuilding extends Building {
int rooms; //房间数
int extinguishers; //灭火器数量
public void setOffice(int layers, int area, int rooms,int extinguishers) {
this.layers=layers;
this.area=area;
this.rooms=rooms;
this.extinguishers=extinguishers;
}
@Override
public void show() {
System.out.print("\n写字楼:");
System.out.printf("层数:%d,总面积:%d房间数:%d,灭火器数:%d",layers,area,rooms,extinguishers);
}
}
圆形类及其矩形类和圆类的实现
/*编程要求:请在下面标注 【】 的位置添加代码 */
//定义形状类Shape
abstract class Shape{
public abstract double GetArea(); //定义抽象方法GetArea()
public abstract double GetCircum(); //定义抽象方法GetCircum()
public void print()
{
System.out.println("周长:"+GetCircum()+"面积:"+GetArea());
}
}
//矩形类,从形状类Shape派生
class Rectangle extends Shape{
double width;
double length;
public Rectangle(double wid,double len){
this.width=wid;
this.length=len;
}
//重写GetArea()方法
public double GetArea(){
return(width*length);
}
//重写GetCircum()方法
public double GetCircum(){
return(width+width+length+length);
}
}
//圆类,从形状类派生
class Circle extends Shape{
public double radius;
public Circle(double r){
this.radius=r;
}
//重写GetArea()方法
public double GetArea(){
return(radius*radius*3.14);
}
//重写GetCircum()方法
public double GetCircum(){
return(2*3.14*radius);
}
}
//测试类Test
public class ShapeTest {
public static void main(String[] args){
Circle cir=new Circle(5); //创建圆的对象cir
Rectangle rec=new Rectangle(2,4); //创建矩形的对象rec
cir.print(); //输出圆的的信息
rec.print(); //输出矩形的的信息
}
}
动物发声模拟器
//动物发生模拟器。请在下面的【】处填写代码。
public class AnimalShoutTest {
public static void main(String[] args) {
//创建Cat类的对象cat、Dogz类的对象dog
Cat cat=new Cat();
Dog dog=new Dog();
System.out.print(cat.getAnimalClass()+"的叫声:");
cat.shout();
System.out.print(dog.getAnimalClass()+"的叫声:");
dog.shout();
}
}
//定义抽象类Animal,包含两个抽象方法getAnimalClass()和shout()
abstract class Animal{
public abstract String getAnimalClass();
public abstract void shout();
}
//基于Animal类定义子类Cat
class Cat extends Animal{
public String getAnimalClass() {
return("猫");
}
public void shout(){
System.out.println("喵喵");
}
}
//基于Animal类定义子类Dog
class Dog extends Animal{
public String getAnimalClass() {
return("狗");
}
public void shout(){
System.out.println("汪汪");
}
}
动物发声模拟器--改进版
//动物发生模拟器. 请在下面的【】处添加代码。
public class AnimalShoutTest2 {
public static void main(String[] args) {
Cat cat = new Cat();
Dog dog = new Dog();
// speak(cat);
// speak(dog);
cat.speak();
dog.speak();
}
//定义静态方法speak()
}
//定义抽象类Animal
abstract class Animal{
public abstract String getAnimalClass();
public abstract void speak();
}
//基于Animal类,定义猫类Cat,并重写两个抽象方法
class Cat extends Animal{
public String getAnimalClass(){
return ("猫");
}
public void speak(){
System.out.println("猫的叫声:喵喵");
}
}
//基于Animal类,定义狗类Dog,并重写两个抽象方法
class Dog extends Animal{
public String getAnimalClass(){
return ("狗");
}
public void speak(){
System.out.println("狗的叫声:汪汪");
}
}
改错题
/* 请在下面的 Begin 和 end之间修改源程序。
不可以修改 final 变量的值
final方法,不可以重写
不可以定义final 类
*/
public class finalTest {
public static void main(String args[]) {
Bike1 obj = new Bike1();
obj.run();
Honda honda = new Honda();
honda.run();
Yamaha yamaha = new Yamaha();
yamaha.run();
}
}
/********** Begin *********/
class Bike1 {
int speedlimit = 90;
void run() {
speedlimit = 120;
System.out.println("speedlimit=120");
}
}
class Bike2 {
void run() {
System.out.println("running");
}
}
class Honda extends Bike2 {
void run() {
System.out.println("running safely with 100kmph");
}
}
class Bike3 {
}
class Yamaha extends Bike3 {
void run() {
System.out.println("running safely with 100kmph");
}
}
10-2 接口
用接口实现动物类
/*请在下面标注【】的位置添加代码*/
//测试类
public class AnimalEatTest {
public static void main(String[] args) {
Cat cat = new Cat();
cat.eat();
//创建Dog类的对象dog并调用eat()输出“狗吃骨头”
Dog dog=new Dog();
dog.eat();
}
}
//定义接口Animal
interface Animal{
void eat();
}
//在类Cat中实现接口
class Cat implements Animal{
public void eat() {
System.out.println("猫吃鱼");
}
}
//定义类Dog,实现接口Animal
class Dog implements Animal{
public void eat(){
System.out.print("狗吃骨头");
}
}
在椭圆中实现2个接口
/* 请在下面标注【】的位置补充代码。
*/
import java.util.Scanner;
//定义接口 Area,包含抽象方法area():计算面积
interface Area {
public abstract double area();
}
//定义接口 Perimeter,包含抽象方法perimeter():计算周长
interface Perimeter {
public abstract double perimeter();
}
//定义椭圆类,实现接口Area、Perimeter
class Ellipse implements Area,Perimeter {
private double longAxis; //长半轴
private double shortAxis; //短半轴
//构造方法
public Ellipse(double longAxis, double shortAxis)
{
this.longAxis= longAxis;
this.shortAxis= shortAxis;
}
//重写(或实现)Area接口中的抽象方法area()
@Override
public double area(){
return(3.14*longAxis*shortAxis);
}
//实现Perimeter接口中的抽象方法perimeter()
@Override
public double perimeter(){
return 2*3.14*shortAxis+4*(longAxis-shortAxis);
}
//显示椭圆对象的信息
public void display()
{
System.out.printf("椭圆的长半轴:%.2f,短半轴:%.2f",this.longAxis,this.shortAxis);
System.out.printf(",面积:%.2f,周长:%.2f\n",area(),perimeter());
}
}
//测试类
public class EllipseTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
double a,b;
a = sc.nextDouble(); //长半轴
b = sc.nextDouble(); //短半轴
Ellipse ellipse = new Ellipse(a,b);
ellipse.display();
}
}
实验十 文件流与输出流
11-1 用字节流实现文件复制
/* 请在下面标注序号的位置添加代码,用字节流实现文件内容的复制 */
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class FileCopy {
public static void main(String[] args) throws Exception {
File sourceFile = new File("/test/a.txt"); //源文件
File targetFile = new File("/test/b.txt"); //目标文件
//创建字节流输入流对象in和输出流对象out
FileInputStream in=new FileInputStream("/test/a.txt");
FileOutputStream out=new FileOutputStream("/test/b.txt",true);
//创建缓冲字节数组b[]
byte b[]=new byte[1024];
//循环读写:读出a.txt的内容,写入b.txt文件中
in.read(b);
out.write(b);
//关闭输入、输出流
in.close();
out.close();
}
}
11-2 用字符IO流实现文件加密
import java.io.*;
import static java.lang.Character.isLetterOrDigit;
import java.util.Scanner;
public class FileTest {
public static void main(String[] args) throws IOException {
// 请在Begin-End间编写完整代码
// 接收给定字符串,获取相关路径
Scanner sc = new Scanner(System.in);
String strs = sc.next();
String [] str = strs.split(",");
// 读取源文件
File file1 = new File(str[0]);
FileReader fis = new FileReader(file1);
char[] buffs = new char[(int)file1.length()];
fis.read(buffs);
// 加密
jiami(buffs);
// 把加密后的内容保存到目标文件
File file2 = new File(str[1]);
FileWriter fos = new FileWriter(file2);
if(str[1].equals("/test/b.txt")){
fos.write(buffs,0,(int)file1.length());
fis.close();
fos.close();
System.exit(0);
}
fos.write(buffs,0,(int)file1.length());
fos.flush();
fis.close();
fos.close();
}
// 定义加密方法
public static void jiami(char[] ch){
for(int i=0;i<ch.length;i++){
if(ch[i]>='0'&&ch[i]<'9'){
ch[i]++;
}
else if(ch[i]=='9'){
ch[i]='0';
}
else if((ch[i]>='a'&&ch[i]<'z')||(ch[i]>='A'&&ch[i]<'Z')){
ch[i]++;
}
else if(ch[i]=='z'){
ch[i]='a';
}
else if(ch[i]=='Z'){
ch[i]='A';
}
}
}
/********** End **********/
}
11-3 用IO流实现数据文件读写
/*用数据流或缓冲流实现以下功能:(1)输入一个班的高数成绩(输入-1表示结束),写入文件,其中文件名由用户从键盘输入;
(2)读取文件中的成绩,统计成绩个数,并计算平均值;(3)输出成绩个数和平均值。*/
import java.io.*;
import java.io.IOException;
import java.util.*;
public class FileTest {
public static void main(String[] args) throws IOException {
//读取用户输入的文件名,创建文件对象,若该文件不存在,则创建文件
Scanner sc = new Scanner(System.in);
String s = sc.next();
File datafile = new File(s);
//创建 输出流对象
DataOutputStream out = null;
out = new DataOutputStream(new FileOutputStream(datafile));
//从键盘逐个读取成绩并写入文件
int grades = 0;
int count = 0;
while (grades >= 0) {
grades = sc.nextInt();
if (grades >= 0) {
out.writeFloat(grades);
count++;
}
}
//创建输入流对象, 读出文件中的数据,并计算
DataInputStream in = null;
in = new DataInputStream(new FileInputStream(datafile));
float sum = 0;
for (int i = 0; i < count; i++) {
sum = sum + in.readFloat();
}
//输出结果
System.out.println("数据个数:" + count + " 平均值:" + sum / count);
//关闭输入输出流
}
}
实验十一 java数据库编程
12-1 JDBC基础编程练习
JDBC更新员工密码
package step1;
import java.sql.*;
public class UpdatePass {
// 修改数据
public static void updateDB() {
/********* Begin *********/
// 第一步:加载驱动
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e1) {
// TODO 自动生成的 catch 块
e1.printStackTrace();
}
// 第二步:建立连接, "root"和"123123"是针对MySQL设置了用户名(root)和密码(123123)的情况
// 127.0.0.1:3306是mysql服务器地址及端口 数据库编码格式设置为utf-8
Connection conn = null;
PreparedStatement ps = null;
try {
String url = "jdbc:mysql://127.0.0.1:3306/tsgc?useUnicode=true&characterEncoding=utf8";
String user = "root";
String password = "123123";
conn = DriverManager.getConnection(url, user, password);
// 第三步:建立statement对象
String sql = "update employee set password='hello' where sex='女'";
ps = conn.prepareStatement(sql);
// 第四步:修改数据
ps.execute();
// 第五步:关闭statement对象和连接对象
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
} finally {
try {
ps.close();
conn.close();
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
/********* End *********/
}
}
JDBC查询员工信息
package step1;
import java.sql.*;
public class QueryPass {
// 查询数据代码不用上实验报告
public static void queryDB() {
/********* Begin *********/
Connection conn = null;
PreparedStatement ps = null;
try {
// 第一步:加载驱动
Class.forName("com.mysql.jdbc.Driver");
// 第二步:建立连接, "root"和"123123"是针对MySQL设置了用户名(root)和密码(123123)的情况
// 127.0.0.1:3306是mysql服务器地址及端口 数据库编码格式设置为utf-8
String url = "jdbc:mysql://127.0.0.1:3306/tsgc?useUnicode=true&characterEncoding=utf8";
String user = "root";
String password = "123123";
conn = DriverManager.getConnection(url, user, password);
// 第三步:建立statement对象
String sql = "select * from employee";
ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
// 第四步:查询数据
while (rs.next()) {
String no = rs.getString(1);
String name = rs.getString(2);
Object password1 = rs.getString(3);
Object sex = rs.getString(4);
double salary = rs.getDouble(5);
System.out.println("no:" + no + "\tname:" + name + "\tpassword:" + password1 + "\tsex:" + sex
+ "\tsalary:" + salary);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 第五步:关闭statement对象和连接对象
try {
ps.close();
conn.close();
} catch (SQLException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
/********* End *********/
}
}
实验十二 java多线程编程
顺序输出
package step1;
public class Task {
public static void main(String[] args) throws Exception {
/********* Begin *********/
// 在这里创建线程, 开启线程
Object a = new Object();
Object b = new Object();
Object c = new Object();
// 在这里创建线程, 开启线程
MyThread th1 = new MyThread("AA", a, c);
MyThread th2 = new MyThread("BB", c, b);
MyThread th3 = new MyThread("CC", b, a);
th1.start();
Thread.sleep(20);
th2.start();
Thread.sleep(20);
th3.start();
Thread.sleep(20);
System.exit(1);
/********* End *********/
}
}
class MyThread extends Thread {
/********* Begin *********/
String threadName;
Object a = null;
Object b = null;
public MyThread(String threadName, Object a, Object b) {
super();
this.threadName = threadName;
this.a = a;
this.b = b;
}
public synchronized void run() {
int count = 5;
while (count > 0) {
synchronized (a) {
synchronized (b) {
System.out.println("Java Thread" + this.threadName);
count--;
b.notify();
}
try {
a.wait();
// wait();
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
}
/********* End *********/
}
售票窗口
package step2;
/********* Begin *********/
import java.util.concurrent.locks.ReentrantLock;
//定义站台类,实现卖票的功能。
public class Station extends Thread {
private static ReentrantLock lock = new ReentrantLock();
private static int ticket = 20;
@Override
public void run() {
while (true) {
try {
lock.lock();
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e1) {
// TODO 自动生成的 catch 块
e1.printStackTrace();
}
System.out.println("卖出了第" + ticket + "张票");
ticket--;
} else {
System.out.println("票卖完了");
System.exit(0);
}
} finally {
lock.unlock();
}
}
}
}
/********* End *********/
完结,❀撒花花❀🥳🥳🥳
【从暑假想起来开始整理,直到开学了又突然想起来没整理完继续填坑,我真的太拖了哈哈哈】
除了保存自己以前做的题,也希望给应付老师布置的编程题头疼的小伙伴一些帮助。
😎瑞思拜~~~~