Java6&Java7&Java8

最新推荐文章于 2024-10-16 15:32:01 发布
最新推荐文章于 2024-10-16 15:32:01 发布
阅读量1.5k 收藏 12
点赞数 1
分类专栏： PTAJava题目集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H0llyLiang/article/details/106887711
版权

6-1 创建一个直角三角形类实现IShape接口 (10分)

创建一个直角三角形类（regular triangle）RTriangle类，实现下列接口IShape。两条直角边长作为RTriangle类的私有成员，类中包含参数为直角边的构造方法。

interface IShape {// 接口

public abstract double getArea(); // 抽象方法 求面积

public abstract double getPerimeter(); // 抽象方法 求周长

}

直角三角形类的定义：

直角三角形类的构造函数原型如下：
RTriangle(double a, double b);

其中 a 和 b 都是直角三角形的两条直角边。
裁判测试程序样例：

import java.util.Scanner;
import java.text.DecimalFormat;

interface IShape {
    public abstract double getArea();

    public abstract double getPerimeter();
}

/*你写的代码将嵌入到这里*/


public class Main {
    public static void main(String[] args) {
        DecimalFormat d = new DecimalFormat("#.####");
        Scanner input = new Scanner(System.in);
        double a = input.nextDouble();
        double b = input.nextDouble();
        IShape r = new RTriangle(a, b);
        System.out.println(d.format(r.getArea()));
        System.out.println(d.format(r.getPerimeter()));
        input.close();
    }
}

输入样例：

3.1 4.2

输出样例：

6.51
12.5202

6-1 创建一个直角三角形类实现IShape接口 (10分)

创建一个直角三角形类（regular triangle）RTriangle类，实现下列接口IShape。两条直角边长作为RTriangle类的私有成员，类中包含参数为直角边的构造方法。

interface IShape {// 接口

public abstract double getArea(); // 抽象方法 求面积

public abstract double getPerimeter(); // 抽象方法 求周长

}
直角三角形类的定义：

直角三角形类的构造函数原型如下：
RTriangle(double a, double b);

其中 a 和 b 都是直角三角形的两条直角边。
裁判测试程序样例：


import java.util.Scanner;
import java.text.DecimalFormat;

interface IShape {
    public abstract double getArea();

    public abstract double getPerimeter();
}

/*你写的代码将嵌入到这里*/


public class Main {
    public static void main(String[] args) {
        DecimalFormat d = new DecimalFormat("#.####");
        Scanner input = new Scanner(System.in);
        double a = input.nextDouble();
        double b = input.nextDouble();
        IShape r = new RTriangle(a, b);
        System.out.println(d.format(r.getArea()));
        System.out.println(d.format(r.getPerimeter()));
        input.close();
    }
}

输入样例：

3.1 4.2

输出样例：

6.51
12.5202

6-2 从抽象类shape类扩展出一个圆形类Circle (10分)

请从下列的抽象类shape类扩展出一个圆形类Circle,这个类圆形的半径radius作为私有成员，类中应包含初始化半径的构造方法。

public abstract class shape {// 抽象类
public abstract double getArea();// 求面积
public abstract double getPerimeter(); // 求周长
}

主类从键盘输入圆形的半径值，创建一个圆形对象，然后输出圆形的面积和周长。保留4位小数。
圆形类名Circle

裁判测试程序样例：

import java.util.Scanner;import java.text.DecimalFormat;
abstract class shape {// 抽象类
     /* 抽象方法 求面积 */
    public abstract double getArea( );

    /* 抽象方法 求周长 */
    public abstract double getPerimeter( );
}
/* 你提交的代码将被嵌入到这里 */
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        DecimalFormat d = new DecimalFormat("#.####");// 保留4位小数
         double r = input.nextDouble( ); 
        shape c = new  Circle(r);

        System.out.println(d.format(c.getArea()));
        System.out.println(d.format(c.getPerimeter()));
        input.close();
    } 
}

输入样例：
3.1415926
输出样例：
31.0063
19.7392

class Circle extends shape{
	private  double r;

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

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

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

6-3 jmu-Java-03面向对象基础-覆盖与toString (3分)

有Person类，Company类，Employee类。
其中Employee类继承自Person类，属性为：
private Company company;private double salary;
现在要求编写Employee类的toString方法，格式为:父类的toString-company的toString-salary
函数接口定义：
public String toString()
输出样例：
zhang-23-true-IBM-9000.123

public String toString() {
	return super.toString()+"-"+company.toString()+"-"+salary;
}

6-4 jmu-Java-04面向对象进阶-01-接口-匿名内部类ActionListener (5分)
已有MyStarter类(你无需编写，直接使用)，其具有：
构造函数：public MyStarter(ActionListener ac)
方法：start()启动任务
main方法执行流程：

  1. 输入整数n和字符串x。

  2. 创建MyStarter对象。该对象的任务为输出n个x字符串，并在循环结束后，使用如下代码
    System.out.println(this.getClass().getName());
    System.out.println(Arrays.toString(this.getClass().getInterfaces()));

  3. 打印一些标识信息。 注意：MyStarter类的构造函数public MyStarter(ActionListener ac)要接收ActionListener类型的对象，我们需要建立这个对象并在该对象相应的方法中编写相关功能代码。
    最后：调用MyStarter对象的start方法启动任务。
    裁判测试程序：
    public static void main(String[] args) {
    MyStarter starter;
    //这边写上你的代码
    starter.start();
    sc.close();
    }
    输入样例：
    3
    a
    输出样例：
    a
    a
    a
    //此处有两行标识信息

Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    
    String str=sc.next();
    ActionListener ac= new ActionListener() {
    	 {
    		for(int i=0;i<n;i++) {
				System.out.println(str);
			}
			 System.out.println(this.getClass().getName());
			 System.out.println(Arrays.toString(this.getClass().getInterfaces()));
    	}

		@Override
		public void actionPerformed(ActionEvent e) {
			
		}
    	
    };
    starter=new MyStarter(ac);

6-5 jmu-Java-03面向对象基础-clone方法、标识接口、深拷贝 (10分)

Object的clone方法可以帮助我们克隆对象。现在需编写一个类Car包含:
1.属性:
private String name;private CarDriver driver;private int[] scores;
2.无参构造函数
public Car() {
}
3.方法:
@Override
public String toString() {
return “Car [name=” + name + “, driver=” + driver + “, scores=” + Arrays.toString(scores) + “]”;
}
setter/getter方法与clone方法。注意：clone方法需实现对象的深度克隆。
CarDriver为已经定义好的类,部分代码如下：
class CarDriver {
private String name;
public CarDriver() {}
//setter/getter
//toString
}
/ 请在这里填写答案，即Car类的完整代码 /

class Car implements Cloneable{
	private String name;
	private CarDriver driver;
	private int[] scores;

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public CarDriver getDriver() {
		return driver;
	}
	public void setDriver(CarDriver driver) {
		this.driver = driver;
	}
	public int[] getScores() {
		return scores;
	}
	public void setScores(int[] scores) {
		this.scores = scores;
	}
	public Car() {
	}
	@Override
	public String toString() {
	    return "Car [name=" + name + ", driver=" + driver + ", scores=" + Arrays.toString(scores) + "]";
	}
	@Override
	public Car clone() throws CloneNotSupportedException {
		Car car=new Car();
		CarDriver cd=new CarDriver();
		if(this.driver==null) {
			cd=null;
		}else {
			cd.setName(driver.getName());
		}
		car.setDriver(cd);
		String nm;
		if(this.name==null) {
			nm=null;
		}else {
			nm=name;
		}
		car.setName(nm);
		if(scores==null) {
			car.setScores(null);
		}else {
			int []t=Arrays.copyOf(scores, scores.length);
			car.setScores(t);
		}
		return car;
	}
}

6-6 jmu-Java-05集合-List中指定元素的删除 (15分)

编写以下两个函数
/以空格(单个或多个)为分隔符，将line中的元素抽取出来，放入一个List/public static List convertStringToList(String line) /在list中移除掉与str内容相同的元素/public static void remove(List list, String str)
裁判测试程序：
public class Main {

/*covnertStringToList函数代码*/   
	
/*remove函数代码*/
	
