Java头歌实验梳理

元元本本源源

已于 2022-11-08 20:54:04 修改

阅读量2.7k

点赞数 3

文章标签： java 算法开发语言

于 2022-09-17 12:16:03 首次发布

本文链接：https://blog.csdn.net/m0_63192871/article/details/126903056

版权

Java头歌实验梳理

实验一：JAVA编程基础
实验二：字符串
- 字符串的值转换成浮点型
- 字符转换
实验三（Java）面向对象编程
- 第1关：第一题：编写一个计算各种形状的面积和周长的程序
- 第2关：第二题（Java）类
实验四（Java）接口
- 第1关：接口练习
- 第2关：定义一个MyList接口，并使用数组的方法来实现接口。
实验五（Java）集合框架
- 第1关

实验一：JAVA编程基础

编写一个简单Java程序，计算银行年存款的本息

请检测用户输入的合法性。可以使用Math类来进行次方的运算：Math.pow(底数,指数)。
输出格式：
在方法中的输出格式：
本金：100000
存款年限：10
利率：0.05
利息：62889.46267774419
总额：162889.4626777442

package step;
public class OneClass{
    public double Calculate(double bj,double lv,int nyear){
    System.out.print("本金：" + bj + "\n存款年限：" + nyear + "利率：" + lv);
    double sum = bj* Math.pow((1+lv),nyear);//总额
    double lx = sum - bj;//利息
    System.out.print("利息：" + lx + "\n总额：" + sum);
    return sum;
    }
    
}

编写程序完成矩阵的乘法运算

程序运行后要求用户分别输入两个矩阵的内容，然后调用Matrix（）方法进行两个矩阵相乘。如果可以相乘，则计算矩阵相乘后的结果并返回；若不能相乘，则提示用户矩阵不相容。
定义一个类，类名为TwoClass；
该类中只有一个方法:
public int[][] Matrix(int A[][],int B[][])；
A,B两个整型矩阵
返回A,B矩阵的乘。如果矩阵不相容，则输出“矩阵不相容！”，返回null。

package step2;
class TwoClass{
    //在此完成相应程序
    public int[][] Matrix(int A[][],int B[][]){
        if(A[0].length==B.length){
            int res[][]=new int[A.length][B[0].length];
            for(int i=0;i<A.length;i++){
                for(int j=0;j<B[0].length;j++){
                    for(int k=0;k<A[0].length;k++){
                        res[i][j]+=A[i][k]*B[k][j];
                    }
                }
            }
            return res;
        }else{
            System.out.println("矩阵不相容！");
            return null;
        }
    }    
}

编写程序用*号输出等腰梯形

程序运行后要求用户输入梯形的上边长度（号的数量），然后输入梯形的层数。梯形的每一层比上一层左右边各多一个号，程序输出梯形的形状。
例如：当用户输入3和4，则程序应该输出(不要序号)：

package step3;
import java.util.Scanner;        //导入Scanner
public class ThreeClass{
    public static void main(String[] args) {
      Scanner input = new Scanner(System.in);    //声明扫描仪
      int topNum=input.nextInt();
      int floor=input.nextInt();
      for(int i=0;i<floor;i++){
        for(int j=floor-i-2;j>=0;j--){
          System.out.print(" ");
        }
        for(int k=0;k<topNum+2*i;k++){
          System.out.print("*");
        }
        System.out.println();
      }
    }
}

在这里插入图片描述

实验二：字符串

字符串的值转换成浮点型

创建一个类DoubleConverter，有二个公有方法：
public boolean check(String value);//value为将转换的字符串,检查该字符串是不是有效的数值字符串，如是返回true,否则返回false;
public double convert(String value); //value为将转换的字符串, 返回为转换后的浮点数，如果返回为0.0，表明用户输入的字符串不是数值串.
提示
合理的浮点表示方法有如下几种形式：
123456
123456.123
+123456.12 = 123456.12
-123456.12
.1234 = 0.1234

