java语言程序设计实验题集锦☞ 头歌平台

🥰🥰在此恭敬奉上平台链接：头歌实践教学平台

鄙人普通本科计算机在读学生一枚，第一次写这种文章有点小紧张，初衷当然是记录一下，未来也希望是越来越好。

最近正值暑假突然想回忆一下之前学的java，就把之前学校课程java实验课做的一些题搬上来了，希望也能给做到这些题不知道怎么下手的uu一些帮助。

实验一~实验十二

目录

实验一 java 基本数据结构

1-1 认识java程序

1-2 java程序编写与运行

2-1 基本类型数据的输入输出

2-2 用println()实现简单计算器 

实验二 基本的运算符和表达式

3-1 算术运算符与算术表达式

3-2 赋值运算符与赋值表达式

3-3 综合应用

 实验三 分支语句

4-1 if语句入门

4-2 选择结构综合应用

实验四 循环语句与for语句

5-1认识for循环

5-2 while与do while

5-3 循环结构综合应用

实验五 数组

6-1 数组逆序输出

6-2 一维数组应用

6-3 二维数组应用

6-4 数组综合应用

实验六 静态方法

7-1 认识静态方法

7-2 递归方法

实验七 类与对象

8-1 认识类与对象

8-2 构造方法与方法重载

实验八 内部类与异常类

9-1 内部类与异常类的应用

9-2 异常处理机制

实验九 继承与接口

10-1 继承与抽象类

10-2 接口

实验十 文件流与输出流

11-1 用字节流实现文件复制

11-2 用字符IO流实现文件加密

11-3 用IO流实现数据文件读写

实验十一  java数据库编程

12-1 JDBC基础编程练习

实验十二  java多线程编程

---

---

实验一 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 *********/

完结，❀撒花花❀🥳🥳🥳

【从暑假想起来开始整理，直到开学了又突然想起来没整理完继续填坑，我真的太拖了哈哈哈】

除了保存自己以前做的题，也希望给应付老师布置的编程题头疼的小伙伴一些帮助。

😎瑞思拜~~~~