 public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    while(sc.hasNextLine()){
        List<String> list = convertStringToList(sc.nextLine());
        System.out.println(list);
        String word = sc.nextLine();
        remove(list,word);
        System.out.println(list);
    }
    sc.close();
}

}

样例说明：底下展示了4组测试数据。
输入样例
1 2 1 2 1 1 1 2111 1 11 1 11112 2 2 11 2 3 4 1 3 11
输出样例
[1, 2, 1, 2, 1, 1, 1, 2]
[2, 2, 2]
[11, 1, 11, 1, 11]
[1, 1]
[2, 2, 2]
[2, 2, 2]
[1, 2, 3, 4, 1, 3, 1]
[2, 3, 4, 3]

/*以空格(单个或多个)为分隔符，将line中的元素抽取出来，放入一个List*/
     public static List<String> convertStringToList(String line){
    	 String[] s= line.split("\\s+");  //以空格(单个或多个)为分隔符这样写才行
    	 List<String> list=new ArrayList<String>();
    	 for(int i=0;i<s.length;i++) {
    		 list.add(s[i]);
    	 }
 		return list;
     }
     /*在list中移除掉与str内容相同的元素*/
     public static void remove(List<String> list, String str) {
    	while(true) {
    		int x=list.indexOf(str);
    		if(x>=0) {
    			list.remove(x);
    		}
    		else {
    			break;
    		}
    	}
     }

7-3 jmu-Java-02基本语法-08-ArrayList入门 (10分)

本习题主要用于练习如何使用ArrayList来替换数组。
新建1个ArrayList strList用来存放字符串，然后进行如下操作。
提示:查询Jdk文档中的ArrayList。
注意:请使用System.out.println(strList)输出列表元素。
输入格式
1.
输入n个字符串，放入strList。直到输入为!!end!!时，结束输入。
2.
3.
在strList头部新增一个begin，尾部新增一个end。
4.
5.
输出列表元素
6.
7.
输入:字符串str
8.
9.
判断strList中有无包含字符串str，如包含输出true，否则输出false。并且输出下标，没包含返回-1。
10.
11.
在strList中从后往前找。返回其下标，找不到返回-1。
12.
13.
移除掉第1个(下标为0)元素,并输出。然后输出列表元素。
14.
15.
输入:字符串str
16.
17.
将第2个（下标为1）元素设置为字符串str.
18.
19.
输出列表元素
20.
21.
输入:字符串str
22.
23.
遍历strList，将字符串中包含str的元素放入另外一个ArrayList strList1，然后输出strList1。
24.
25.
在strList中使用remove方法，移除第一个和str相等的元素。
26.
27.
输出strList列表元素。
28.
29.
使用clear方法，清空strList。然后输出strList的内容，size()与isEmpty()，3者之间用,连接。
30.
输入样例:
a1 b1 3b a2 b2 12b c d !!end!!
b1
second
b
输出样例:
[begin, a1, b1, 3b, a2, b2, 12b, c, d, end]
true
2
2
begin
[a1, b1, 3b, a2, b2, 12b, c, d, end]
[a1, second, 3b, a2, b2, 12b, c, d, end]
[3b, b2, 12b]
[a1, second, 3b, a2, b2, 12b, c, d, end]
[],0,true

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main{
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int i;
		List<String>strList=new ArrayList<String>();
		while(true) {
			String str=sc.next();
			if(str.equals("!!end!!")) {
				break;
			}
			strList.add(str);
		}
		strList.add(0, "begin");
		strList.add(strList.size(), "end");
		System.out.println(strList.toString());
		
		//判断有无指定的字符串
		String str=sc.next();
		System.out.println(strList.contains(str));
		System.out.println(strList.indexOf(str));
			
		//从后往前返回下标
		System.out.println(strList.lastIndexOf(str));	
		
		//移除掉第1个(下标为0)元素,并输出。然后输出列表元素
		System.out.println(strList.get(0));
		strList.remove(0);
		System.out.println(strList.toString());
		//输入字符串str 将第2个（下标为1）元素设置为字符串str.
		str=sc.next();
		strList.set(1, str);
		System.out.println(strList.toString());
		
		
		
//		遍历strList，将字符串中包含str的元素放入另外一个ArrayList strList1，然后输出strList1。
		List<String>strList1=new ArrayList<String>();
		str=sc.next();
		for(i=0;i<strList.size();i++) {
			if(strList.get(i).indexOf(str)>=0) {
				strList1.add(strList.get(i));
			}
			
		}
		System.out.println(strList1.toString());
		
//		在strList中使用remove方法，移除第一个和str相等的元素。
		strList.remove(str);
		System.out.println(strList.toString());
		
		
//		使用clear方法，清空strList。然后输出strList的内容，size()与isEmpty()，3者之间用,连接。
		strList.clear();
		System.out.println(strList.toString()+","+strList.size()+","+strList.isEmpty());
	}
	
		
}

7-4 jmu-Java&Python-统计文字中的单词数量并按出现次数排序 (25分)

现在需要统计若干段文字(英文)中的单词数量，并且还需统计每个单词出现的次数。
注1：单词之间以空格(1个或多个空格)为间隔。
注2：忽略空行或者空格行。
基本版:
统计时，区分字母大小写，且不删除指定标点符号。
进阶版:

  1. 统计前，需要从文字中删除指定标点符号!.,😗?。 注意：所谓的删除，就是用1个空格替换掉相应字符。
  2. 统计单词时需要忽略单词的大小写。
    输入说明
    若干行英文，最后以!!!为结束。
    输出说明
    单词数量
    出现次数排名前10的单词（次数按照降序排序，如果次数相同，则按照键值的字母升序排序）及出现次数。
    输入样例1
    failure is probably the fortification in your pole

it is like a peek your wallet as the thief when you
are thinking how to spend several hard-won lepta

when you are wondering whether new money it has laid
background because of you then at the heart of the