package step1;
public class DoubleConverter{
   //在此完成该类
   public boolean check(String value){
      char a[] = value.toCharArray();//创建一个字符型数组
        int i;
        //判断该字符串第一位
        //可以是正负数、小数
        if ((a[0]>='0'&&a[0]<='9')||(a[0]=='+')||(a[0]=='-')||a[0]=='.'){
        //如果第一位符合标准那么判断后面
            for (i=1;i<value.length();i++){
                if (a[i]>='0'&&a[i]<='9'||a[i]=='.') continue;
                else{
                return false;
                }
            }
        }else{
             return false;
        }
        return true;

   }
   public double convert(String value)
   {
      double res=0;
      //调用check类方法判断是否为字符串
      if(check(value))
      //Double自带的方法将字符串转为浮点数：Double.praseDouble()
      res=Double.parseDouble(value);

      return res;
   }
}

字符转换

要求：
程序运行后要求用户输入一个句子。并将单词的首字母转换成大写，其余字符小写。最后输出新字符串。
编程要求
创建一个类Converter，该类中有一方法：
public String convert(String value)；//value为待转换的字符串
返回转换的结果字符串
输入格式:
用户输入：This is a samPLe sentencE to demostrATE the TasK 2.
输出格式:
程序应该输出：This Is A Sample Sentence To Demonstrate The Task 2.

将字母转化为大写：toUpperCase()
将字母转化为小写：toLowerCase()

//这个代码是没有返回值的，直接输出
//且定义的str2是把原字符串空格去掉了，后面的字符不论大小写保留，所以不符合题意
package demo;
import java.util.Scanner;
public class One {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in); // 定义扫描键盘输入的对象
		String s1 = sc.nextLine(); // 从键盘读入一行文本
		convert(s1);
	}
	public static void convert(String value) {
		String[] str1=value.split(" ");//用空格分割字符串。以字符数组接收
		for(int i=0;i<str1.length;i++) {//遍历数组
			String[] str2=new String[str1.length];//创建一个新的字符数组接收改变后的数组
			str2[i]=str1[i].substring(0,1).toUpperCase()+ str1[i].substring(1);// 第一个字母转化为大写，第一个字母后面的字符不变
			System.out.print(str2[i]+" ");//输出
		}
	}
}

//这个方法是先将所有字符转化为小写
//通过多次转化
package step2;

public class Converter{
        //增加你的代码
    public String convert(String value){
        String value1=value.toLowerCase();
        char c[]=value1.toCharArray();
        int a=(int) c[0];
        int b=a-32;
        c[0] = (char)b;
        for(int i=1;i<c.length-1;i++){
            if(c[i]==' ' && c[i+1]>='a' && c[i+1]<='z'){
                int x=(int)c[i+1];
                int y=x-32;
                c[i+1]=(char)y;
            }
        }

        String value2=new String(c);  
        return value2;
    }
}

实验三（Java）面向对象编程

第1关：第一题：编写一个计算各种形状的面积和周长的程序

知识点：抽象类继承方法的重写

本关任务：编写一个计算各种形状的面积和周长的程序。
父类Shape2D为一个抽象类，其中包含计算周长和计算面积两个抽象方法。其他形状圆(Circle)，三角形(Triangle)和长方形(Rectangle)类均继承自Shape2D类。而正方形Square类继承自Rectangle类。编写计算这些形状的面积和周长的各类的程序。
abstract public double getArea();//计算面积的方法
abstract public double getL();//计算周长的方法
####提示：不同的形状包含的属性应该不同，构造函数应该不同，计算周长和面积的方法也应该不同。如果三角形的边不满足要求，这两方法都返回-1 PI=3.14159
各类的构造函数如下：
public Circle（double r）;r为圆的半径
public Triangle（double a,double b,double c）;a,b,c为三边的长
public Rectangle（double a,double b）；a,b为长宽
public Square（double a）；a为边长

//Shape2D.java
package step1;
public abstract class Shape2D{
    //在这完成Shape2D类的程序的编写
    public abstract double getArea();//计算面积的方法
    public abstract double getL();//计算周长的方法
    
}

package step1;
//在这完成Circle类的编写
import java.lang.*;
public class Circle extends Shape2D {
	
	private double r; //圆的半径

