本文目录一览：
- 1、一个JAVA课程实验的题目，急要，要有注释
- 2、求代码，java实验，题目如图
- 3、JAVA 实验题
- 4、求解一道Java实验题，给出一段代码，要求把该代码补充完整使其可以运行，具体要求如下
一个JAVA课程实验的题目，急要，要有注释
//第二题
import java.util.Scanner;
public class Test {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入数据以空格隔开：");
String[] str=(sc.nextLine()).split("\s+");
double[] ds=new double[2];
for(int i=0;istr.length;i++){
double d=Double.parseDouble(str[i]);
try{
if(d100 || d0) throw new MyException();
}catch(MyException e){
e.printStackTrace();
}
ds[i]=d;
}
for(double d:ds)
System.out.println(d);
}
}
class MyException extends Exception{
public MyException(){
System.out.println("数据大于100或小于0");
}
}
求代码，java实验，题目如图
import java.util.Scanner;
import java.util.Stack;
public class DFS
{
// 存储节点信息
private char[] vertices;
// 存储边信息（邻接矩阵）
private int[][] arcs;
// 图的节点数
private int vexnum;
// 记录节点是否已被遍历
private boolean[] visited;
// 初始化
public DFS(int n)
{
vexnum = n;
vertices = new char[n];
arcs = new int[n][n];
visited = new boolean[n];
for(int i = 0; i vexnum; i++)
{
for(int j = 0; j vexnum; j++)
{
arcs[i][j] = 0;
}
}
}
// 添加边(无向图)
public void addEdge(int i, int j)
{
// 边的头尾不能为同一节点
if(i == j)
return;
arcs[i - 1][j - 1] = 1;
arcs[j - 1][i - 1] = 1;
}
// 设置节点集
public void setVertices(char[] vertices)
{
this.vertices = vertices;
}
// 设置节点访问标记
public void setVisited(boolean[] visited)
{
this.visited = visited;
}
// 打印遍历节点
public void visit(int i)
{
System.out.print(vertices[i] + " ");
}
// 从第i个节点开始深度优先遍历
private void traverse(int i)
{
// 标记第i个节点已遍历
visited[i] = true;
// 打印当前遍历的节点
visit(i);
// 遍历邻接矩阵中第i个节点的直接联通关系
for(int j = 0; j vexnum; j++)
{
// 目标节点与当前节点直接联通，并且该节点还没有被访问，递归
if(arcs[i][j] == 1 visited[j] == false)
{
traverse(j);
}
}
}
// 图的深度优先遍历（递归）
public void DFSTraverse(int start)
{
// 初始化节点遍历标记
for(int i = 0; i vexnum; i++)
{
visited[i] = false;
}
// 从没有被遍历的节点开始深度遍历
for(int i = start - 1; i vexnum; i++)
{
if(visited[i] == false)
{
// 若是连通图，只会执行一次
traverse(i);
}
}
}
// 图的深度优先遍历（非递归）
public void DFSTraverse2(int start)
{
// 初始化节点遍历标记
for(int i = 0; i vexnum; i++)
{
visited[i] = false;
}
StackInteger s = new StackInteger();
for(int i = start - 1; i vexnum; i++)
{
if(!visited[i])
{
// 连通子图起始节点
s.add(i);
do
{
// 出栈
int curr = s.pop();
// 如果该节点还没有被遍历，则遍历该节点并将子节点入栈
if(visited[curr] == false)
{
// 遍历并打印
visit(curr);
visited[curr] = true;
// 没遍历的子节点入栈
for(int j = vexnum - 1; j = 0; j--)
{
if(arcs[curr][j] == 1 visited[j] == false)
{
s.add(j);
}
}
}
} while(!s.isEmpty());
}
}
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int N, M, S;
while(true)
{
System.out.println("输入N M S，分别表示图G的结点数，边数，搜索的起点：");
String line = sc.nextLine();
if(!line.matches("^\s*([1-9]\d?|100)(\s+([1-9]\d?|100)){2}\s*$"))
{
System.out.print("输入错误，");
continue;
}
String[] arr = line.trim().split("\s+");
N = Integer.parseInt(arr[0]);
M = Integer.parseInt(arr[1]);
S = Integer.parseInt(arr[2]);
break;
}
DFS g = new DFS(N);
char[] vertices = new char[N];
for(int i = 0; i N; i++)
{
vertices[i] = (i + 1 + "").charAt(0);
}
g.setVertices(vertices);
for(int m = 0; m M; m++)
{
System.out.println("输入图G的第" + (m + 1) + "条边，格式为“i j”，其中i，j为结点编号（范围是1~N）");
String line = sc.nextLine();
if(!line.matches("^\s*([1-9]\d?|100)\s+([1-9]\d?|100)\s*$"))
{
System.out.print("输入错误，");
m--;
continue;
}
String[] arr = line.trim().split("\s+");
int i = Integer.parseInt(arr[0]);
int j = Integer.parseInt(arr[1]);
g.addEdge(i, j);
}
sc.close();
System.out.print("深度优先遍历（递归）：");
g.DFSTraverse(S);
System.out.println();
System.out.print("深度优先遍历（非递归）：");
g.DFSTraverse2(S);
}
}
JAVA 实验题
//LeadMain.java
import java.util.*;
public class LeadMain {
public static void main(String args[]){
MyDate mydate=new MyDate();
int y;
Scanner yreader=new Scanner(System.in);
System.out.println("从键盘输入年份：");
y=yreader.nextInt();
mydate.setYear(y);
int m;
Scanner mreader=new Scanner(System.in);
System.out.println("从键盘输入月份：");
m=mreader.nextInt();
mydate.setMonte(m);
mydate.LeapToJudge();
mydate.DaysOfTheMonth();
mydate.Tomorrow();
}
}
//MyDate.java
import java.util.*;
public class MyDate {
private int year;
private int monte;
private int day;
public boolean LeapToJudge(){
if((year%4==0year%100!=0)||(year%400==0)){
return true;
}
else{
return false;
}
}
public void DaysOfTheMonth(){
if(LeapToJudge()){
System.out.println(year+"年是闰年！");
if(monte==2){
System.out.println(year+"年"+monte+"月的天数为：29天");
}
else{
if(monte==1||monte==3||monte==5||monte==7||monte==8||monte==10||monte==12){
System.out.println(year+"年"+monte+"月的天数为：31天");
}
else{
System.out.println(year+"年"+monte+"月的天数为：30天");
}
}
}
else{
System.out.println(year+"年不是闰年！");
if(monte==2){
System.out.println(year+"年"+monte+"月的天数为：28天");
}
else{
if(monte==1||monte==3||monte==5||monte==7||monte==8||monte==10||monte==12){
System.out.println(year+"年"+monte+"月的天数为：31天");
}
else{
System.out.println(year+"年"+monte+"月的天数为：30天");
}
}
}
}
public void Tomorrow(){
Date today=new Date();
Date tomorrow=new Date(today.getTime()+24*3600*1000);
System.out.println("明天的此刻时间是："+tomorrow);
}
public void setYear(int years){
year=years;
}
public void setMonte(int montes){
monte=montes;
}
}
求解一道Java实验题，给出一段代码，要求把该代码补充完整使其可以运行，具体要求如下
package xinguan;
abstract class Operation{ //抽象类
public static double numberA= 0;
public static double numberB = 0;
abstract double getResult(); //抽象方法
}
class OperationADD extends Operation{
@Override
double getResult() {
return numberA+numberB;
}
}
class OperationSUB extends Operation{
@Override
double getResult() {
return numberA-numberB;
}
}
class OperationMUL extends Operation{
@Override
double getResult() {
return numberA*numberB;
}
}
class OperationDIV extends Operation{
@Override
double getResult() {
return numberA/numberB;
}
}
class OperationFactory{
public static Operation createOperate(char operate){
Operation oper = null;
switch (operate){
case'+':
oper= new OperationADD();
break;
case'-':
oper= new OperationSUB();
break;
case'*':
oper= new OperationMUL();
break;
case'/':
oper= new OperationDIV();
break;
}
return oper;
}
}
public class CalculateDemo {
/**
* @param args
*/
public static void main(String[] args) {
Operation operADD = OperationFactory.createOperate('+');
Operation operSUB = OperationFactory.createOperate('-');
Operation operMUL = OperationFactory.createOperate('*');
Operation operDIV = OperationFactory.createOperate('/');
operADD.numberA = 15.0;
operADD.numberB = 3;
System.out.println(operADD.getResult());
System.out.println(operSUB.getResult());
System.out.println(operMUL.getResult());
System.out.println(operDIV.getResult());
}
}
因为抽象类是静态方法 所以 给operADD 那个对象赋值一次就能获得所有结果。要是去掉static 那么就需要每个对象 赋值。现在基本满足你的要求了。