most lax alert and most low awareness and left it

godsend failed
!!!

输出样例1
46
the=4
it=3
you=3
and=2
are=2
is=2
most=2
of=2
when=2
your=2
输入样例2
Failure is probably The fortification in your pole!

It is like a peek your wallet as the thief when You
are thinking how to. spend several hard-won lepta.

when yoU are? wondering whether new money it has laid
background Because of: yOu?, then at the heart of the
Tom say: Who is the best? No one dare to say yes.
most lax alert and! most low awareness and* left it

godsend failed
!!!
输出样例2
54
the=5
is=3
it=3
you=3
and=2
are=2
most=2
of=2
say=2
to=2

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Main{
	public static String formate(String s)
	{
		String str="";
		StringBuilder sb = new StringBuilder();
		for(int i=0;i<s.length();i++)
		{
			if(s.charAt(i)=='!'||s.charAt(i)==','||s.charAt(i)=='.'||s.charAt(i)==':'||s.charAt(i)=='*'||s.charAt(i)=='?')
				continue;
			else
				sb.append(s.charAt(i));
		}
		str = sb.toString();
		str = str.toLowerCase();
		return str;
	}
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		Map<String, Integer> mp = new HashMap<>();
		while(true)
		{
			String s = in.nextLine();
			if(s.equals("!!!!!"))
				break;
			if(s!=null&&s.equals(""))
				continue;
			String ss[] = s.split(" ");
			for(int i=0;i<ss.length;i++)
			{
				String str = formate(ss[i]);
				if(str==null||str.length()==0)
					continue;
				if(!mp.containsKey(str))
				{
					mp.put(str, 1);
				}
				else
				{
					int num=mp.get(str);
					num++;
					mp.put(str, num);
				}
			}
		}
		List<Map.Entry<String, Integer>> list = new ArrayList<>(mp.entrySet());
		Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {

			@Override
			public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
				// TODO Auto-generated method stub
				if(o1.getValue()-o2.getValue()!=0)
					return o2.getValue().compareTo(o1.getValue());
				else
					return o1.getKey().compareTo(o2.getKey());
			}
		});
		System.out.println(mp.size());
		int cnt=0;
		for(Map.Entry<String, Integer> x:list)
		{
			System.out.println(x.getKey()+"="+x.getValue());
			cnt++;
			if(cnt==10)
				break;
		}
	}
}

7-1 jmu-Java-02基本语法-08-ArrayList入门 (10分)
本习题主要用于练习如何使用ArrayList来替换数组。
新建1个ArrayList strList用来存放字符串，然后进行如下操作。
提示:查询Jdk文档中的ArrayList。
注意:请使用System.out.println(strList)输出列表元素。
输入格式
1.
输入n个字符串，放入strList。直到输入为!!end!!时，结束输入。
2.
3.
在strList头部新增一个begin，尾部新增一个end。
4.
5.
输出列表元素
6.
7.
输入:字符串str
8.
9.
判断strList中有无包含字符串str，如包含输出true，否则输出false。并且输出下标，没包含返回-1。
10.
11.
在strList中从后往前找。返回其下标，找不到返回-1。
12.
13.
移除掉第1个(下标为0)元素,并输出。然后输出列表元素。
14.
15.
输入:字符串str
16.
17.
将第2个（下标为1）元素设置为字符串str.
18.
19.
输出列表元素
20.
21.
输入:字符串str
22.
23.
遍历strList，将字符串中包含str的元素放入另外一个ArrayList strList1，然后输出strList1。
24.
25.
在strList中使用remove方法，移除第一个和str相等的元素。
26.
27.
输出strList列表元素。
28.
29.
使用clear方法，清空strList。然后输出strList的内容，size()与isEmpty()，3者之间用,连接。
30.
输入样例:
a1 b1 3b a2 b2 12b c d !!end!!
b1
second
b
输出样例:
[begin, a1, b1, 3b, a2, b2, 12b, c, d, end]
true
2
2
begin
[a1, b1, 3b, a2, b2, 12b, c, d, end]
[a1, second, 3b, a2, b2, 12b, c, d, end]
[3b, b2, 12b]
[a1, second, 3b, a2, b2, 12b, c, d, end]
[],0,true

import java.util.ArrayList;
import java.util.Scanner;

public class Main { 
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);
		ArrayList<String> strList = new ArrayList<>();
		while(true)
		{
			String s = in.next();
			if(s.equals("!!end!!"))
				break;
			strList.add(s);
		}
		strList.add(0, "begin");
		strList.add("end");
		System.out.println(strList);
		String str = in.next();
		System.out.println(strList.contains(str));
		System.out.println(strList.indexOf(str));
		System.out.println(strList.lastIndexOf(str));
		System.out.println(strList.get(0));
		strList.remove(0);
		System.out.println(strList);
		str = in.next();
		strList.set(1, str);
		System.out.println(strList);
		str = in.next();
		ArrayList<String> strList1 = new ArrayList<>();
		for(int i=0;i<strList.size();i++)
		{
			if(strList.get(i).contains(str))
				strList1.add(strList.get(i));
		}
		System.out.println(strList1);
		strList.remove(str);
		System.out.println(strList);
		strList.clear();
		System.out.println(strList+","+strList.size()+","+strList.isEmpty());
	}
}

7-2 jmu-Java-05集合-01-ArrayListIntegerStack (15分)

定义IntegerStack接口，该接口描述了一个存放Integer的栈的常见方法：
public Integer push(Integer item); //如item为null，则不入栈直接返回null。否则直接入栈，然后返回item。public Integer pop(); //出栈，如栈为空，则返回null。public Integer peek(); //获得栈顶元素，如栈顶为空，则返回null。注意：不要出栈public boolean empty(); //如过栈为空返回truepublic int size(); //返回栈中元素数量
定义IntegerStack的实现类ArrayListIntegerStack，内部使用ArrayList存储。该类中包含：
构造函数：
在无参构造函数中新建ArrayList或者LinkedList，作为栈的内部存储。
思考：查询JDK文档，尝试说明本题到底使用哪个List实现类最好。
方法:
public String toString() //用于输出List中的内容,可直接调用List的toString()方法。可用System.out.println(list)进行输出。
提示：

  1. 不建议使用top指针。最好直接复用List实现类中已有的方法。
  2. pop时应将相应的元素从列表中移除。
    main方法说明
  3. 建立ArrayIntegerStack对象
  4. 输入m个值，均入栈。每次入栈均打印入栈返回结果。
  5. 输出： 栈顶元素，输出是否为空，然后输出size.
  6. 输出栈中所有元素（调用其toString()方法）
  7. 输入x，然后出栈x次，每次均打印出栈的对象。
  8. 输出:栈顶元素，输出是否为空，输出size。注意：这里的输出栈顶元素，仅输出、不出栈。
  9. 输出栈中所有元素（调用其toString()方法）。注意：返回null，也要输出。
    思考：
    如果使用LinkedList来实现IntegerStack，怎么实现？测试代码需要进行什么修改？
    输入样例
    5
    1 3 5 7 -1
    2
    输出样例
    1
    3
    5
    7
    -1
    -1,false,5
    [1, 3, 5, 7, -1]
    -1
    7
    5,false,3
    [1, 3, 5]