	public Circle(double r) {
        this.r = r;
	}

	@Override
	public double getL() {
		return 2*Math.PI*r;
	}

	@Override
	public double getArea() {
		return Math.PI*r*r;
	}

}

package step1;
//在这完成Triangle类的编写
import java.lang.*;
//三角形
public class Triangle extends Shape2D {
	
	private double a;
	private double b;
	private double c;

	public Triangle(double a, double b, double c) {
		this.a=a;
		this.b=b;
		this.c=c;
	}
    @Override
	public double getL() {
        if(a+b>c && a+c>b && b+c>a){
            return a+b+c;
        }else{
            return -1;
        }	
	}
    @Override
	public double getArea() {
		if(a+b>c && a+c>b && b+c>a){
            double p = (a+b+c)/2.0;
		    return Math.sqrt(p*(p-a)*(p-b)*(p-c));
        }else{
            return -1;
        }	
	}
}

package step1;
//在这完成Rectangle类的编写
public class Rectangle extends Shape2D {

	private double  c;
	private double  k;
	
	public Rectangle(double c,double k) {
		// TODO Auto-generated constructor stub
		this.c=c;
		this.k=k;
	}
	
	@Override
	public double getL() {
		// TODO Auto-generated method stub
		return 2*(c+k);
	}

	@Override
	public double getArea() {
		// TODO Auto-generated method stub
		return c*k;
	}
}

package step1;
//在这完成Square类的编写
public class Square extends Rectangle{
    public Square(double a){
        super(a,a);
    } 
}

在这里插入图片描述

第2关：第二题（Java）类

本关任务：设计并实现三个类：班级(Class)、学生(Student)、课程(Course)。然后计算班上每个同学的平均成绩。
班级类的私有属性包含班级名称、学生人数以及学生列表（用对象数组表示）。班级类的方法包括：
 构造函数Class(int num,String name) //num学生人数，name班级名称
 void addStudent (Object student) //往班级中添加学生。Student学生对象
 int GetStudentNum() //返回班级人数
 Object GetStudent(int index) //返回对应下标的学生对象
 重写toString()方法来将班级有关信息转换成字符串.

package step2;
/* 私有属性包含班级名称、学生人数以及学生列表（用对象数组表示）
    构造函数Class(int num,String name)  //num学生人数，name班级名称
   void addStudent (Object  student) //往班级中添加学生。Student学生对象
   int GetStudentNum()  //返回班级人数
   Object GetStudent(int index) //返回对应下标的学生对象
   重写toString()方法来将班级有关信息转换成字符串.*/

public class Class {
	private String classname;
	private int stunum;
	private Student[] stulist;
	private int i=0;

	public Class(int num,String name) {
		this.classname = name;
		this.stunum = num;
		this.stulist = new Student[num];
	}
	public void addStudent(Student student) {		
		stulist[i] = student;
		i++;
		stunum++;
	}
	public int GetStudentNum() {
		return stunum;
	}
	public Student GetStudent(int index){
        if(index<0||index>this.stulist.length-1){
            return null;
        }else{
            return stulist[index];
        }
    }
	@Override
	public String toString() {
		return("班级名称："+classname+"；学生人数："+stunum+"；学生列表："+stulist);
	}
}

学生类的私有属性包含学生的学号、姓名、所选课程数量、所选课程（用对象数组表示）。学生类的方法包括：
 构造函数Student(int id, String name, int nCourse) //id学号,name学生姓名，nCourse所学课程数
 void addCourse(Object course) 往学生类中添加课程对象
 int GetCourseNum() 返回所学课程数
 Object GetCourse(int index) 返回对应下标的课程对象
 int calculateAvgGrade() 计算该每个学生的平均成绩（取整）
 重写toString()方法来将学生有关信息转换成字符串。

