Java学习_初学阶段综合实验 总

Java学习_综合实验 总

综合实验1

设计一个名为Rectangle的类表示矩形。这个类包括以下内容：

两个名为width和height的double类型私有数据域，它们分别表示矩形的宽和高。

一个用于创建默认矩形的无参构造方法，设置width和height值都为1。

一个创建指定width和height值的矩形有参构造方法。

设置width和height的访问器和修改器。

一个名为getArea()的方法，返回矩形的面积。

一个名为getPerimeter()的方法，返回周长。

请去定义一个测试类Test，创建两个Rectangle对象：一个调用无参构造方法创建对象r1，修改r1对象的宽度值为10（可以自设）；一个调用有参构造方法创建对象r2，设置宽为4（可以自设），高为40（可以自设）。按照顺序显示每个矩形的宽、高、面积和周长。

实验代码

package Main;

public class Main {

	public static void main(String[] args) {
	
		Rectangle r1=new Rectangle();
		
		r1.setWidth(10);
		
		r1.getA();
		
		r1.getArea();
		
		r1.getPerimeter();
		
		Rectangle r2=new Rectangle(4,40);
		
		r2.getA();
		
		r2.getArea();
		
		r2.getPerimeter();
		
	}

}

class Rectangle{

	private double width;
	
	private double height;

	Rectangle(){
	
	setWidth(1);
	
	setHeight(1);
	
	}

	Rectangle(double w,double h){
	
	width=w;
	
	height=h;
	
	}

	public double getWidth() {
	
	return width;
	
	}
	
	public void setWidth(double width) {
	
	this.width = width;
	
	}
	
	public double getHeight() {
	
	return height;
	
	}
	
	public void setHeight(double height) {
	
	this.height = height;
	
	}
	
	public void getA(){
	
	System.out.println(width+" "+height);
	
	}
	
	public void getArea(){
	
	System.out.println(height*width);
	
	}
	
	public void getPerimeter(){
	
	System.out.println(height*2+width*2);
	
	}

}

实验结果

实验心得分享

无参构造方法中数据写在{}里而不是写在（）里。

无参构造方法中数据的定义为set数据名（填写数值）而并不是直接写成数据名=数值。

方法名的定义必须以get开头。

定义一个无参构造方法和一个有参构造方法需要写Rectangle r1=new Rectangle();和Rectangle r1=new Rectangle(填写数值);这两个，而不能用Rectangle r1=new Rectangle();一个来既表示无参构造方法又表示一个有参构造方法。

有参构造方法中定义两个数据中间用，分隔开，而不是；。

实例数据和参数名字不可以相同，需要做出区分，例如在有参构造的{}中height=h； ，而不是height=height；。

访问器用的是get，修改器用的是set。

Class Rectangle{}这个新的类需要写在public class 原类名{}的外面。

Rectangle r1=new Rectangle中r1是定义的变量名，可以进行修改，其中无参构造方法和有参构造方法两者的变量名不可以相同。

有参构造方法中的（）定义变量的时候，在变量名前需要写出它的基本数据类型是什么。

若文件只有一个类，则需要把数据写在mian方法之前的那个class中去。

Course Java=new Course（）；其中Java为对象的名字。

综合实验2

设计一个Course类并测试该类，这个类包括以下内容：

三个私有数据域，分别是String类型的课程名name、String类型的选课学生student[]数组（默认大小为10）、int类型的选课学生数num。

一个用于设置课程名name的有参构造方法。

num和student的访问器。

一个名为addStudent(String name)且无返回值的方法，用于为该课程添加选课学生,选课学生将保存在student数组中。

在类中的main方法中，创建一个课程名为“Java”的对象，调用addStudent()方法为该课程添加三个选课学生，输出选课人数，打印选课人的名字。

实验代码

package Maina;

public class Course {

	private String name;
	
	private String[] student=new String[10];
	
	private int num;

	public Course(){}
	
	public Course(String n){
	
	name=n;
	
	}

	public String getName() {
	
	return name;
	
	}
	
	public int getNum() {
	
	return num;
	
	}