import java.util.LinkedList;
import java.util.Scanner;
 
interface IntegerStack{
    public Integer push(Integer item); 
    public Integer pop(); 
    public Integer peek();
    public boolean empty(); 
    public int size();
}
class ArrayListIntegerStack implements IntegerStack{
    LinkedList linkedList=new LinkedList();
    public Integer push(Integer item) {
        if (item==null){
            return null;
        }
        linkedList.push(item);
        return item;
    }
    public Integer pop() {
        if (linkedList.size()==0){
            return null;
        }
        return (int)linkedList.pop();
    }
    public Integer peek() {
        if (linkedList.size()==0){
            return null;
        }
        return (int)linkedList.peek();
    }
    public boolean empty() {
        return linkedList.isEmpty();
    }
    public int size() {
        return linkedList.size();
    }
    public String toString() {
        String s="";
        s+="[";
        int i=linkedList.size();
        if (i!=0){
            i--;
            for (;i>0;i--){
                s+=linkedList.get(i)+", ";
            }
            s+=linkedList.get(i)+"]";
        }else {
            s+="]";
        }
        return  s;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();
        ArrayListIntegerStack arrayListIntegerStack = new ArrayListIntegerStack();
        for (int i=0;i<num;i++){
            int number=sc.nextInt();
            System.out.println(arrayListIntegerStack.push(number));
        }
        System.out.println(arrayListIntegerStack.peek()+","+arrayListIntegerStack.empty()+","+arrayListIntegerStack.size());
        System.out.println(arrayListIntegerStack.toString());
        int pop_num=sc.nextInt();
        for (int i=0;i<pop_num;i++){
            System.out.println(arrayListIntegerStack.pop());
        }
        System.out.println(arrayListIntegerStack.peek()+","+arrayListIntegerStack.empty()+","+arrayListIntegerStack.size());
        System.out.println(arrayListIntegerStack.toString());
    }
}

7-3 jmu-Java&Python-统计一段文字中的单词个数并按单词的字母顺序排序后输出 (10分)

现需要统计若干段文字(英文)中的不同单词数量。
如果不同的单词数量不超过10个，则将所有单词输出(按字母顺序)，否则输出前10个单词。
注1：单词之间以空格(1个或多个空格)为间隔。
注2：忽略空行或者空格行。
注3：单词大小写敏感，即’word’与’WORD’是两个不同的单词 。
输入说明
若干行英文，最后以!!!为结束。
输出说明
不同单词数量。 然后输出前10个单词（按字母顺序），如果所有单词不超过10个，则将所有的单词输出。
输入样例
Failure is probably the fortification in your pole
It is like a peek your wallet as the thief when you
are thinking how to spend several hard-won lepta
when you Are wondering whether new money it has laid
background Because of you, then at the heart of the
most lax alert and most low awareness and left it
godsend failed
!!!
输出样例
49
Are
Because
Failure
It
a
alert
and
are
as
at

import java.util.*;
 
public class Main{
 
	public static void main(String[] args) {
		Scanner sc=new Scanner (System.in);
		Set<String>set=new TreeSet<String>();
		String str="";
		while(true) {
			str=sc.next();
			if(str.equals("!!!!!")) {
				break;
			}
			set.add(str);
		}
		System.out.println(set.size());
		//使用Iterator迭代器
		Iterator<String> i=set.iterator();
		if(set.size()<10) {
			while(i.hasNext()) {
				System.out.println(i.next());
			}
		}else {
			for(int j=0;j<10;j++) {
				System.out.println(i.next());
			}
		}
		//使用foreach输出
//		int count=0;
//		for(String str1:set) {
//			count++;
//			System.out.println(str1);
//			if(count==10) {
//				break;
//			}
//		}
	}
}

7-4 jmu-Java-05集合-4-倒排索引 (20分)

对若干行文字建立倒排索引(根据单词找到所在行号)。
然后根据关键字，在倒排索引查找进行查找，找到包含所有该关键字所在的行数并输出。
输入说明

  1. 若干行英文，以!!!为结束。
  2. 输入一行查询关键字，以1个空格为分隔
    输出说明
  3. 输出所创建倒排索引。索引的key按照字母升序，索引的value按照行号升序
  4. 输出查询结果。如果找到，输出行集与行集内每一行的内容，如果没找到输出found 0 results
    输入样例
    where are you from are you ok
    this is a test
    that is an apple
    there are lots of apples you eat it
    who are you
    !!!
    you are
    eat
    you test
    abc
    输出样例
    a=[2]
    an=[3]
    apple=[3]
    apples=[4]
    are=[1, 4, 5]
    eat=[4]
    from=[1]
    is=[2, 3]
    it=[4]
    lots=[4]
    of=[4]
    ok=[1]
    test=[2]
    that=[3]
    there=[4]
    this=[2]
    where=[1]
    who=[5]
    you=[1, 4, 5]
    [1, 4, 5]
    line 1:where are you from are you ok
    line 4:there are lots of apples you eat it
    line 5:who are you
    [4]
    line 4:there are lots of apples you eat it
    found 0 results
    found 0 results
import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Map <String, List<Integer>> map = new HashMap();
        int n = 0;
        List<String> lines = new ArrayList<>();
        while (true) {
            String line = in.nextLine();
            if (line.equals("!!!!!"))
                break;
            n++;
            lines.add(line);
            String[] words = line.split(" ");
            for (String word : words) {
                if (map.containsKey(word)) {
                    if (map.get(word).contains(n))
                        continue;
                    map.get(word).add(n);
                } else {
                    List<Integer> index = new ArrayList<>();
                    index.add(n);
                    map.put(word, index);
                }
            }
        }
        List<Map.Entry<String, List<Integer>>> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, Comparator.comparing(Map.Entry::getKey));
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        while (true) {
            String[] keys = in.nextLine().split(" ");
            List<List<Integer>> index = new ArrayList<>();
            for (int i = 0; i < keys.length; i++) {
                for (int j = 0; j < list.size(); j++) {
                    if (list.get(j).getKey().equals(keys[i])) {
                        index.add(list.get(j).getValue());
                    }
                }
            }
            if (index.size() == 0) {
                System.out.println("found 0 results");
                continue;
            }
            List<Integer> result = index.get(0);
            if (keys.length >= 2) {
                for (int i = 1; i < index.size(); i++) {
                    result.retainAll(index.get(i));
                }
                if (result.size()==0){
                    System.out.println("found 0 results");
                    continue;
                }
            }
            System.out.println(result);
            for (int i : result) {
                System.out.println("line "+i+":"+lines.get(i-1));
            }
        }
    }
}

7-5 有重复的数据I (10分)