package step2;
//在这儿些Student类
public class Student {
	private int id;
	private String stuname;
	private int nCourse;
	private Course[] courses;
	private int j=0;
	//有参构造函数
	public Student(int id,String name,int nCourse){
        this.id=id;
        this.stuname=name;
        this.nCourse=nCourse;
        this.courses=new Course[nCourse];
    }
	public void addCourse(Course course) {
		courses[j]=course;
		j++;
		nCourse++;
	}
	public int GetCourseNum() {
		return nCourse;
	}
	public Course GetCourse(int index) {
		if(index<0||index>this.courses.length-1){
            return null;
        }else{
            return courses[index];
        }
	}
	public int calculateAvgGrade() {
		int count=0;
        int sum=0;
        for(int i=0;i<this.courses.length;i++){
            if(!(this.courses[i].gethk())){
                sum+=this.courses[i].getcj();
                count++;
            }
        }
        return sum/count;
	}
	@Override
	public String toString(){
        return "学号："+id+"姓名："+stuname+"所选课程数量："+nCourse+"所选课程："+courses;
    }
}

运用：getter/setter方法

课程类包含私有属性课程编号、课程名称、学分、是否缓考以及成绩（成绩要求在0到100分之间）。课程类方法包括：
 构造函数public Course(int id,String name,int credit) 分别为课程编号、课程名称、学分
 void sethk(boolean hk) hk=true代表缓考
 boolean gethk() 返回是否学生缓考
 void setcj(int cj) 设置成绩
 int getcj() 返回成绩
 int getCredit() 返回该课程的学分
 重写toString()方法来将课程有关信息转换成字符串。

package step2;
//在这些Course类
public class Course {
	private int cId;
	private String cName;
	private int credit;
	private boolean hk;
    private int grade;
	public Course(int id,String name,int credit) {
		this.cId=id;
		this.cName=name;
		this.credit=credit;
	}
	public void sethk(boolean hk) {
		this.hk=hk;
	}
	public boolean gethk() {
		return hk;
	}
	public void setcj(int cj) {
		this.grade=cj;
	}
	public int getcj() {
		return grade;
	}
	public int getCredit() {
		return credit;
	}
	@Override
	public String toString(){
        return "课程编号："+cId+"；课程名称："+cName+"；学分："+credit+"；是否缓考："+hk+"；成绩："+grade;
    }
}

实验四（Java）接口

第1关：接口练习

本关任务：定义一个Animal接口，并按要求实现接口。
Animal接口包含三个方法：
 public void Speak(); //说话
 public void Walk(); //行走方式
 public String toString();//返回动物名称

package step2;
//定义Animal接口
 interface Animal{
    public void Speak();//说话
    public void Walk();//行走方式
    public String toString();//返回动物名称
}

定义Centipede（蜈蚣）类，实现Animal接口。例如：
void Speak()；方法显示“不发声”
void Walk(); 方法显示“不知道有多少条腿走路”
String toString(); 方法返回“蜈蚣”

package step2;
public  class Centipede implements Animal{
    public void Speak() {
        System.out.println("不发声");
    }
    public void Walk() {
        System.out.println("不知道有多少条腿走路");
    }
    public String toString() {
        return "蜈蚣";
    }
}

定义Dog（狗）类，实现Animal接口。
定义People（人）类，实现Animal接口。
定义Chinese（中国人）类，继承People（人）类。
定义Britisher（英国人）类，继承People（人）类。

package step2;
//完成Dog类
 class Dog implements Animal{
    @Override
    public void Walk() {
        System.out.println("四条腿走路");
    }
    @Override
    public void Speak() {
        System.out.println("发声");
    }

    @Override
    public String toString() {
        return "狗";
    }
}

package step2;
//完成People类
public  class People implements Animal{
    @Override
    public void Walk() {
        System.out.println("两条腿走路");
    }
    @Override
    public void Speak() {
        System.out.println("发声");
    }
    @Override
    public String toString() {
        return "人";
    }
}

package step2;
//完成Chinese类
class Chinese extends People{  
    public String toString() {
        return "中国人";
    }
}

package step2;
//完成Britisher类
public class Britisher extends People{  
    public String toString() {
        return "英国人";
    }
}

第2关：定义一个MyList接口，并使用数组的方法来实现接口。

知识点：接口
- 自定义构造方法:如果一个类中不存在无参的构造方法，则对其子类的构造方法会有限制。
- 好的声明习惯：通常至少声明两个构造方法，其中一个为无参构造方法
- 接口默认public，所以前面可以不写public

