Java头歌实验梳理
实验一: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;
}
}