在一大堆数据中找出重复的是一件经常要做的事情。现在，我们要处理许多整数，在这些整数中，可能存在重复的数据。
你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，输出“YES”这三个字母；如果没有，则输出“NO”。
输入格式:
你的程序首先会读到一个正整数n，1<=n<=100000。 然后是n个整数，这些整数的范围是[1,100000]。
输出格式:
如果这些整数中存在重复的，就输出：
YES
否则，就输出： NO
输入样例:
5
1 2 3 1 4
输出样例:
YES

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

class Input{
	StringTokenizer tok;
	BufferedReader buf;
	public Input() {
		// TODO Auto-generated constructor stub
		buf = new BufferedReader(new InputStreamReader(System.in));
	}
	boolean hasNext()
	{
		while(tok==null||!tok.hasMoreElements())
		{
			try {
				tok = new StringTokenizer(buf.readLine());
			} catch (Exception e) {
				// TODO: handle exception
				return false;
			}
		}
		return true;
	}
	String next()
	{
		if(hasNext())
			return tok.nextToken();
		return null;
	}
	int nextInt()
	{
		return Integer.parseInt(next());
	}
}
public class Main {
    public static void main(String[] args){
        Input in = new Input();
        Set<Integer> s = new HashSet<>();
        int n = in.nextInt();
        for(int i=0;i<n;i++)
        	s.add(in.nextInt());
        if(s.size()==n)
        	System.out.println("NO");
        else
        	System.out.println("YES");
    }
}

7-6 御膳房 (5分)

御膳房要准备皇帝的早餐，非常的辛苦。辛苦是因为这个皇帝很挑剔，要求相邻两天不能吃相同的早餐。根据采买到的原料，御膳房准备了未来几天的早餐的菜单。但是厨师不懂数学，排出的菜单有相邻两天重复的。你能否根据菜单，判断能不能调整成相邻两天不重复的呢？
输入格式:
首先是一个正整数N（1<N<100），表示厨师准备了N天的菜单。 然后是N个正整数Pi（1<Pi<100），每个数字表示一天的早餐内容。相同的数字表示相同的内容。
输出格式:
如果可以调整成相邻两天不重复，就输出
YES
否则就输出
NO
输入样例:
6
1 2 4 6 6 4
输出样例:
YES

import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        int i,m;
        for(i = 0;i < n;i++)
        {
           m = sc.nextInt();
           a[m]++;
        }
        for(i = 0;i < n;i++)
        {
            if(a[i] >= (n / 2+2))
            {
                System.out.println("NO");    
              return;
            }
        }
        System.out.println("YES");
    }
}

7-7 jmu-Java-05集合(泛型)-10-GeneralStack (15分)

以前定义的IntegerStack接口，只能用于存放Integer类型的数据。然而对于栈来说，不管内部存放的是什么类型的数据，基本操作与元素的具体类型无关。

  1. 编写一个通用的GeneralStack接口，接口中的操作对任何引用类型的数据都适用。
    一旦定义完毕，只能存放一种类型的数据，比如只能存放String或只能存放Integer。GeneralStack接口方法如下：
    push(item); //如item为null，则不入栈直接返回null。
    pop(); //出栈，如为栈为空，则返回null。
    peek(); //获得栈顶元素，如为空，则返回null.public boolean empty();//如为空返回truepublic int size(); //返回栈中元素数量

2.定义GeneralStack的实现类ArrayListGeneralStack
内部使用ArrayList对象存储，属性名为list。
方法: public String toString()//该方法的代码为return list.toString();
提示：

  1. 不用使用top指针。
  2. 直接复用ArrayList中已有的方法。
  3. pop时应将相应的元素从ArrayList中移除。
  4. 代码中不要出现类型不安全的强制转换。
    3.定义Car对象
    属性：
    private int id;private String name;
    方法：Eclipse自动生成setter/getter,toString方法。
    4.main方法说明
  5. 输入选项，有quit, Integer, Double, Car4个选项。如果输入quit，则直接退出。否则，输入整数m与n。m代表入栈个数，n代表出栈个数。然后声明栈变量stack。
  6. 输入Integer,打印Integer Test。建立可以存放Integer类型的ArrayListGeneralStack。入栈m次，出栈n次。打印栈的toString方法。最后将栈中剩余元素出栈并累加输出。
  7. 输入Double ，打印Double Test。剩下的与输入Integer一样。
  8. 输入Car，打印Car Test。其他操作与Integer、Double基本一样。只不过最后将栈中元素出栈，并将其name依次输出。
    2、3、4步骤做完都要使用代码System.out.println(stack.getClass().getInterfaces()[0]);打印标识信息
    特别注意：如果栈为空的时候继续出栈，则返回null
    输入样例
    Integer
    5
    2
    1 2 3 4 5
    Double
    5
    3
    1.1 2.0 4.9 5.7 7.2
    Car
    3
    2
    1 Ford
    2 Cherry
    3 BYD
    quit
    输出样例
    Integer Test
    push:1
    push:2
    push:3
    push:4
    push:5
    pop:5
    pop:4
    [1, 2, 3]
    sum=6
    interface GeneralStack
    Double Test
    push:1.1
    push:2.0
    push:4.9
    push:5.7
    push:7.2
    pop:7.2
    pop:5.7
    pop:4.9
    [1.1, 2.0]
    sum=3.1
    interface GeneralStack
    Car Test
    push:Car [id=1, name=Ford]
    push:Car [id=2, name=Cherry]
    push:Car [id=3, name=BYD]
    pop:Car [id=3, name=BYD]
    pop:Car [id=2, name=Cherry]
    [Car [id=1, name=Ford]]
    Ford
    interface GeneralStack
import java.util.ArrayList;
import java.util.Scanner;
 
interface GeneralStack<T>{
    public T push(T item);
    public T pop();
    public T peek();
    public boolean empty();
    public int size();}
