您的位置:

java实验题目汇总下载(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 那么就需要每个对象 赋值。现在基本满足你的要求了。