Java实验复习（建议收藏）

最新推荐文章于 2023-01-11 11:42:28 发布

Xlorb

最新推荐文章于 2023-01-11 11:42:28 发布

阅读量3.2k

点赞数 8

分类专栏： java基础实验文章标签： java

本文链接：https://blog.csdn.net/m0_54453933/article/details/116544862

版权

java基础实验专栏收录该内容

4 篇文章 1 订阅

订阅专栏

实验一数组，循环语句和输入输出实验

实验目的及任务

1、学会使用main方法
2、掌握数组、输入输出语句、循环语句的用法。

实验内容

1、定义一个类Calculate ，其中有一个main方法。
2、在main方法中，首先调用Scanner类，从键盘输入一个整数放到变量count中，count表示将要从键盘读入的整数个数，然后调用循环语句从键盘读入count个整数，并保存到数组value中。
（1）将这count个整数求和，然后求出平均值。最后输出和及平均值。
（2）找到数组中所有的数组元素大于平均值的那些元素。

代码

import java.util.Scanner;

public class Calculate {
    private static float average = 0;
    private static float sum = 0;

    public static void main(String[] args) {
        try (Scanner sc = new Scanner(System.in)) {
            int count = sc.nextInt();
            int[] value = new int[count];
            for (int i = 0; i < value.length; i++) {
                value[i] = sc.nextInt();
            }
            for (int j : value) {
                sum += j;
                average = sum / value.length;
            }
            for (int j : value)
                if (j > average)
                    System.out.println(j);
        }
    }
}

Scanner输入使用 Scanner sc = new Scanner(System.in);
sc.nextInt()是输入一个整型
强化循环语句for(对象的类型对象名：需要遍历的数组对象名)

实验二模拟银行账户存、取款、转账功能

实验目的及任务

1、学会根据实际问题抽象出类模型
2、学会分析实际问题，并定义合适的属性、方法。
3、学会利用面向对象思路解决实际问题

实验内容

1、建立一个银行账户类（Acount），具有建立新帐号、查询余额、存款、取款、转账（即从本账户把钱转给另一个账户）的功能，每个账户包括账号、姓名、账户余额三个属性。
2、在测试类（AccountManager）的main方法中进行测试账户类。具体如下：
创建（“001”，“张三”，1000）、（“002”，“李四”，300）两个账号。
分别给两个账号各存入500元。
然后张三取出200元。
张三转给李四300元。
最后显示2人的余额。

代码

Acount类：

public class Acount {
    private String ID;
    private float balance;
    private String name;

    public Acount(String ID, String name, float balance) {
        this.ID = ID;
        this.name = name;
        this.balance = balance;
    }

    //查询余额
    public void queryBalance() {
        System.out.println(balance);
    }

    //存款操作
    public void  deposit(float m) {
            balance += m;
    }

    //取款操作
    public boolean withdrawal(float m) {
        if (m < 0) return false;
        else {
            balance -= m;
            return true;
        }
    }


    //转账操作（即从本账户把钱转给另一个账户）
    public boolean transfer(float m, Acount other) {
        if (m < 0 || m > balance) return false;
        else {
            other.balance += m;
            balance -= m;
            return true;
        }
    }

    //重构toString方法
    @Override
    public String toString() {
        return " ID: " + ID +
                " name: " + name +
                " balance " + balance;
    }

}

AccountManger函数类

public class AccountManger {
    //测试
    public static void main(String[] args) {
        Acount acount1 = new Acount("001", "张三", 1000);
        Acount acount2 = new Acount("002", "李四", 300);
        acount1.deposit(300);
        acount2.deposit(300);
        if (acount1.transfer(300, acount2))
            System.out.println(acount1 + "余额不足");
        System.out.println(acount1 + "\n" + acount2);

    }
}

Acount类是机器操作的过程不需要输出语句，因此用布尔类。
AccountManger类是人机交互的过程，需要有人可以看懂的数据。因此存在System.out.println（）

实验四、继承

一、实验目的及任务

学会使用继承机制编写程序
学会利用面向对象思路解决实际问题

二、实验环境

PC 系列微机，Windows XP、Windows2003。 JDK150 或更高版本。

三、实验步骤

在实验 3 的基础上编写银行账户 Account 的子类定期账户类和信用卡账户类，重新覆盖存钱、取钱、转账的方法。信用卡账户增加透支额度属性，但不能转账，取钱额度为账户余额加透支额度的总和。定期账户类增加存期属性（以年为单位）只能开户时确定余额，不能再次存钱，也不能转账，到期才能取钱，而且一次必须全部取出。
编写测试类 Test，其中的 main 方法中完成以下功能：创建定期账户 count1（“001”，“张三”，3000,3）；其中 3000 为存款额度，3 位存期 3 年。创建信用卡账户 count2（“002”，“李四”，4000,10000）；其中 4000 为存款额度，10000 位透支额度。测试 count1 取钱 200 元、取钱 3000 元、存钱 5000 元。测试 count2 取钱 12000 元、取钱 20000 元、存钱 6000 元、取钱 20000 元。

四、代码、测试用例和测试结果

package myproject; 
public class Acount {
	private String id; 
	private String name; 
	public float balance; 
	public Acount(String id, String name, float balance) { 				 	 
	this.setId(id); 
	this.setName(name); 
	this.setBalance(balance); 
	}
	
	public void setId(String id) 
		{ this.id = id; }
	public void setName(String name) 
		{ this.name = name; }
	public void setBalance(float balance) 
		{ this.balance = balance;}
	public String getId() 
		{ return id; }
	public String getName() 
		{ return name; }
		