class ArrayListGeneralStack implements GeneralStack{
    ArrayList list=new ArrayList();
    public String toString() {
        return  list.toString();
    }
    public Object push(Object item) {
        if (list.add(item)){
            return item;
        }else {
            return false;
        }
    }
    public Object pop() {
        if (list.size()==0){
            return null;
        }
        return list.remove(list.size()-1);
    }
    public Object peek() {
        return list.get(list.size()-1);
    }
    public boolean empty() {
        if (list.size()==0){
            return true;
        }else {
            return false;
        }
    }
    public int size() {
        return list.size();
    }
}
class Car{
    private int id;
    private String name;
    public String toString() {
        return "Car [" +
                "id=" + id +
                ", name=" + name  +
                ']';
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Car(int id, String name) {
        this.id = id;
        this.name = name;
    }
}
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while (true){
            String s=sc.nextLine();
            if (s.equals("Double")){
                System.out.println("Double Test");
                int count=sc.nextInt();
                int pop_time=sc.nextInt();
                ArrayListGeneralStack arrayListGeneralStack = new ArrayListGeneralStack();
                for (int i=0;i<count;i++){
                    System.out.println("push:"+arrayListGeneralStack.push(sc.nextDouble()));
                }
                for (int i=0;i<pop_time;i++){
                    System.out.println("pop:"+arrayListGeneralStack.pop());
                }
                System.out.println(arrayListGeneralStack.toString());
                double sum=0;
                int size=arrayListGeneralStack.size();
                for (int i=0;i<size;i++){
                    sum+=(double)arrayListGeneralStack.pop();
                }
                System.out.println("sum="+sum);
                System.out.println("interface GeneralStack");
            }else if (s.equals("Integer")){
                System.out.println("Integer Test");
                int count=sc.nextInt();
                int pop_time=sc.nextInt();
                ArrayListGeneralStack arrayListGeneralStack = new ArrayListGeneralStack();
                for (int i=0;i<count;i++){
                    System.out.println("push:"+arrayListGeneralStack.push(sc.nextInt()));
                }
                for (int i=0;i<pop_time;i++){
                    System.out.println("pop:"+arrayListGeneralStack.pop());
                }
                System.out.println(arrayListGeneralStack.toString());
                int sum=0;
                int size=arrayListGeneralStack.size();
                for (int i=0;i<size;i++){
                    sum+=(int)arrayListGeneralStack.pop();
                }
                System.out.println("sum="+sum);
                System.out.println("interface GeneralStack");
            }else if (s.equals("Car")){
                System.out.println("Car Test");
                int count=sc.nextInt();
                int pop_time=sc.nextInt();
                ArrayListGeneralStack arrayListGeneralStack = new ArrayListGeneralStack();
                for (int i=0;i<count;i++){
                    int id=sc.nextInt();
                    String name=sc.next();
                    Car car = new Car(id,name);
                    System.out.println("push:"+arrayListGeneralStack.push(car));
                }
                for (int i=0;i<pop_time;i++){
                    System.out.println("pop:"+arrayListGeneralStack.pop());
                }
                System.out.println(arrayListGeneralStack.toString());
                if (arrayListGeneralStack.size()>0){
                    int size=arrayListGeneralStack.size();
                    for (int i=0;i<size;i++){
                        Car car=(Car) arrayListGeneralStack.pop();
                        System.out.println(car.getName());
                    }
                }
                System.out.println("interface GeneralStack");
            }else if (s.equals("quit")){
                break;
            }
        }
    }
}

6-1 jmu-Java-07多线程-Thread (3分)

编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。
功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息
裁判测试程序：

import java.util.Scanner;
/*这里放置你的答案，即MyThread类的代码*/
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Thread t1 = new MyThread(Integer.parseInt(sc.next()));
        t1.start();
    }
}

输入样例：
3
输出样例：
0
1
2
标识信息

class MyThread extends Thread{
	private int n;
	public MyThread(int n) {
		this.n=n;
	}
	public void run() {
		for(int i=0;i<n;i++) {
			System.out.println(i);
		}
		System.out.println(Thread.currentThread().getName()+" "+isAlive());
	}
}

6-2 jmu-Java-07多线程-Runnable与匿名类 (3分)
在Main方法中启动一个线程t1，该线程打印3行信息：

  1. 主线程名
  2. 线程t1的线程名
  3. 线程t1所实现的所有接口。提示：使用System.out.println(Arrays.toString(getClass().getInterfaces()));打印
    注：本题也可使用Lambda表达式实现。
    裁判测试程序：
public class Main {	
    public static void main(String[] args) {
        final String mainThreadName = Thread.currentThread().getName();
        Thread t1 = /*这里放置你的代码*/
        t1.start();
    }
}

new Thread(new Runnable() {
			@Override
			public void run() {
                System.out.println(mainThreadName);
				System.out.println(Thread .currentThread().getName());
				System.out.println(Arrays.toString(getClass().getInterfaces()));
			}
        	
        });

6-3 jmu-Java-07多线程-互斥访问 (5分)

定义Account类
属性：
private int balance
方法：
getter方法
void deposit(int money) //存钱，在余额的基础上加上money
void withdraw(int money) //取钱，在余额的基础上减去money
注意：可能有多个线程通过deposit或withdraw方法同时存取Account对象的balance属性。
裁判测试程序：
import java.util.Scanner;
/你的代码，即Account类的代码/
/系统已有代码，无需关注/

class Account implements Runnable{
	private int balance;
	public int getBalance() {
		return balance;
	}
	public void setBalance(int balance) {
		this.balance = this.getBalance();
	}
	
	public Account(int balance) {
		super();
		this.balance = balance;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		
	}
	synchronized public void deposit(int money) {
		this.balance=money+this.getBalance();
	}
	synchronized public void withdraw(int money) {
		this.balance=-money+this.getBalance();;
	}
	
}

6-4 jmu-Java-07多线程-同步访问 (10分)

现已有Account类，拥有
属性:
private int balance
方法:
相应的getter方法。
要求为该类编写：
void deposit(int money) //存钱，在余额的基础上加上money
void withdraw(int money) //取钱，在余额的基础上减去money
注意：

  1. 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。
  2. 需要编写完整的deposit方法与withdraw的前半部分代码解决该问题。
    裁判测试程序：
    import java.util.Scanner;
    //这里是已有的Account类前半部分的代码/这里是deposit代码//这里是withdraw代码的前半部分/
    if(balance<0) //这里是withdraw代码的后半部分。
    throw new IllegalStateException(balance+"");
    }
    /系统已有代码，无需关注/