	public String[] getStudent() {
	
	return student;
	
	}
	
	public void addStudent(String name){
	
	student[num]=name;
	
	num++;
	
	}

	public static void main(String[] args) {
	
		Course Java=new Course("Java");
		
		Java.addStudent("ls");
		
		Java.addStudent("lw");
		
		Java.addStudent("ll");
		
		System.out.println(Java.getNum());
		
		String[] s=Java.getStudent();
		
		for(int i=0;i<Java.getNum();i++){
		
			System.out.print(s[i]+"\n");
		}
	}
}

实验结果

综合实验3

设计一个People类，包含以下内容：

三个私有数据域，分别是姓名name、年龄age、性别gender。

设置四个构造方法，分别为空参数、一个参数、两个参数、三个参数构造方法，后两个构造方法分别使用this关键调用其他构造方法。

设置带返回字符串的getInfor（）方法，该方法需要返回当前对象的姓名name、年龄age、性别gender，需要使用this关键字。

设计测试类Test,创建两个Peoson类的对象perA和perB，通过构造方法设置姓名name、年龄age、性别gender成员变量值，调用getInfor（）方法输出对象perA和perB的信息。

实验代码

public class Test{
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		People perA = new People("李四",18,"男");
		People perB = new People("张三",18,"男");
		System.out.print(perA.getInfor());
		System.out.println();
		System.out.print(perB.getInfor());
	}
}
class People {
	private String name;
	private int age;
	private String gender;
	People(){
		
	}
	People(String name){
		this.name=name;
	}
	People(String name,int age){
		this(name);
		this.age=age;
	}
	People(String name,int age,String gender){
		this(name,age);
		this.gender=gender;
	}
	public String getInfor(){
		return"姓名为"+this.name+"年龄为"+this.age+"性别为"+this.gender;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
}

实验结果

实验心得分享

谁下面写对象，谁是主类。例如：设计测试类Test,创建两个Peoson类的对象，那么这个题中就是Test为主类，在它的下面创建两个Peoson类

在return中可直接写出“”并且内部写字符串

对象的写法:类名 对象名=new类名

调用对象方法的写法：对象名.方法名

This的用法：1、在构造方法里可以设置与成员变量相同名字的变量，后在{}中写this.成员变量名=你定义的与成员变量名相同的变量名;2、如果你有了一个参数的构造方法，要写用到上面参数的有两个参数的构造方法，你可以写this(上面你写到的那个参数);来直接调用上面提到的参数，如果要调用两个参数的构造方法，则写成this(第一个参数，第二个参数);中间是都好分隔开的，如果调用的是无参构造方法，那么就写this.();就可以，记住要写在{}里的第一条

普通方法是并列关系，并不需要去给他们排序，他们使用的顺序看main方法里调用方法的顺序

我们在程序运行后修改成员变量时，需要访问器与修改器，鼠标右击界面，选择Source选项，在选择菜单中Generate Getters and Setters选项可以快速选择你所需要的成员变量，为其写出访问器与修改器
设置了方法后，在下面的return中我们返回经过修改了的变量，可以写成this.变量，输出的就是最后通过方法的计算而得出的变量

综合实验4

设计一个Book类，包含以下内容：

两个私有数据域，分别是书名title、静态变量图书数量count。

设置带一个参数的构造方法，该构造方法中需设置图书的书名title和图书数量count加1。

设计TestBook类，在该类中创建三本书，并输出count的值。

实验代码

public class TestBook {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Book A1 = new Book("英语");
		Book B2 = new Book("体育");
		Book C3 = new Book("音乐");
		System.out.print(Book.getCount());
	}
}
class Book {
	private String title;
	private static int count;
	Book(){
			
	}
	Book(String title){
		this.title=title;
		count++;
	}
	public static int getCount(){
		return count;
	}
}

实验结果

实验心得分享

设置静态变量图书数量count，需要写上static,例如：private static int count;如果不加static，就是非静态变量，输出时会根据方法的计算，输出不同的结果

静态变量无论是谁，都可以调用，无论调用时前缀是谁，最后得到的值是一样的，不会改变