MyList接口包含六个方法：
 void add(Object obj)：往列表尾部添加对象
 Object get(int index)：从列表中获取索引为i的对象
 void clear()：清空所有的对象
 boolean isEmpty()：判断列表中是否有对象
 int size()：获取列表中对象的个数
 int capacity()：所分配的空间大小

package step1;
//在此写接口MyList
interface MyList{
    public void add(Object obj);
    public Object get(int index);//从列表中获取索引为i的对象
    public void clear();//清空所有的对象
    public boolean isEmpty();//判断列表中是否有对象
    public int size();//获取列表中对象的个数
    public int capacity();//所分配的空间大小
}

MyObjectArray类实现MyList接口，内部以数组的方式实现，要求：
 构造函数MyObjectArray(int incSize)：参数incSize为数组初始化大小和空间的增量。若用户调用incSize非法，则设为默认值5。
 当调用add()方法往试图往MyObjectArray中增加对象时，如果内部数组已满，则增加数组大小，增量为incSize。
 调用clear()方法可以清空所有通过add()方法加入的对象。
 调用get(int index)方法时，如果传入的参数非法，则返回null对象，否则返回对应的对象。

package step1;
import java.util.Arrays;
//在此写MyObjectArray类
public class MyObjectArray implements MyList{
    private Object[] Array;
    private int c=0;
    private int incSize;
    public MyObjectArray(){

    }
    public MyObjectArray(int incSize){
    //初始化数组，若incSize非法则默认5
        if(incSize<0){
            this.incSize = 5;
        }else{
            this.incSize = incSize;
        }
        this.Array = new Object[this.incSize];
    }
    public void add(Object obj){
        if(this.c==Array.length){
            Array = Arrays.copyOf(Array,Array.length+incSize);
        }
        Array[c++]=obj;
    }
    public void clear(){
        this.Array = new Object[5];
        this.c=0;
    }
    public Object get(int index){
        if(index>0&&index<c){
            return Array[index];
        }else{
            return null;
        }
    }
    public boolean isEmpty(){
        if(Array[0]==null){
            return true;
        }else
            return false;
    }
    public int size(){
        return c;
    }
    public int capacity(){
        return this.Array.length;
    }
}

MyDoubleArray类也实现ReList接口，内部依旧通过数组实现，要求：
 构造函数MyDoubleArray(int initSize)：参数initSize表示数组的初始化大小。若用户调用initSize非法，则设为默认值10。
 当调用add()方法往MyDoubleArray列表里面增加对象时，如果其内部数组已满，则将数组的长度变为当前长度的2倍。
 其他方法和MyObjectArray一致

package step1;
import java.util.Arrays;
//在此写MyDoubleArray类
public class MyDoubleArray implements MyList{
    private Object[] Array= null;
    private int c=0;
    private int incSize;
    public MyDoubleArray(){

    }
    public MyDoubleArray(int initSize){
        if(initSize<0){
            this.incSize = 10;
        }else{
            this.incSize = initSize;
        }
        this.Array = new Object[this.incSize];
    }
    public void add(Object obj){
        if(c==Array.length){
            Array = Arrays.copyOf(Array,2*Array.length);
        }
        Array[c++]=obj;    
    }
    public Object get(int index){
        Object obj=null;
        if(index > 0 && index < c){
            obj=Array[index];
        }
        return obj;
    }
    public boolean isEmpty(){
        if(Array[0]==null)
            return true;
        else
            return false;
    }
    public int size(){
        return c;
    }
    public int capacity(){
        return this.Array.length;
    }
    public void clear(){
        this.Array = new Object[10];
        this.c = 0;
    }  
}

最后设计一个类来测试你的MyObjectArray和MyDoubleArray类，看看这两个类是否能在不破坏使用者代码的情况下相互替换。
####提示：增加数组长度的方法：使用java.util.Arrays.copyOf()方法，用法请查阅Java API文档。
Arrays.copyOf()用法

实验五（Java）集合框架

第1关

涉及知识点：泛型