public  synchronized void deposit(int money)
{
    
        this.balance=this.getBalance()+money;
        
   
}
public synchronized void withdraw(int money)
{
    
        if(balance<money){
            try
            {
                wait();
            }catch(Exception e)
            {
            }
        }

         this.balance=this.getBalance()-money;

6-5 jmu-Java-07多线程-交替执行 (15分)
有一连串任务，需要两个线程交替执行。线程1执行完任务1后，线程2才能执行任务2，接下来线程1执行任务1，如此交替执行下去。直到所有任务执行完毕。
定义Repo类代表任务仓库，使用字符串代表任务。该类拥有：
构造函数:
/将传递进来的字符串以空格分隔分解为多个不同的任务，并存储起来。如"1 2 3 4 5 6"被分解成6个任务1,2,3,4,5,6/
public Repo(String items) {
}
方法：
int getSize(); //返回Repo包含的任务数量。注意：完成任务的时候，需要将任务删除。//其他完成任务的方法

定义Worker1与Worker2类，代表两个交替完成任务的类，可以从Repo对象中获取任务。
main函数如下：
public class Main {
public static void main(String[] args) throws InterruptedException {
Scanner sc = new Scanner(System.in);
Repo repo = new Repo(sc.nextLine());
Thread t1 = new Thread(new Worker1(repo));
Thread t2 = new Thread(new Worker2(repo));
t1.start();
Thread.yield();
t2.start();
sc.close();
}
}
输入样例
1 2 3 4 5 6 7 8 9
输出样例
Thread-0 finish 1
Thread-1 finish 2
Thread-0 finish 3
Thread-1 finish 4
Thread-0 finish 5
Thread-1 finish 6
Thread-0 finish 7
Thread-1 finish 8
Thread-0 finish 9

裁判测试程序：
/Repo代码/
/Worker1代码/
/Worker2代码/
/系统已有代码，无需关注/

import java.util.Scanner;
class Repo{
	String []str;
    boolean flag=false;
	public Repo(String items) {
		str=items.split(" ");
		
	}
	 public int getSize() {
		 return str.length;
	 }
	 
}
class Worker1 implements Runnable{
	Repo repo;
	public Worker1(Repo repo) {
		this.repo=repo;
		
	}
     
	@Override
	public  void run() {
        while (repo.getSize()>0){
        	synchronized (repo) {
        		if(repo.flag) {
        			try {
						repo.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
        		}else {
        			System.out.println(Thread.currentThread().getName()+" finish "+repo.str[0]);
        			String str2[]=new String[repo.getSize()-1];
        			System.arraycopy(repo.str, 1, str2, 0, repo.str.length-1);
        			repo.str=str2;
        			repo.flag=true;
        			repo.notify();
        		}
				
			}
        }
		
		
	}
	
}
class Worker2 implements Runnable{
	Repo repo;
	public Worker2(Repo repo) {
		this.repo=repo;
	}

	@Override
	public void run() {
		while(repo.getSize()>0) {
			synchronized (repo) {
				if(!repo.flag) {
        			try {
						repo.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
        		}else {
        			System.out.println(Thread.currentThread().getName()+" finish "+repo.str[0]);
        			String str2[]=new String[repo.getSize()-1];
        			System.arraycopy(repo.str, 1, str2, 0, repo.str.length-1);
        			repo.str=str2;
        			repo.flag=false;
        			repo.notify();
        		}
			}
		}
	}
}

7-1 程序改错题4 (5分)

程序改错题。请修改下列代码，使程序能够输出正确的结果。

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Thread t = new Thread(new RunHandler());
		t.run();
	}
}

class RunHandler  {
	public void run() {
		Scanner in = new Scanner(System.in);
		int x = in.nextInt();
			System.out.println("run");
	}
}

输入格式:
输入一个整数x。
输出格式:
输出x行，每行一个字符串“run”。
输入样例:
4
输出样例:
run
run
run
run

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Thread t = new Thread(new RunHandler());
		t.run();
	}
}

class RunHandler implements Runnable  {
	public void run() {
		Scanner in = new Scanner(System.in);
		int x = in.nextInt();
		for(int i=0;i<x;i++) {
			System.out.println("run");
		}
			
	}
}

7-2 多线程计算 (20分)

已知某学校有n名教师，学校有m名学生，学校搞学生民意调查，每一位学生为每一位老师都打分，学生所打的所有的分数都集中到一个数组中。数据存放规律是，前m个数据是对1号老师的打分，接下来m个数据是对2号老师的打分，以此类推。请设计一个多线程的算法，计算出每一位老师的总打分。
输入格式:
第一行输入教师数，第二行输入学生数，第三行输入所有n*m个打分（整型），各个分数之间以一个空格分隔
输出格式:
按照教师原来的顺序，每行输出每一位老师的得分
输入样例:
在这里给出一组输入。例如：
2
3
1 2 3 4 5 6
输出样例:
在这里给出相应的输出。例如：
6
15

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

public class Main {
	public static void main(String[] args) {
		MyThread mt=new MyThread();
		new Thread(mt).start();
		
	}
}
class MyThread implements Runnable{
	