一个public class 内不可以写另一个class

设置的两个class类名不能相同

成员变量里有静态变量，在调用构造方法的时候不需要去为它写一个位置，例如 Book C3 = new Book(“音乐”);而我的成员变量是 private String title; private static int count; 这两个

静态变量直接可以进行计算，不需要用this来将它引入构造方法里，也可以直接return一下，作为返回值

综合实验5

设计一个名为Person的类和它的两个名为Student和Teacher的子类。

每个人都有工号、姓名、地址、电话号码（定义为实例变量）。

定义Person类的无参构造方法、带3个参数的有参构造方法。

定义Student类和Teacher类的有参构造方法，此处需要使用super关键字调用父类的构造方法。

每个人都需要有工作行为（定义实例方法）。

学生有年级属性。

老师有办公室和工资属性。

学生的工作是学习，老师的工作是上课，任务不同，需要重新定义工作行为。

为每个类定义一个打印print()方法，输出各自的属性信息。

同时编写一个Test类，创建Person、Student、Teacher类的对象，分别输出他们的属性信息，即调用print（）方法，并调用各个对象的工作work()方法。

实验代码

//Preson.java
package p1;

public class Person {
	public String id;
	public String name;
	public String add;
	public String tel;
	Person(){}
	public Person(String id, String name, String add, String tel) {
		this.id = id;
		this.name = name;
		this.add = add;
		this.tel = tel;
	}
	public Person(String id, String name, String add) {
		super();
		this.id = id;
		this.name = name;
		this.add = add;
	}
	public void work(){
		System.out.println("人们需要工作");
	}
	public void print(){
		System.out.print(this.id+","+this.name+","+this.add+","+this.tel+",");
	}
}


//Student.java
package p1;

public class Student extends Person{
	public String grade;

	public Student(String id, String name, String add, String tel,String grade) {
		super(id,name,add,tel);
		this.grade = grade;
	}

	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("学生的工作是学习");
	}

	@Override
	public void print() {
		// TODO Auto-generated method stub
		super.print();
		System.out.println(this.grade);
	}
}


//Teacher.java	
package p1;

public class Teacher extends Person{
	public String office;
	public double wage;
	public Teacher(String id, String name, String add, String tel,String office, double wage) {
		super(id,name,add,tel);
		this.office = office;
		this.wage = wage;
	}
	@Override
	public void work() {
		// TODO Auto-generated method stub
		System.out.println("老师的工作是上课");
	}
	@Override
	public void print() {
		// TODO Auto-generated method stub
		super.print();
		System.out.println(this.office+","+this.wage);
	}
}


//Test.java
package p1;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person p=new Person("1001","张三","呼和浩特","1868686");
		
		Student s=new Student("20201012","李四","江南","1525252","大一");
		Teacher t=new Teacher("202110","王五","包头","1575757","607",5000.0);
		p.print();
		System.out.println();
		s.print();
		t.print();
		p.work();
		s.work();
		t.work();
	}

}

实验结果

实验心得分享

如果要跨包定义一个对象，需要在开头package的下方写import 跨的包名字.class文件名字;

构造有参构造方法可以从source里选择Generate Constructor using Fields,再去选择你需要添加的成员变量，就可以快速生成参构造方法
方法的重写：可以从source里选择Override选择父类里你需要去重写的方法，就可以快速生成方法的重写；重写System.out.print();类的方法时不需要写出super.方法名();；重写输出属性类的方法时需要你先用super.方法名();来把父类方法的属性先调用过来，然后在去输出你自己的属性

在定义对象的时候需要你去写出它本身和父类所有的属性

第一个父类必须写上无参构造方法，因为子类会去调用父类的无参构造方法，如果父类不写，写子类时会出错误

如果内容是分开Java文件去写的，那么成员变量、无参构造方法、有参构造方法、实例方法都需要加上public；分开写Java文件需要去仔细检查你的print与println，以避免出现输出内容分开的情况；分开写Java文件只有最后定义对象调用并且输出方法的文件是需要写main方法并且在main方法下书写代码的