本关任务：设计一个程序，管理一个班级的若干学生（学生的姓名是唯一的），每个学生都修了若干门课程，每门课程都有了一个成绩。但一个班的同学修的课程不完全一样。
该程序用集合框架的Map接口来实现。学生用Map来存储，键用学生姓名，值是另一个存储课程的Map；每个同学修的若干门课程也用Map来存储，键是课程名称，值是该课程的成绩。
将把完成的工作放在Class类中。类名：Class public Class(String name) 构造函数，name为班级名称；
public void addCourseGrade(String stuname,String []Coursenames,Integer[] grades) 增加学生及课程的数据，stuname 学生姓名，Coursenames多个课程名，grades对应的多个分数；
public void addCourseGrade(String stuname,String Coursename,Integer grade) 增加学生及课程的数据，stuname 学生姓名，Coursename课程名，grade对应的分数；
public void delStudent(String stuname) 删出一个学生，stuname学生姓名；
public void delStuCourse(String stuname,String Coursename) 删出一个学生的一门课程，stuname学生姓名，Coursename课程名；
public double getPerAvgStudent(String stuname)返回一个学生的所有课程的平均成绩，stuname学生姓名；
public double getClassAvgCourse(String Coursename) 返回一个班某门课程的平均成绩，如果该班有同学没选修该门课程，平均成绩不计算该同学，Coursename为课程名。

package step1;
import java.util.*;
//在此写Class类

public class Class {
    String classname = null;
    String stuname = null;
    HashMap<String,ArrayList<HashMap<String,Integer>>> nameprojects = new HashMap<>();
    public Class(String classname){
        this.classname = classname;
    }

    public void addCourseGrade(String stuname,String Coursename,Integer grade){
        ArrayList<HashMap<String,Integer>> stuList = nameprojects.get(stuname);
        if(stuList == null) {
            stuList = new ArrayList<>();
            nameprojects.put(stuname, stuList);
        }
        HashMap<String,Integer> courseGrade = new HashMap<>();
        courseGrade.put(Coursename, grade);
        stuList.add(courseGrade);
    }
    public void addCourseGrade(String stuname,String[] Coursenames,Integer[] grades){
        for(int i = 0;i < Coursenames.length;i++){
            ArrayList<HashMap<String,Integer>> stuList = nameprojects.get(stuname);
            if(stuList == null) {
                stuList = new ArrayList<>();
                nameprojects.put(stuname, stuList);
            }
            HashMap<String,Integer> courseGrade = new HashMap<>();
            courseGrade.put(Coursenames[i], grades[i]);
            stuList.add(courseGrade);
        }
    }

    public void delStudent(String stuname){
        nameprojects.remove(stuname);
    }

    public void delStuCourse(String stuname,String Coursename) {
        for (Map.Entry<String, ArrayList<HashMap<String, Integer>>> delet : nameprojects.entrySet()) {
            if (delet.getKey().equals(stuname)) {
                for(HashMap<String,Integer> deletCourse : delet.getValue()){
                    deletCourse.remove(Coursename);
                }
            }
        }
    }

    public double getPerAvgStudent(String stuname){
        double sum = 0;
        int count = 0;
        for (Map.Entry<String,ArrayList<HashMap<String,Integer>>> find_name : nameprojects.entrySet()) {
            if(find_name.getKey().equals(stuname)){
                for(HashMap<String,Integer> SUM : find_name.getValue()){
                    for(Map.Entry<String,Integer> Sum : SUM.entrySet()){
                        sum = sum + Sum.getValue();
                        count++;
                    }

                }
            }
        }
        return sum/count;
    }

    public double getClassAvgCourse(String Coursename){
        double sum = 0;
        int count = 0;
        for (Map.Entry<String,ArrayList<HashMap<String,Integer>>> find_name : nameprojects.entrySet()) {
            for(HashMap<String,Integer> SUM : find_name.getValue()){
                for(Map.Entry<String,Integer> Sum : SUM.entrySet()){
                    if(Sum.getKey().equals(Coursename)){
                        sum = sum + Sum.getValue();
                        count++;
                    }
                }
            }
        }
        return sum/count;
    }
}