	@Override
	public void run() {
		Scanner sc=new Scanner(System.in);
		int tn=sc.nextInt();
		int sn=sc.nextInt();
		int []code=new int[tn*sn];
		for(int i=0;i<code.length;i++) {
			code[i]=sc.nextInt();
		}
		int sum=0;
		int t=1;
		for(int i=0;i<code.length;i++,t++) {
			sum+=code[i];
			if(t==sn) {
				System.out.println(sum);
				sum=0;
				t=0;
			}
			
		}
		
	}
	
}
一只拥有神力的兔子
关注
专栏目录
简介java5、java6、java7、java8、java9
zf888999666的博客
07-29 1911
JAVA作为使用的主力语言，掌握下其历史发展也是有必要的。看看从JAVA5开始到现在的JAVA9有哪些变化。借此机会，也可以看看哪些特性我们是已经用到的，哪些是还没有用到的。我们在IDEA里面也可以看到languagelevel里面的信息，这里也大致写了下各个版本JDK的新特性。JAVA1.3普通的原始的JAVA，基本语法相信大家都见过了JAVA1.4assert关键字JAVA5枚举类型、泛型、自动拆装箱JAVA6@Override注解JAVA7符号、ARM支持、支持多catch。...
看了就明白！java5、java6、java7、java8、java9新特性
m0_64363449的博客
07-30 712
你可以用过简单的annotaion将你的API发布成.NET交互的web services. Mustang 添加了新的解析和 XML 在 Java object-mapping APIs中, 之前只在Java EE平台实现或者Java Web Services Pack中提供.引用泛型之后，允许指定集合里元素的类型，免去了强制类型转换，并且能在编译时刻进行类型检查的好处。Java中某些资源是需要手动关闭的，如InputStream，Writes，Sockets，Sql classes等。
6-2 创建一个直角三角形类实现IShape接口
GZH_mxjx的博客
09-24 354
创建一个直角三角形类（regular triangle）RTriangle类，实现下列接口IShape。两条直角边长作为RTriangle类的私有成员，类中包含参数为直角边的构造方法。interface IShape {// 接口// 抽象方法 求面积// 抽象方法 求周长。
面向对象-java匿名内部类
qq_41048982的博客
11-02 107
6-2 请按照要求实现接口 (10分) java pta
m0_46553277的博客
11-01 1276
创建一个直角三角形类Triangle类，实现下列接口Ishape。两条直角边长作为Triangle类的私有成员，类中包含参数为直角边的构造方法。 函数接口定义： 请详细阅读接口和主方法中的定义和调用。 裁判测试程序样例： import java.text.DecimalFormat; interface Ishape { public abstract double getArea(); public abstract double getPerimeter(); } /*你写的代码将
07创建一个直角三角形类实现IShape接口
ihopeyousuccess的博客
11-29 2602
创建一个直角三角形类（regular triangle）RTriangle类，实现下列接口IShape。两条直角边长作为RTriangle类的私有成员，类中包含参数为直角边的构造方法。 interface IShape {// 接口 public abstract double getArea(); // 抽象方法 求面积 public abstract double getPerimeter(); // 抽象方法 求周长 } ###直角三角形类的定义： 直角三角形类的构造函数原型如下： RTriangle
Java-JDK-11.0.8(Windows &amp; Mac os) 下载
09-19
Java JDK 11.0.8 是Oracle公司发布的Java开发工具包的一个稳定版本，它针对开发者提供了完整的编译、调试和运行Java应用程序所需的环境。这个版本支持Windows和Mac OS操作系统，使得不同平台上的开发者都能方便地...
Java OCR 图像智能字符识别技术，可识别中文
02-08
6. 分类识别：使用预先训练的模型（如深度学习的CNN模型或传统的模板匹配方法）对字符进行分类，将其转化为对应的文本。 对于中文字符的识别，Java OCR面临更大的挑战，因为中文字符数量庞大且形状复杂。常用的Java...
Java小游戏之数字彩虹雨
12-07
6. **时间同步与动画**：通过设置定时器或使用`Thread.sleep()`来控制数字雨的下落速度，实现时间同步，保证动画的流畅性。 7. **事件监听**：为了增加交互性，可以添加事件监听器，例如鼠标点击事件，当用户点击...
Java项目经验汇总(简历项目素材）
11-03
Java项目经验汇总(简历项目素材）
Java面试指南：突破面试难关，成为优秀程序员的必备利器！
热门推荐
Java程序员廖志伟
05-08 12万+
超高质量的文章，Java面试，Java理论知识大全，人生感悟都给到你。
Java第七章继承、多态、抽象类和接口
jjwlikegirl的博客
04-04 581
课堂内容
6-1 创建一个直角三角形类实现IShape接口 (10分)
sddfnsff的博客
06-15 4629
创建一个直角三角形类（regular triangle）RTriangle类，实现下列接口IShape。两条直角边长作为RTriangle类的私有成员，类中包含参数为直角边的构造方法。 interface IShape {// 接口 public abstract double getArea(); // 抽象方法 求面积 public abstract double getPerimeter(); // 抽象方法 求周长 } 直角三角形类的定义： 直角三角形类的构造函数原型如下： RTriangle(do
Java基础从入门到实战
07-04
 尹成老师，带你步入java 语言的殿堂，讲课生动风趣、深入浅出，全套视频内容充实，整个教程以java语言为核心，完整精彩的演练了数据结构、算法、设计模式、数据库、大数据高并发检索、文件重定向、多线程同步、进程通讯、加密解密，以及各种精彩的小项目等，非常适合大家学习！帮助大家快速入门java语言，一步步的成为java语言高手。清华高手尹成老师、微软全球most 价值专家，帮助你巩固知识点，提高应对面试的能力，为后续课程开发打下极其坚实的基础！ Java大数据处理    Java大规模数据预览 成哥的迷宫就像他的人生，但是编程能力就是迷宫中的任务，只有编程能力提升才能走出迷宫 密码破解 Java读写文档 报表统计 Java爬虫系统，成哥的大爱 Java图形化编程 Java控制数据导入Oracle数据库     Java高并发内存数据库
6-1 Shape类 (20分)
雪岩的博客
12-22 8456
java旧题复习 6-1 Shape类 (20分) 定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数 定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea() 定义一个子类圆形类Circle继承自Shape，拥有半径属性
关于应该实现ActionListener接口还是使用ActionListener的匿名类对象
;
11-14 3166
java
jmu-Java-04面向对象进阶-01-接口-匿名内部类ActionListener
最新发布
xxn66666666的博客
10-16 303
ActionListener 的实现是通过一个匿名内部类来完成的。// 使用前面创建的 ActionListener。// ActionListener 参数的构造函数。// 实例作为参数来初始化 starter 变量。// 这里假设 MyStarter 类有一个接受。同时重写其方法，而无需显式地声明一个新的类。匿名内部类是一种特殊的类，它没有名字，并且在定义它的地方被立即实例化。这种技术允许你创建一个类的实例，
PTA 2022秋-Java-04-面向对象2（继承与多态）
m0_66137457的博客
10-10 2770
PTA 2022秋-Java-04-面向对象2（继承与多态）
多线程-题
weixin_33972649的博客
02-01 124
1、进程和线程之间有什么不同？ 一个进程是一个独立（self contained）的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源。 2、多线程编程的好处是什么？ 在多线程程序中，多个线程被并发的执行以提高程序的效率，C...
6-2 创建一个直角三角形类实现ishape接口 (10 分)
06-28
### 回答1： 题目意思：创建一个直角三角形类实现iShape接口。 回答如下： 创建一个类Triangle，实现iShape接口。该类应包含三个私有属性：底边长base、直角边长height、斜边长hypotenuse，以及求解面积和周长的方法，具体代码如下所示： ```python class Triangle(iShape): def __init__(self, base, height): self.base = base self.height = height self.hypotenuse = math.sqrt(base * base + height * height) def area(self): return 0.5 * self.base * self.height def perimeter(self): return self.base + self.height + self.hypotenuse ``` 注意，由于是创建直角三角形类，因此我们只需要知道底边长和直角边长即可求解斜边长，所以在构造函数中我们只传入了底边长和直角边长，并根据勾股定理求解出了斜边长。面积的求解根据公式:s=0.5bh进行，周长的求解则是底边长、直角边长和斜边长的和。 ### 回答2： 直角三角形类是一种继承自ishape接口的类，用于表示直角三角形。该类包含了直角边、斜边和空心图形的属性，并实现了ishape接口的方法，包括计算面积、计算周长和绘制图形。 在该类中，我们可以通过构造函数初始化直角边和斜边的长度，并通过设置空心图形的属性确定三角形的绘制方式。对于计算面积和周长的方法，我们可以使用标准的数学公式进行计算，其中面积公式为：面积 = 直角边 * 斜边 / 2，周长公式为：周长 = 直角边 + 斜边 + 斜边的平方根。 此外，根据ishape接口规定，直角三角形类需要提供一个绘制图形的方法来展示三角形。为了实现这个方法，我们可以使用Java的Graphics2D类来绘制一个三角形的轮廓。先设置画笔的颜色和线宽，然后分别绘制直角边、斜边和第三条边的轮廓。 总之，实现一个直角三角形类并遵循ishape接口的规范，可以让我们在Java程序中使用该类轻松地创建和操作直角三角形。通过该类，我们可以计算三角形的面积和周长，并在GUI环境中绘制出美观的图形。 ### 回答3： 直角三角形是一种特殊的三角形，其内部包含一个直角（90度角）。根据几何学定义，直角三角形的两条直角边的平方和等于斜边的平方。 在面向对象编程中，可以通过创建一个直角三角形类来实现直角三角形的功能。为了实现该类的功能，可以通过实现一个名为“ishape”的接口来指定所需的方法。该接口应该包括计算面积和计算周长的方法。 在创建直角三角形类时，需要定义三个属性，分别是三角形的两条直角边和斜边的长度。这些属性可以通过构造函数或setter方法来设置。在定义属性时，需要注意数据类型的选择，以确保能够存储足够的精度。 对于面积计算方法，可以通过利用直角三角形的定义进行计算。具体而言，面积可以通过直角边的乘积再除以2来计算。计算周长时，需要将所有三条边的长度相加。 在实现直角三角形类时，需要考虑输入的长度是否为正数，以及是否符合直角三角形定义，例如两条直角边是否相互垂直。如果输入不符合条件，应该通过异常处理等方式提示错误信息。 最终，可以通过创建直角三角形对象并调用相应的方法来计算直角三角形的面积和周长。此外，可以运用面向对象编程的思想，对直角三角形类进行扩展，以实现更多功能，比如计算其它形状的三角形。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值