子类在写有参构造方法的时候需要去把父类和自己所含有的特殊都写在构造方法的（）中去，并且在{下的第一行写的是super(里面写你调用的父类的成员变量，若有多个，它们用逗号来分隔);之后属于子类的特殊成员变量还是用this.成员变量来书写

在写输出属性的方法里每个this.成员变量最好用+“，”+来分隔开，否则会把所有数据连在一起区分不开

名字extends名字，前面是子类的名字，后面是父类的名字

在最后调用输出方法的时候只需要写对象名.方法名();就可以了，括号内不需要引入变量

super在调用父类无参构造方法的时候开业被省略成为隐式super，而在调用有参数的时候是必须被写出来的成为显式super

综合实验6

定义如下的继承关系，要求如下：

注：属性前带“-”号表示该属性私有。
（1）toString()显示当前对象的基本信息
（2）在客户类中定义静态方法show，用来显示对象的基本信息，通过调用toString()方法实现。
（3）采用多态实现上述要求

问：如何判断多态，即多态的基本要求是什么？

答：要有子类对父类的继承；在子类中有对父类的方法的重写；使用父类类型的引用指向子类的对象

问：针对本例，谈一谈面向对象三大特性的特点是什么？体现在什么地方

答：面向对象三大特性的特点是封装，继承，多态；封装体现在所有类中的变量是私有的，继承体现在子类中可以引用父类的方法和构造方法，多态体现在每个类的toString方法上

请在多态的基础上，创建一个ArrayList，然后向列表中添加一个Student对象、一个Teacher对象、一个CollegeStudent对象，然后使用循环调用对象的toString（）方法显示列表中所有的元素。

实验代码

package Main;

import java.util.ArrayList;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student s = new Student("lisan",92);
		Main.show(s);
		Teacher t = new Teacher("gaoshu","gaofen");
		Main.show(t);
		CollegeStudent c = new CollegeStudent("gaoshu",94,"gaofen");
		Main.show(c);
		ArrayList<People> list= new ArrayList<>();
		list.add(s);
		list.add(t);
		list.add(c);
		for(People p:list){
			System.out.println(p.toString());
		}
	}
	
	public  static void show(People p){
		System.out.println(p.toString());
	}
}
class People{
	private String name;
	People(){
		
	}

	public People(String name) {
		super();
		this.name = name;
	}

	@Override
	public String toString() {
		return "People [name=" + name + "]";
	}
	
}
class Student extends People{
	private double score;

	@Override
	public String toString() {
		return super.toString()+","+"Student [score=" + score + "]";
	}

	public Student(String name, double score) {
		super(name);
		this.score = score;
	}
	
}
class Teacher extends People{
	private String title;

	public Teacher(String name, String title) {
		super(name);
		this.title = title;
	}

	@Override
	public String toString() {
		return super.toString()+","+"Teacher [title=" + title + "]";
	}
}
class CollegeStudent extends Student{
	public CollegeStudent(String name, double score, String major) {
		super(name, score);
		this.major = major;
	}

	@Override
	public String toString() {
		return super.toString()+","+"CollegeStudent [major=" + major + "]";
	}
	private String major;

}

实验结果

实验心得分享

ArrayList是添加对象的，所以你需要在它之前将每个类都实例化，ArrayList作为主类，需要涉及多态，即<>里写的是你最上面的父类People，这时不需要将People实例化，而是在静态方法声明的时候将People实例化，方法内容就是将每个对象的内容都转化为String类型，再用静态方法所属类的类名. 静态方法（对象名）来将原来的内容通过方法修改，再把每一个类都add进入ArrayList内

第一个父类必须写好无参构造方法，后面的子类如果不写无参构造方法，就必须在下面的子类里写显式的super（父类的参数）父类的参数有几个就写几个，包括着父类的父类所继承下来的参数
Private属于封装

有参构造方法和对object类的toString的重写都可以通过鼠标右键，进入source菜单内，有参构造方法去选择Generate Constructor，toString的重写去选择Generate toString（），其中重写的时候需要你去写上super.toString（表示父类已经重写过的toString方法）+你新重写的内容