	// 显示余额 
	public float getBalance() 
		{ return balance; }
		
	// 存款操作 
	public void deposit(float x) { 
		if (x > 0) balance += x; 
		else	System.out.println("存款不能为" + x); }
		
	// 取款操作 
	public void witgdraw(float x) { 
	if (jurge(balance, x)) balance -= x; 
	else System.out.println("存款不足"); }
	
	// 判断 
	public boolean jurge(float a, float b) { return a - b > 0; }
	
	// 转账
	public void transfer(float tras, Acount other) { 
	if (jurge(balance, tras)) { 
			other.balance += tras;
			balance -= tras; 
			} 
			else
				System.out.println("存款不足"); }
	public static void main(String[] args) { 
		Acount acount1 = new Acount("001", "张三", 100); 
		// 转账测试 
		Acount acount2 = new Acount("002", "李四", 200);
		acount2.transfer(100, acount1); 
		System.out.println(acount2.balance); } 


package myproject; 
public class Cred extends Acount { 
	private float credit; 
	private final float credit1;
	public Cred(String id, String name, float balance, float credit) {
		 super(id, name, balance); 
		 this.setCredit(credit); 
		 this.credit1 = credit; }
	public void setCredit(float credit) 
		{ this.credit = credit; }
	public float getCredit()
		 { return credit; }
	// 转账业务 
	public void transfer(float tras, Acount other) { 
	System.out.println("信用卡不能运行转账业务"); }
	// 取款操作
	public void witgdraw(float x) { 
		if (balance + credit > x) { 
			if (balance > x) 
				balance -= x; 
			else {credit += (balance - x); 
				balance = 0; }
			print(); } 
		else 
			System.out.println("余额不足，不能取款"); }
		// 存款操作 
	public void deposit(float x) { 
		if (jurge()) { 
			credit += x; if (jurge()) balance = 0; 
		else balance += (credit - credit1); }
		print(); }
	// 判断 
	private boolean jurge() 
		{ return credit < credit1; }
	public float getCredit1() 
		{ return credit1; }
	private void print() 
	{ System.out.println(getName() + "还能透支："
						 + credit + "余额为：" + balance); }
	}
	package myproject;
	public class Termaccount extends Acount { 
		private int year; 
	public Termaccount(String id, String name, float balance, int year)	
	{	
		super(id, name, balance); 
		this.setYear(year); }
	public void setYear(int year) 
		{ this.year = year; }
	public int getYear() 
		{ return year; }
	@Override 
	// 存款 
	public void deposit(float x) 
		{ System.out.println(getName() + "现在定期存款不能存入");
	// 取钱 
	public void witgdraw(float x) 
	{ if (year >= 3 && x == balance) 
		{ System.out.println(getName() + "提取的金额为" + balance); 
		balance = 0; } 
		else
			System.out.println(getName() + "无法提取，时间不足或者不是全部 提取"); }
			// 转账 
	public void transfer(float tras, Acount other) 
		{ System.out.println(getName() + "定期存款不支持转账服务"); }

五、实验总结

在写程序时，要先想好应该写那些，应该怎么写。
在写代码之前，要先把流程画在纸上。
写代码时，需要有一定的注释，确保在引用类的时候可读性增加。

实验五、对象的初始化顺序

一、实验目的及任务

1、深入理解普通对象的初始化执行顺序
2、深入理解有static成员变量时对象的初始化执行顺序
3、深入理解在有继承关系时，普通对象的初始化执行顺序
4、深入理解在有static成员变量、有继承关系时，对象的初始化执行顺序
5、理解static成员变量和对象变量之间的区别

二、实验环境

Windows10。
JDK150

三、实验步骤

输入以下2个程序代码，观察执行结果，深刻理解体会每行代码的作用、执行顺序。`

Computer.java
package ch6;
public class Computer {                        //电脑
	private MainBoard mb=new MainBoard();      //主板，域成员变量
	private HardDisk hd=new HardDisk("");       //硬盘，域成员变量
	static{
		System.out.println("Computer类的静态代码块输出的语句，下面开始定义静态成员变量");                              //静态代码段
	}
	private static Cpu cpu=new Cpu("Intel");          //CPU，静态成员变量
	public Computer(){                           //默认（无参）构造方法      
		System.out.println("我是一台电脑，我刚被创建（制造）出来,我是用无参数的构造方法创建的");
	}
	public Computer(MainBoard mb,HardDisk hd,Cpu cpu) {    //带参构造方法
		this.hd = hd;this.mb = mb;this.cpu = cpu;
		System.out.println("我是一台电脑，我刚被创建（制造）出来,我是用有参数的构造方法创建的");
	}
	public static void main(String args[]){
		System.out.println("main方法：下面开始创建（制造）第一台电脑,我只需要Cpu是Intel的，别的不在乎,所以用无参数的构造方法创建");
		Computer computer1=new Computer();

		System.out.println("\n\nmain方法：下面开始创建（制造）第二台电脑,我很关注主板、硬盘、Cpu的品牌，所以用有参数的构造方法创建");
		System.out.println("main方法：先创建三个成员对象");
		MainBoard mb=new MainBoard("联想");
		HardDisk hd=new HardDisk("西数");
		Cpu cpu=new Cpu("Intel");

		System.out.println("main方法：然后调用Computer的有参数构造方法创建电脑对象");
		Computer computer2=new Computer(mb,hd,cpu);
	}
}

class HardDisk{
	String type;
	public HardDisk(){                         //无参构造方法
		type="没有品牌";
		System.out.println("我是一个硬盘，我刚被创建（制造）出来,我是用无参数的构造方法创建的,我的型号是"+type);
	}
	public HardDisk(String type){                //有参构造方法
		this.type=type;
		System.out.println("我是一个硬盘，我刚被创建（制造）出来,我是用有参数的构造方法创建的,我的型号是"+type);
	}
}
class MainBoard{
	String type;
	public MainBoard(){
		type="没有品牌";
		System.out.println("我是一块主板，我刚被创建（制造）出来,我是用无参数的构造方法创建的,我的型号是"+type);
	}
	public MainBoard(String type){
		this.type=type;
		System.out.println("我是一块主板，我刚被创建（制造）出来,我是用有参数的构造方法创建的,我的型号是"+type);
	}
}
class Cpu{
	String type;
	public Cpu(){
		type="没有品牌";
		System.out.println("我是一个CPU，我刚被创建（制造）出来,我是用无参数的构造方法创建的,我的型号是"+type);
	}
	public Cpu(String type){
		this.type=type;
		System.out.println("我是一个CPU，我刚被创建（制造）出来,我是用有参数的构造方法创建的,我的型号是"+type);
	}
}

2、

NoteComputer.java
package ch6;
public class NoteComputer extends Computer {
	static{
		System.out.println("NoteComputer类的静态代码块输出的语句，下面开始定义静态成员变量");
	}
	private static Displayer displayer=new Displayer();
	public NoteComputer() {
		System.out.println("我是一台笔记本电脑，我刚被创建（制造）出来,我是用无参数的构造方法创建的");
	}
	public NoteComputer(MainBoard mb,HardDisk hd,Cpu cpu,Displayer displayer) {
		super(mb,hd,cpu);
		this.displayer = displayer;
		System.out.println("我是一台笔记本电脑，我刚被创建（制造）出来,我是用有参数的构造方法创建的");
	}

	public static void main(String[] args) {
		System.out.println("main方法：下面开始创建（制造）第一台笔记本电脑,我只需要Cpu是Intel的，别的不在乎,所以 要用无参数的构造方法创建");
		NoteComputer computer1=new NoteComputer();
		System.out.println("\n\nmain方法：下面开始创建（制造）第二台笔记本电脑,我很关注主板、硬盘、Cpu、显示器的品牌，所以要用有参数的构造方法创建");
		System.out.println("main方法：先创建四个成员对象");
		MainBoard mb=new MainBoard("联想");
		HardDisk hd=new HardDisk("西数");
		Cpu cpu=new Cpu("Intel");
		Displayer displayer=new Displayer("IBM");
		System.out.println("main方法：然后要调用NoteComputer的有参数构造方法创建笔记本电脑对象");
		NoteComputer computer2=new NoteComputer(mb,hd,cpu,displayer);
	}
}
class Displayer{
	String type;
	public Displayer(){
		type="没有品牌";
		System.out.println("我是一块笔记本专用显示器，我刚被创建（制造）出来,我是用无参数的构造方法创建的,我的型号是"+type);
	}
	public Displayer(String type){
		this.type=type;
		System.out.println("我是一块笔记本专用显示器，我刚被创建（制造）出来,我是用有参数的构造方法创建的,我的型号是"+type);
	}
}

四、代码、测试用例和测试结果

先进入Computer类，输出Computer类的静态代码块，再转向Cpu类，输出Cpu的静态代码块。进入main函数，输出第一个System.out.println，进入Computer类，创造一个Computer类的新对象computer1.进入Computer类以后,对Computer类域进行初始化。进入Mainboard类进入Mainboard的无参构造方法创造一个新的无参对象。进入HardDisk类进入HardDisk的无参构造方法，创造一个无参对象。进入C omputer类的无参构造方法，输出构造方法内的System.out.println
输出main函数的第二个System.out,println和第三个System,out,println进入Mainboard类进入MainBoard的有参构造方法，创造一个新的有参对象，进入HardDisk类进入HardDisk的有参构造方法，创造一个新的有参对象，进入Cpu类进入Cpu的有参构造方法，创造一个新的有参对象。
输出第四个System.out.println。进入Computer类的有参构造方法。首先进入MainBoard类，进入MainBoard的有参构造方法创造一个有参对象。进入HardDiSk类，进入HardDisk的有参构造方法创造一个有参对象。由于Computer类中的Cpu 名字为cpu时Computer类的静态成员变量，故无法创造新的对象。然后输出Computer类的有参构造方法中的System.out.println.最后退出程序进程。
NoteComputer时Computer的子类，当运行时，先遍历Computer类的字段，然后再遍历NoteCompuer的字段，输出Computer的静态代码块，和创造静态成员变量后，输出NoteComputer的静态代码块。
输出main函数的第一个System.out.println,进入NoteComputer类，运行NoteComputer的无参构造方法创造一个新的对象，进入Computer类，继承Computer类的无参构造方法。后输出NoteComputer的无参构造方法
输出main函数的第二个System.out.println以及第三个System.out.println.进入MainBoard类，进入MainBoaed的有参构造方法。进入HardDisk类，进入HardDisk的有参构造方法。进入Cpu类，进入Cpu的有参构造方法。进入Displayer类，进入Displayer的有参构造方法
输出main函数的第四个System,out.println进入NoterComputer类的有参构造方法，进入Computer的有参构造方法进行继承，Cpu为静态成员变量，无法改变，故无法创造。进入Displayer类，进入Displayer的有参构造方法创造对象。最后退出程序。

五、实验总结

1.静态代码块再直接引用类的时候会出现，其他时候不会出现
2.类中main方法运行时，会先运行类域中的静态代码
3.再main函数的过程中，用到哪一个类就会去哪一个类中寻找
4.有继承关系的两个类先运行其父类在运行子类

实验六、接口和抽象类

一、实验目的及任务

1．掌握构造类和创建对象的方法；
2. 掌握修饰符和构造方法的使用；
3. 掌握接口的用法。

二、实验环境

Windows10。
JDK150

三、实验步骤

1、编写接口（Shape），具有getArea()、draw()两个方法；编写类圆（Circle）实现接口Shape，具有属性半径（r），并实现方法getArea()、draw()。其中draw()只是向控制台输出“I am a circle”。注意要有带参数的构造方法；编写类长方形（Rectangle）实现接口Shape，具有属性长（x）、宽(y)，并实现方法getArea()、draw()。其中draw()只是向控制台输出“I am a rectangle”。注意要有带参数的构造方法。测试所定义的类。
2、定义抽象类ShapeClass，具有getArea()、draw()两个方法；编写类圆（CircleClass）继承抽象类ShapeClass，具有属性半径（r），并实现方法getArea()、draw()。其中draw()只是向控制台输出“I am a circle”。注意要有带参数的构造方法；编写类长方形（RectangleClass）继承抽象类ShapeClass，具有属性长（x）、宽(y)，并实现方法getArea()、draw()。其中draw()只是向控制台输出“I am a rectangle”。注意要有带参数的构造方法。测试所定义的类。

四、代码、测试用例和测试结果

1.代码

package Shape;

public interface Shape {
    double getArea();//面积抽象

     void draw();//输出抽象

}
package Shape;

public class Circle implements Shape {
    private double r;

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

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

    @Override
    public void draw() {
        System.out.println("I am a circle");
    }
}
package Shape;

public class Rectangle implements Shape {
    private double length, width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double getArea() {

        return length * width;
    }

    @Override
    public void draw() {

        System.out.println("I am a rectangle");
    }
}
//测试
package Shape;

public class Text {

    public static void main(String[] args) {
        Shape s;
        //测试半径为2的⚪
        s = new Circle(2);
        printShape(s);
 //测试三边为1 2 的长方形
        s = new Rectangle(1, 2);
        printShape(s);
}


    private static void printShape(Shape s) {//Shape是接口。
        System.out.println(s.getArea());
        s.draw();
    }
}

2.代码

package Shape;

abstract class ShapeClass{
    	abstract double getArea();

    	abstract void draw();
}

package Shape;

import Shape.ShapeClass;

public class CircleClass extends ShapeClass {
    private double radius;

    public CircleClass(double radius) {
        this.radius = radius;
    }

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

    @Override
    void draw() {
        System.out.println("I am a circle");
    }
}
package Shape;

import Shape.ShapeClass;

public class RectangleClass extends ShapeClass {
    private double a, b, c;

    public RectangleClass(double a, double b) {
        this.a = a;
        this.b = b;
    }

    @Override
    double getArea() {
        return a * b;
    }

    @Override
    void draw() {
        System.out.println("I am a rectangle");
    }
}



测试
package Shape;

public class Text {

    public static void main(String[] args) {
 //测试半径为2的⚪
   		ShapeClass circle = new CircleClass(2);
        printShapeClass(circle);
 //测试三边为1 2 的长方形
       ShapeClass rectangle = new RectangleClass(1, 2);
       printShapeClass(rectangle);
    }

 private static void printShapeClass(ShapeClass s) {
//ShapeClass是抽象类方法，可以用于此抽象类方法的全部子类
        System.out.println(s.getArea());
        s.draw();
    }
}

五、实验总结

1.接口规定了功能，并且不能改变
2.抽象类可以被其他类继承
3.在创造对象时，接口可以表示接口下的所有类
4.在创造对象时，抽象类可以表示抽象类的所有子类

实验七、自定义异常类

一、实验目的及任务

掌握异常类的定义方法；
掌握抛出异常和捕获异常的方法。

二、实验环境

Windows10。
JDK15.0.
IntelliJ IDEA Community Edition 2021.1

三、实验步骤

1、定义一个分数异常类ScoreException，表示分数异常，一般当分数小于0或大于200时会抛出这个异常，异常的默认信息是“分数异常，分数应该在0到200之间”。
2、定义一个学生类Student，具有name、age、score属性，具有getName、setName、getAge、setAge、getScore、setScore和print方法，print方法输出属性信息，具有3个参数的构造方法Student(String name ,int age,double score)，在构造方法中判断score是否在0-200之间，如果不在这个范围则抛出ScoreException；在setScore方法中也要判断形参score是否在0-200之间，如果不在这个范围则抛出ScoreException。
3、在main方法中完成如下工作：
（1）创建对象zhangsan=new Student(“张三”，20，220)；要求能捕获异常
（2）创建对象lisi=new Student（“李四”，30，120）；
（3）调用lisi的setScore()方法给score赋值230，要求能捕获异常。

四、代码、测试用例和测试结果

package ExceptionScore;

import java.io.Serial;

public class ScoreException extends Exception {
    @Serial
    private static final long serialVersionUID =-7010206068266292459L;

    public ScoreException() {
        super();
    }

    public ScoreException(String message) {
        super(message);
    }

    public ScoreException(String message, Throwable cause) {
        super(message, cause);
    }

    public ScoreException(Throwable cause) {
        super(cause);
    }
}
package ExceptionScore;

public class Student {
    private String name;
    private int age;
    private double score;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                "age=" + age +
                ", score=" + score +
                '}';
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.setScore(score);
    }

    public double getScore() {
        return score;
    }

    public int getAge() {
        return age;
    }
    public String getName(){
        return name;
    }
    private void setScore(double score) {
        try {
            this.score = score;
            jurge();
        } catch (ScoreException e) {
            e.printStackTrace();
        }
    }

    private void jurge() throws ScoreException {
        if (score < 0 || score > 200)  throw new ScoreException("分数异常，分数应该在0到200之间");
    }

    public static void main(String[] args) {//text测试异常方法
        Student lisi = new Student("李四", 30, 120);
        print(lisi);
        Student zhangsan;

        zhangsan = new Student("张三", 20, 220);
        lisi.setScore(230);
    }

    private static void print(Student lisi) {
        System.out.println(lisi.toString());
    }
}

1.score∈(0,200)因此没有错误
2.Score = 220 >200 抛出ScoreException错误
3.Score = 230 >200 抛出ScoreException错误

五、实验总结

1.创建异常类时要继承Exception，不能继承Throwable，也不能继承RangeException.
2.在使用时要throw出异常类：throw new 异常类类名（）.
3.不应该在构造器中进行异常类判断，java是面向对象编程前提是必须有对象
4.如果这样写则不会显示错误的所在位置
e.printStackTrace();这个方法当捕获ScoreException时，则会输出错误的所在位置，并且以红色字体表明。
5.异常类需要serialVersionUID 这个是由电脑运用算法得出的一个long值。人工不能随意修改。

实验八、字符串

一、实验目的及任务

1、学会字符串的拆分、查找、类型转换
2、学会数组的用法

二、实验环境

Windows10。
JDK16.0
IntelliJ IDEA Community Edition 2021.1

三、实验步骤

建立一个字符串操作类（StringDemo），在main函数中做一下操作：
1、定义字符串变量String s1=”I am a good student”;
String s2=”I am a good worker”;
String s3=”3,6,12,20”;
2、用compareTo方法比较s1和s2的大小，并输出比较结果
3、用StringTokenizer类将s1以空格为分隔符拆分成多个单词，并输出每个单词
4、用split方法将s2以空格为分隔符拆分成多个单词，并输出每个单词
5、用indexOf方法在s1中查找单词student，如找到，输出所在位置。
6、用split方法将s3以半角逗号为分隔符拆分成字符串数组sArray，然后用Integer类的parseInt方法将数组中的每个元素变成int型数，放到int型数组iArray中，然后将iArray中的元素累计求和，并输出和。

四、代码、测试用例和测试结果

package Stringtext;

import java.util.StringTokenizer;

public class StringDemo {
    public static void main(String[] args) {
        String s1 = "I am a good student";
        String s2 = "I am a good worker";
        String s3 = "3,6,12,20";

        //用compareTo比较S1 S2的大小并且输出结果
        System.out.println(s1.compareTo(s2));

        //用StringTokenizer类将s1以空格为分隔符拆分成多个单词，并输出每个单词
        StringTokenizer st = new StringTokenizer(s1, " ");
        while (st.hasMoreElements())
            System.out.println(st.nextToken());

        //用split方法将s2以空格为分隔符拆分成多个单词，并输出每个单词
        String[] result = s2.split(" ");
        for (String i : result)
            System.out.println(i);

        //用indexOf方法在s1中查找单词student，如找到，输出所在位置。
        int s = s1.indexOf("student");
        if (s != -1) {
            String sou = Integer.toString(s);
            System.out.println(sou);
        } else
            System.out.println("未找到此单词，请重新输入");

        //用split方法将s3以半角逗号为分隔符拆分成字符串数组sArray，
        //然后用Integer类的parseInt方法将数组中的每个元素变成int型数，放到int型数组iArray中，
        //然后将iArray中的元素累计求和，并输出和。
        String[] sArray = s3.split(",");
        int[] iArray = new int[sArray.length];
        for (int i = 0; i < sArray.length; i++)
            iArray[i] = Integer.parseInt(sArray[i]);
        int sum = 0;
        for (int j : iArray)
            sum += j;
        System.out.println(sum);
    }
}

五、实验总结

1.StringTokenizer的构造器returnDelims如果没有初始值则为默认值false。第二个参数是分界字符。在第一次参数里找到第二个参数来断开。形成一个数组；注意：如果delim是null则编译器不会报出异常，但是尝试调用由此产生的StringTokenizer的其他方法，可能会导致NullPointerException。
2.hasMoreTokens()方法是一个布尔型的方法，判断下一个是否还存在，如果没有，则为false，maxPosition是字符串的长度。return(newPosition<maxPosition)语句的意思是，如果下一个字符的角标大于字符串的长度则返回false，其他情况则返回true。
3.Integer.parseInt(数组)可以把数组中的每一个字符都转换为int类型，并存入另一个数组中。
字符串.indexOf(“字符/字符串”)会在引用此方法的字符串中查找括号里面的字符/字符串。如果查到了则返回第一个角标，如果没有则返回-1.
4.字符串.spit(分界字符)以分界字符为分界线来使得字符串分开，并存入一个数组中，如果字符串中没有分界字符。则数组中存入原字符串。
实验九集合的使用

实验九集合的使用

一、实验目的及任务

掌握 List、ArrayList、LinkedList 作为泛型类的用法。
在后续的课程设计中，可以使用 List、ArrayList、LinkedList 来存储数据。

二、实验环境

Windows10。
IntelliJ IDEA Community Edition 2021.1

三、实验步骤

1定义一个 Student 类，具有 name、sex、age 属性，具有 getName、setName、getSex、setSex、getAge、setAge 方法和三个参数的构造方法
2编写一个类，名字为 ListDemo，在 main 方法中做以下工作：
定义一个可以保存 Student 类型对象的 List 类型对象 list1，然后向 list1 中放入 2 个学生：new Student(“张三”,“男”,20)、new Student(“李四”,“男”,22)
遍历 list1 中的学生对象，并将每个学生的姓名、性别、年龄输出到显示器
定义一个可以保存 String 类型对象的 List 类型对象 list2，然后向 list2 中放入 2 个字符串：
“aaa”、“bbb”
遍历 list2 中的字符串对象，并输出到显示器
定义一个可以保存 Student 类型对象的 LinkedList 类型对象 list3，然后向 list3 放入 4 个学生，放入的方法如下：
用 addFirst 方法，加入 new Student(“王五”,“男”,23)
用 add 方法，加入 new Student(“王六”,“男”,24)
用 addFirst 方法，加入 new Student(“王七”,“男”,25)
用 addLast 方法，加入 new Student(“王九”,“男”,26)
遍历 list3 中的学生对象，并将每个学生的姓名、性别、年龄输出到显示器

四、代码、测试用例和测试结果

代码 student：

package Demo02;

public class Student { private String name; private String sex; private int age;

public String getName() { return name;
}

@Override
public String toString() { return "name :"+getName()+
"sex :"+getSex()+
"age :"+getAge();
}

public Student(String name, String sex, int age) { this.name = name;
this.sex = sex; this.age = age;
}

public void setName(String name) { this.name = name;
}

public String getSex() { return sex;
}

public void setSex(String sex) {


this.sex = sex;
}

public int getAge() { return age;
}

public void setAge(int age) { this.age = age;
}
}


ListDemo package Demo02;

import java.util.ArrayList; 
import java.util.LinkedList; 
import java.util.List;

public class ListDemo {
public static void main(String[] args) {

List<Student> list1 = new ArrayList<>(); 
list1.add(new Student("张三", "男", 20));
list1.add(new Student("李四", "男", 22));

for (Student str : list1) System.out.println(str);

List<String> list2 = new ArrayList<>(); list2.add("aaa");
list2.add("bbb");

for (String str : list2) System.out.println(str);

LinkedList<Student> list3 = new LinkedList<>();

list3.addFirst(new Student("王五", "男", 23)); 
list3.add(new Student(" 王 六 ", " 男 ", 24)); 
list3.addFirst(new Student("王七", "男", 25));


list3.addLast(new Student("王九", "男", 26));

for (Student student : list3) System.out.println(student);

}
}

五、实验总结

1.Linkedlist 中 addLast 方法在 list 中的最后一位添加 Object， add
（index，element）在 index 的位置处添加元素 Object。AddFirst 方法在 list 中的最前面添加 Object。
2.addAll 方法在 list 中添加一个相同类型的 list.
3.Java 面向对象编程思想，例子：list.add（new Studeng(ID,name,age)）;减少使用局部变量，在 list.add 中直接 new 对象。
4.四种循环输出
Interator 接口有两种方法：hasnext()和 next()
hasnext：判断下一位是否存在，如果存在则返回 true，不存在则返回 false Next：取下一位。

实验十文件读写

一、实验目的及任务

掌握用字符流和字节流读写文件的方法。

二、实验环境

Windows10。
IntelliJ IDEA Community Edition 2021.1

三、实验步骤

1.用字节流读写二进制文件

要求：用 DataOutputStream+FileOutputStream 类将 1,2，…，100，这 100 个数字写入到文件 d:
\out1.bin 里，然后再用 DataInputStream+FileInputStream 类将 d:\out1.bin 的内读出来，并输出到屏幕上。

用DataOutputStream+FileOutputStream 写入二进制数据时,直接调用 DataOutputStream 的writeInt()方法将一个int 型数据写入到文件中。读入数据时用 DataInputStream+FileInputStream,调用DataInputStream 的readInt()方法读入一个int 型数据。

判断是否读入完毕有 2 种办法：a：用while 循环，当抛出 EOFException 时表示数据读入完毕。b：先调用File 类的length()方法得到输入流的字节总数，字节总数除以 4 得到需要读入的次数，然后用for 循环来读入。

2.用字符流读写字符文件

要求：用 FileWriter 类将 1,2，…，100，这 100 个数字写入到文件 d:\out2.txt 里，然后再用 Fil eReader 类将 d:\out2.txt 的内读出来，并输出到屏幕上。

注意：将一个数字以字符流的方式写入文件时，要将该数字先转化为字符，然后写入到文件中。从文件中读入字符数据时，可以一次读入一个字符，也可以一次读多个字符，放到字符数组中。

四、代码、测试用例和测试结果

代码 filetext：

package File;
import java.io.*; public class Filetext {
public static void main(String[] args) {
try (DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("D:\\out2.txt"))) {
for (int i = 0; i < 100; i++) dataOutputStream.writeInt(i + 1);
} catch (IOException ignored) { }

try (DataInputStream dataInputStream = new DataInputStream(new FileInputStream("D:\\out2.txt"))) {
for (int i = 0; i < new File("D:\\out.bin").length(); i++) System.out.println(dataInputStream.readInt());
} catch (IOException ignored) { }
}

代码：Filetext package File;


import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.File;

public class Filetext02 {
public static void main(String[] args) {
try (FileWriter fileWriter = new FileWriter("D:\\out2.txt")) { for (int i = 0; i < 100; i++)
fileWriter.write(i + 1 + "\n");
} catch (IOException ignored) { }

try(FileReader fileReader = new FileReader("D:\\out2.txt")) { char[] c = new char[(int) new File("D:\\out2.txt").length()]; fileReader.read(c);
System.out.println(c);
} catch (IOException ignored) { }
}
}

五、实验总结

1.try-with-catch 语句，会自动关闭文件，相当于 file.close
2.在使用 DataOutputStream 传入文件中时，是以二进制传入例子：传入 1~100 整数。
存储二进制文件的后缀名应该为 bin 而不是 txt。
3.此代码将路径文件的内容赋值给 Char 类型的 c 数组，然后运行 FileReader 的 read 方法将文件内全部字符都存入 c 数组中，最后在屏幕上输出 c 数组。从而可以在屏幕上查看文件内容。

实验十一用泛型方法实现集合内的对象排序

一、实验目的及任务

1掌握泛型方法的作用、泛型方法的编写格式和方法。
2掌握集合内元素排序的操作方法。
3掌握Comparable接口的用法。

二、实验环境

Windows10。

IntelliJ IDEA Community Edition 2021.1

三、实验步骤

1．定义一个Student类实现Comparable接口（实现Comparable接口的目的是为了让Student类的对象能够比较大小，即具有比较大小的标准。具体比较标准要通过实现接口中定义的public int compareTo(Student o)方法来定义。该方法的返回值>0,表示该方法所在的对象大于o对象；=0表示该方法所在的对象等于o对象；<0表示方法所在的对象小于o对象）。具体要求如下：
（1）Student类具有name、age属性，具有getName、setName、getAge、setAge方法和2个参数的构造方法Student(String name ,int age)。
（2）同时，Student类要实现接口Comparable接口中声明的public int compareTo(Student o)方法。这里我们要求根据Student对象的age属性比较大小，age大的对象也大，age小的对象也小。因而该方法中要根据Student对象的age属性进行比较，通过用return this.age-o.age;语句即可实现按照age进行比较大小的功能，并且是age大的对象也大。反之，用 return o.age -this.age;则表示age小的对象大。请同学们好好体会。

2．编写类ListUtil.
(1)在该类中编写static的泛型方法paiXu，paiXu方法的作用是把一个集合中的对象进行排序，当然集合中的对象能够排序，必须是实现了Comparable接口的类的对象，因而paiXu方法的声明如下：
public static < T extends Comparable > List paiXu(List list){
T temp ;//作为交换时用的临时中间变量
for(int i=0 ;i<list.size() -1;i++){
for(int j=i+1;j<list.size();j++){
if(list.get(i).compareTo(list.get(j))>0){//需要交换，注意交换的方法，跟数组不一样
temp=list.get(i);
list.set(i,list.get(j));
list.set(j,temp);
}
}
}
return list;
}
即对paiXu方法的参数list中的元素进行排序，排序完毕仍然返回该list。
其中，< T extends Comparable >表示这是一个泛型方法，而且方法用到的T是实现Comparable接口的。
List表示该方法的返回值类型
List list，是方法的参数，用来声明要被排序的集合list。
（2）编写main方法。在main方法中，先定义一个集合List list=new ArrayList() ;
然后向list中加入3个Student对象，分别为：
new Student(“张三”,22);
new Student(“李四”,20);
new Student(“王五”,21);
然后调用paiXu方法将该list集合排序。
最后遍历输出集合中所有对象的姓名。

四、代码、测试用例和测试结果

代码 student：

package Demo01;

public class Student implements Comparable<Student>{
    @Override
    public int compareTo(Student o) {
        return o.age -this.age;
    }
    private String name;
    private int age;

    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 Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
代码：ListUtil
package Demo01;

import java.util.ArrayList;
import java.util.List;

public class ListUtil {
    public static <T extends Comparable<T>> List<T> paiXu(List<T> list) {
        T temp;
        for (int i = 0; i < list.size() - 1; i++)
            for (int j = i + 1; j < list.size(); j++)
                if (list.get(i).compareTo(list.get(j)) > 0) {
                    temp = list.get(i);
                    list.set(i, list.get(j));
                    list.set(j, temp);
                }
        return list;
    }

    private static void print(Student student) {
        System.out.println("name: " + student.getName() + " age: " + student.getAge());
    }

    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        //在list中添加对象张三，李四,王五

        list.add(new Student("张三", 22));
        list.add(new Student("李四", 20));
        list.add(new Student("王五", 21));

        paiXu(list);//根据年龄大小排序

        for (Student student : list)
            print(student);
    }
}

五、实验总结

1.List的size方法，返回list的长度。

2.泛型类派生子类，子类也是泛型类，子类的泛型标识，需要和父类一致。

3.泛型类的定义：泛型标识——类型形参。T创建对象的时候指定具体的数据类型。

4.泛型类在创建对象的时候，没有指定类型，将按照Object类型操作。

5.泛型类不支持int等基本数据结构

实验十二带事件的图形界面

一、实验目的及任务

掌握编写图形界面的一般方法，包括文本输入框、按钮、标签、布局管理器、授权事件模型的使用。

二、实验环境

Windows10。
设备名称 gwrxhzxl
处理器 Intel® Core™ i7-10750H CPU @ 2.60GHz 2.59 GHz
机带 RAM 16.0 GB (15.9 GB 可用)
系统类型 64 位操作系统, 基于 x64 的处理器
JDK16.0
IntelliJ IDEA Community Edition 2021.1

三、实验步骤

编写一个计算两个数相加的加法器，要求：
1、提供输入两个加数的文本输入框。
2、一个表示“+”的标签
3、一个“=”按钮
4、一个保存两数相加的和的文本框
当单击等号按钮时，能够计算出两数的和并显示到第三个文本框，同时能够判断两个加数是否是合法，即都是数字。
界面参考如下：

1、先建立类MyAdd继承JFrame
2、定义五个属性，分别是被加数txtNumber1、加号lblAdd、加数输入框txtNumber2、等号按钮btnEqual、表示和的输入框txtSum
3、构造方法中把五个属性对象加入到窗体中（用FlowLayout布局管理即可）
4、给txtNumber1、txtNumber2添加FocusEvent监听器，给btnEqual添加ActionEvent监听器。实现事件监听器最好采用匿名类的方法

提示：
1、使用FlowLayout布局管理器
2、判断输入的是不是数字可以单独编写一个方法boolean isNumber（String s），在isNumber方法中应该循环取出s中的每一个字符（用字符串的s.charAt(字符的索引位置)方法可以取出某个位置的字符），判断是否大于57或小于48（因为0的ascii码是48，9的ascii码是57），如果符合条件则可以说明不是数字，要返回false，否则就是合法数字，返回true。（判断一个字符是否是数字也可以用Character.isDigit(‘要判断的字符’)，返回true表示是数字，返回false表示不是数字）
3、在输入框的FocusEvent事件的focusLost方法中，首先判断是否为空，如果为空，则返回。如果不为空，再调用isNumber方法判断是否是数字，如果不是数字则不让光标离开，即让光标还停留在输入框内，方法是调用输入框的requestFocus()方法，例如txtNumber1. requestFocus()。
4、给等号按钮添加ActionListener事件，并实现actionPerformed方法，在该方法中，首先判断两个输入框的内容是否为空，如果为空则提示，然后返回。如果不为空，则取出两个输入的值并转换成int或double型数据，相加后放入和的文本输入框中。
提示：得到输入框的值用：输入框名.getText（），给输入框赋值用：输入框名.setText（”新值”）

四、代码、测试用例和测试结果

package File;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;

public class MyAdd extends JFrame {
    public static void main(String[] args) {
        //定义组件
        Frame frame = new JFrame("加法计算器");
	frame.setLayout(new FlowLayout());

        Panel panel = new Panel();

        TextField txtnumber1 = new TextField(8);
        txtAction(txtnumber1);

        Label lblAdd = new Label("+");

        TextField txtnumber2 = new TextField(8);
        txtAction(txtnumber2);

        JButton jButton = new JButton("=");

        TextField txtSum = new TextField(8);
        //按钮监听器
        jbuAction(txtnumber1, txtnumber2, jButton, txtSum);
        //组装
        panel.add(txtnumber1);
        panel.add(lblAdd);
        panel.add(txtnumber2);
        panel.add(jButton);
        panel.add(txtSum);

        frame.add(panel, BorderLayout.NORTH);
        //显示

        frame.pack();

        frame.setVisible(true);
    }

    private static void jbuAction(TextField txtnumber1, TextField txtnumber2, JButton jButton, TextField txtSum) {
        jButton.addActionListener(new AbstractAction() {
            @Override
            public void actionPerformed(ActionEvent e) {
                if (txtnumber1.getText() == null ||
                        txtnumber2.getText() == null)
                    return;
                txtSum.setText(String.valueOf(
                        doubleget(txtnumber1.getText()) +
                                doubleget(txtnumber2.getText())));
            }
        });
    }

    private static void txtAction(TextField txtnumber2) {
        txtnumber2.addFocusListener(new FocusListener() {
            @Override
            public void focusGained(FocusEvent e) {
            }

            @Override
            public void focusLost(FocusEvent e) {
                if (txtnumber2.getText() == null)
                    return;
                try {
                    if (isNumber(txtnumber2.getText()))
                        txtnumber2.requestFocus();
                } catch (NumberFormatException e1) {
                    txtnumber2.requestFocus();
                }
            }
        });
    }

    //转换成double类型
    private static double doubleget(String st) {
        return Double.parseDouble(st);
    }
    //判断是否为数字
    public static boolean isNumber(String string) {
        return Character.isDigit(Integer.parseInt(string));
    }
}

五、实验总结

1.监听器：不同的事件需要使用不同的监听器监听，不同的监听器需要实现不同的监听器接口，当指定事件发生后，事件监听器就会调用所包含的事件处理器(实例方法)来处理事件。例如：通过TextListener监听TextFiled内容变化；

构造方法方法功能
FlowLayout() 使用默认的对齐方式及默认的垂直间距、水平间距创建 FlowLayout 布局管理器。
FlowLayout(int align) 使用指定的对齐方式及默认的垂直间距、水平间距创建 FlowLayout 布局管理器。
FlowLayout(int align,int hgap,int vgap) 使用指定的对齐方式及指定的垂直问距、水平间距创建FlowLayout 布局管理器。
FlowLayout 中组件的排列方向(从左向右、从右向左、从中间向两边等) ，该参数应该使用FlowLayout类的静态常量 : FlowLayout. LEFT 、 FlowLayout. CENTER 、 FlowLayout. RIGHT ，默认是左对齐。
3.组件：
组件名功能
Button Button按钮
Choice 下拉选择框
Label 标签类，用于放置提示性文本
Panel 不能单独存在基本容器类，必须放到其他容器中
TextField 单行文本框
Frame 窗口，在 GUI 程序里通过该类创建窗口
TextArea 多行文本域

Xlorb

关注

8
点赞
踩
48

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java实验复习（建议收藏）

java实验实验一数组，循环语句和输入输出实验实验目的及任务1、学会使用main方法2、掌握数组、输入输出语句、循环语句的用法。实验内容1、定义一个类Calculate ，其中有一个main方法。2、在main方法中，首先调用Scanner类，从键盘输入一个整数放到变量count中，count表示将要从键盘读入的整数个数，然后调用循环语句从键盘读入count个整数，并保存到数组value中。（1）将这count个整数求和，然后求出平均值。最后输出和及平均值。（2）找到数组中所有的数组元素
复制链接

扫一扫