For each语句的书写：for（主类 对象名: ArrayList的对象名）{输出主类的对象名}

无参构造方法可以写成缺省的，即没有public

该题中，因为你没有将成员变量赋值，所以你需要在实例化的时候在（）内将你的内容赋值上去，继承来的和自己特有的都需要赋值，赋值的时候注意看好变量的类型

综合实验7

编写一个ComputerAverage抽象类，类中有一个成员变量double类型的数组data和一个抽象方法求平均分average（double[] data）。定义Athletes类和Student类，它们都是ComputerAverage的子类，Atheletic类中计算选手的平均成绩的方法是去掉一个最低分，去掉一个最高分，然后求平均分。Student类中计算平均分的方法是直接是总分除以总科目。（要求：定义ComputerAverage类型的子类对象（上转型对象），并调用重写的方法averge。）

实验代码

package Main;

import java.util.Arrays;
import java.util.Scanner;


public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner input = new Scanner(System.in);
		int len = input.nextInt();
		double[] data= new double[len];
		for(int i=0;i<len;i++){
			data[i]=input.nextDouble();
		}
		ComputerAverage a = new Athetes();
		double s = a.average(data) ;
		System.out.println(s);
		ComputerAverage b = new Student();
		double e = b.average(data) ;
		System.out.println(e);
	}
}
abstract class ComputerAverage{
	abstract double average(double[] data);
}
class Athetes extends ComputerAverage{

	@Override
	double average(double[] data) {
		// TODO Auto-generated method stub
		Arrays.sort(data);
		double q = 0.0;
		for(int i=1;i<data.length-1;i++)
		q +=data[i];
		return q/(data.length-2);
	}
}
class Student extends ComputerAverage{

	@Override
	double average(double[] data) {
		// TODO Auto-generated method stub
		Arrays.sort(data);
		double w = 0.0;
		for(int i=0;i<data.length;i++)
		w +=data[i];
		return w/data.length;
		
	}
}

实验结果

实验心得分享

抽象类的定义就是在class之前加上abstract，其中所要写的方法也在最前方写上abstract

abstract指的就是模板，每一个子类都需要重写那个方法、

在排列数组的时候可以用Arrays.sort(data);，同时写上import java.util.Arrays;，来迅速排列这个数组，再把范围取到第二位开始，倒数第二位结束就可以把最大值和最小值排除在外

向上转型分两种，第一种是在定义一个对象a的时候父类打头，子类结尾，另一种是在定义一个对象b的时候子类打头，子类结尾，再父类方法中调用的变量是父类的，方法又在子类被重写，那么此时你输出b对象的重写父类后的方法，它会自动向上转型

在方法中有if和else的语句是可以有多个return值的，但是return只能是返回一个变量或者是一个计算式子

记住，数组的长度是属性的length，是在它后面不带（）的

综合实验8

编写一个类A，该类有如下一个方法：
publicint f(int a,int b){
//要求该方法将返回a和b的最大公约数
}
再编写一个该类的子类B，要求子类重写方法f()，而且重写的方法将返回两个正整数的最小公倍数。

实验代码

package Main;

import java.util.Scanner;

public class A {

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int a = input.nextInt();
		int b = input.nextInt();
		A r = new A();
		System.out.println(r.f(a, b));
		A q = new B();
		System.out.println(q.f(a, b));
		
	}
	
		public int f(int a,int b){
			int c = 1;
			if(a==0||b==0){
				System.out.println("公约数为:"+0);
				return 0;
			}
			else{
				for(int i =1;i<=a &&i<=b;i++){
					if(a%i==0 && b%i ==0){
						c=i;
					}
				}
				return c;
			}
			
		}
}
class B extends A{

	@Override
	public int f(int a, int b) {
		// TODO Auto-generated method stub
		int d;
		for(d = a;;d++){
			if(d%a==0 && d%b==0){
				break;
			}
		}
		return d;
	}
}

实验结果

---

以上就是本文全部内容，如果它对您有帮助，请您帮我点个赞，这对我真的很重要