软件工程 之 (XMUT)Java期末复习题及答案2

发布时间 2023-09-18 18:11:10作者: Ivan丶c

{callout color="#f0ad4e"}
软件工程实用案例教程 https://www.ivanky.cn/XMUTRG/304.html
Java期末复习题及答案 https://www.ivanky.cn/XMUTRG/361.html
计算机网络复习题库 https://www.ivanky.cn/XMUTRG/405.html

(XMUT)Java期末复习题及答案

le2by5cx.png

选择题

{collapse}
{collapse-item label="单选题" }
分数 1
作者 张峰
单位 山东科技大学
一个计算机上安装JDK后,该计算机不包含的是()。
A.JRE
B.JVM
C.Eclipse
D.javac.exe

分数 1
作者 刘永福
单位 河北农业大学
关于Java语言的描述,错误的是()。
A.每一个.java文件编译后对应一个.class文件。
B..java文件编译后,每一个class对应一个.class文件
C.Java源代码编译后产生的.class是字节码文件
D..class文件在JVM上运行

分数 1
作者 殷伟凤
单位 浙江传媒学院
下面哪个标识符不符合Java定义要求?
A.String
B._Name
C.Name123
D.100Book

分数 1
作者 殷伟凤
单位 浙江传媒学院
下列哪个叙述是正确的?
A.Java应用程序由若干个类所构成,这些类必须在一个源文件中
B.Java源文件必须含有主类
C.Java源文件的文件名必须与public类名完全相同
D.Java应用程序由若干个类所构成,这些类可以在一个源文件中,也可以分布在若干个源文件中,其中每个源文件必须含有主类。

分数 1
作者 殷伟凤
单位 浙江传媒学院
以下哪个标识符不合法?
A._sys1_lll
B.2mail
C.$change
D.Class

分数 1
作者 殷伟凤
单位 浙江传媒学院
Java应用程序源文件的扩展名为( )。
A.java
B.class
C.exe
D.html

分数 1
作者 殷伟凤
单位 浙江传媒学院
Java应用程序经过编译后会产生一个以( )为扩展名的字节码文件
A.java
B.class
C.exe
D.html

分数 1
作者 李妙妍
单位 沈阳师范大学
哪一种类型的代码被JVM解释成本地代码?
A.源代码
B.处理器代码
C.字节码
D..exe可执行代码

分数 1
作者 李妙妍
单位 沈阳师范大学
编译Java源文件和解释执行Java字节码文件的指令分别是什么?
A.javac.exe和javadoc.exe
B.java.exe和jdb.exe
C.jad.exe和java.exe
D.javac.exe和java.exe

分数 1
作者 李妙妍
单位 沈阳师范大学
在Java类的定义中,程序执行入口声明如下,哪一个是错误的程序代码?
A.public static void main(String args){ }
B.public static void main(String[ ] args){ }
C.public static void main(String args[ ]){ }
D.public static void main(String message[ ]){ }

分数 1
作者 周雪芹
单位 山东理工大学
一个Java源文件中最多可以包含( )个主类?
A.0
B.1
C.2
D.不受限制

分数 1
作者 周雪芹
单位 山东理工大学
下列说法中,不正确的是( )。
A.一个java源程序经过编译后,得到的文件的扩展名一定是.class。
B.一个java源程序编译通过后,得到的结果文件数也只有一个。
C.一个java源程序只能有一个public class类定义,且源文件的名字与public class的类名相同,扩展名必须是.java。
D.一个java源程序可以编译成多个class文件。

分数 1
作者 周雪芹
单位 山东理工大学
某Java源文件代码如下,该源文件应如何命名?

public class A {
 int a;
}
class B {
 int b;
}
class C {
 public static void main(String[] args) {
  System.out.print("HELLO!");
 }
}

A.一定是A.java
B.一定是B.java
C.一定是C.java
D.不确定

分数 1
作者 周雪芹
单位 山东理工大学
某Java源文件代码如下,该源文件应如何命名?

class A {
  int a;
}
class B {
  int b;
}
class C {
   public static void main(String[] args) {
       System.out.print("HELLO!");
   } 
}

A.一定是A.java
B.一定是B.java
C.一定是C.java
D.后缀是.java,文件名可以任意取,符合标识符规范即可。

分数 1
作者 周雪芹
单位 山东理工大学
( )方法是Java程序执行的入口,含有该方法的类叫做( )。
A.main 主类
B.Main 主类
C.main 公共类
D.Main 公共类

分数 1
作者 周雪芹
单位 山东理工大学
下面哪种类型的文件可以在Java虚拟机中运行?
A..java
B..jre
C..exe
D..class

分数 1
作者 周雪芹
单位 山东理工大学
Java属于以下哪种语言?
A.机器语言
B.汇编语言
C.高级语言
D.以上都不对

分数 1
作者 周雪芹
单位 山东理工大学
对JDK描述错误的是( )。
A.运行Java程序只要有JRE环境就可以,不一定需要全部JDK的功能
B.JDK中包括JVM、核心类库、Java开发工具(java,javac)等
C.JDK本身也是平台无关的,不同的操作系统安装的JDK是一样的
D.JDK的全称是 Java Development Kit

分数 1
作者 周雪芹
单位 山东理工大学
正确配置path环境变量的方式是:( )。
A.在系统环境变量path原有的字符串基础上,加上分号“;”,然后再加上JDK安装路径下的bin目录
B.新建系统环境变量path,其值为:分号“;”,然后再连上JDK安装路径下的bin目录
C.在系统环境变量path原有的字符串基础上,加上分号“;”,然后再加上JDK安装路径下的lib目录
D.新建系统环境变量path,其值为:分号“;”,然后再连上JDK安装路径下的lib目录

分数 1
作者 周雪芹
单位 山东理工大学
下面关于main方法声明正确的是( )。
A.public main(String args[ ])
B.public static void main(String args[ ])
C.private static void main(String args[ ])
D.void main()

分数 1
作者 刘生智
单位 新疆科技学院
下列选项中,哪一个是多行注释符号()

A.//**//
B.//
C.//
√  D./**/

分数 1
作者 刘凤良
单位 天津仁爱学院
以下( )字符串是 Java 中合法的标识符。
A.super
B.3number
C.#number
D.$number

分数 1
作者 刘凤良
单位 天津仁爱学院
属于 main() 方法的返回类型是()。
A.public
B.static
C.void
D.main

分数 1
作者 刘凤良
单位 天津仁爱学院
请问,为了使一个名为MyClass的public类成功编译,需要满足以下哪些条件?
A.MyClass必须定义一个正确的main()方法
B.MyClass必须定义在MyClass.java源文件中
C.MyClass必须定义在MyClass包中
D.MyClass类必须被导入

分数 1
作者 刘凤良
单位 天津仁爱学院
以下哪个标识符不是Java语言的合法用户标识符( )。
A._double
B.$123
C.Main
D.class

分数 1
作者 刘凤良
单位 天津仁爱学院
编译Java Application源程序文件将产生相应的字节码文件,这些字节码文件的扩展名是()。
A..java
B..class
C..html
D..exe

分数 1
作者 刘凤良
单位 天津仁爱学院
下面( )是 main()方法的合法参数。
A.char args[]
B.char args[][]
C.String args[]
D.String args

分数 1
作者 刘
单位 山东科技大学
下面概念中,不属于面向对象编程范畴的是( )。
A.对象
B.继承
C.类
D.过程调用

分数 1
作者 楼学庆
单位 浙江大学
Given the following code:

public class TestClass {
    public static void main(String args[]) {
        String str = new String("World");
        char[] ch = { 'H', 'e', 'l', 'l', 'o' };
        change(str, ch);
        System.out.println(str + " and " + new String(ch));
    }

    public static void change(String str, char ch[])
    {
            str="Changed"; ch[0]='C';
    }
}

What is the result after execution?
A.World and Hello
B.World and Cello
C.Changed and Hello
D.Changed and Cello

分数 1
作者 周雪芹
单位 山东理工大学
关于字符串的方法,如下代码执行结果是( )。

String fileName = "sdut@sdut.edu.cn"; 
System.out.println(fileName.lastIndexOf("."));

A.9
B.10
C.13
D.12

分数 1
作者 周雪芹
单位 山东理工大学
关于字符串的方法,如下代码执行结果是( )。

String fileName = "中国China"; 
System.out.println(fileName.indexOf("国"));

A.0
B.1
C.2
D.3

分数 1
作者 周雪芹
单位 山东理工大学
关于字符串的构造方法,如下代码执行结果是( )。

String str="ABCDEFG";
char[] chars=str.toCharArray(); 
System.out.println(new String(chars,1,3));

A.ABC
B.BCD
C.AB
D.BC

分数 1
作者 周雪芹
单位 山东理工大学
关于字符串的方法,如下代码执行结果是( )。

String str1 = "sdut@sdut.edu.cn";
String str2 = str1.toLowerCase();
System.out.println(str2);
System.out.println(str1);
System.out.println(str1 == str2);

A.
sdut@sdut.edu.cn
sdut@sdut.edu.cn
true

B.
sdut@sdut.edu.cn
sdut@sdut.edu.cn
false

C.
sdut@sdut.edu.cn
SDUT@SDUT.EDU.CN
true

D.
sdut@sdut.edu.cn
SDUT@SDUT.EDU.CN
false

分数 1
作者 周雪芹
单位 山东理工大学
关于字符串的方法,如下代码执行结果是( )。

String str1 = "abcd"; 
String str2="sdut";
System.out.println(str1.compareTo(str2)>0);

A.true
B.false
C.1
D.-1

分数 1
作者 周雪芹
单位 山东理工大学
关于字符串的方法,如下代码执行结果是( )。

String str1 = "sdut12"; 
String str2="sDut12";
System.out.println(str1.equalsIgnoreCase(str2));

A.true
B.false
C.0
D.1

分数 1
作者 周雪芹
单位 山东理工大学
关于字符串的方法,如下代码执行结果是( )。

String str = "    abcd123";
  str.toUpperCase();
  str.trim();
  System.out.println(str);

A. abcd123
B.abcd123
C. ABCD123
D.ABCD123

分数 1
作者 周雪芹
单位 山东理工大学
关于字符串的相关操作,如下代码执行后输出的结果是:( )。

String str1="abc";
String str2=str1.toUpperCase();
String str3=str1.toLowerCase();
System.out.println(str1==str2);
 System.out.println(str1==str3);

A.false
true
B.false
false
C.true
true
D.true
false

分数 1
作者 周雪芹
单位 山东理工大学
关于字符串对象的比较,==用于比较字符串对象的( )是否相同;equals()方法用于比较字符串对象的( )是否相同。
A.存储地址 字符序列
B.存储地址 存储地址
C.字符序列 存储地址
D.字符序列 字符序列

分数 1
作者 周雪芹
单位 山东理工大学
执行如下两行代码之后,则内存中存在几个字符串对象?( )

String str="abc"; 
str+="def";

A.1
B.2
C.3
D.4

分数 1
作者 楼学庆
单位 浙江大学
Given code below:

String s1 = "Hello";
String s2 = "Hell"+"o";
String s3 = "Hell";
s3 = s3+"o";

Which one below is correct?
A.s1 == s2 is true, s1 == s3 is true
B.s1 == s2 is true, s1 == s3 is false
C.s1 == s2 is false, s1 == s3 is false
D.s1 == s2 is false, s1 == s3 is true

分数 1
作者 周雪芹
单位 山东理工大学
阅读下面的程序段,以下表达式的值为true的是哪个?( )

String str1=new String("java");
        String str2=new String("java");
        StringBuffer str3=new StringBuffer("java");
        StringBuffer str4=new StringBuffer("java");

A.str1str2
B.str1.equals(str2)
C.str3
str4
D.str3.equals(str4)
E.str1==str3
F.str1.equals(str4)

分数 1
作者 周雪芹
单位 山东理工大学
对String类型的字符串 String str="abcdefg"; 调用str对象的( )方法,得到byte类型的数组[97, 98, 99, 100, 101, 102, 103]?
A.getBytes()
B.getChars()
C.toBytes()
D.toChars()

分数 1
作者 周雪芹
单位 山东理工大学
对String类型的字符串String str="abcd",调用str对象的( )方法,得到char类型的数组['a','b','c','d'] ?
A.toCharArray()
B.toChars()
C.getChars()
D.getBytes()

分数 1
作者 刘凤良
单位 天津仁爱学院
执行以下语句后,str2的值是( )。

String str1 = "abc";
String str2 = str1.concat("cde");

A.abcde
B.abccde
C.cdeabc
D.edccba

分数 1
作者 蒋辉
单位 天津仁爱学院
下列选项中,可以正确实现String初始化的是( )2分。
A.String str=abcd;
B.String str="hello";
C.String str=1234;
D.String str='good';

分数 1
作者 董卫萍
单位 绍兴文理学院元培学院
有如下程序代码, 程序运行的结果是( )。

String s1 = "中国";
String s2 = "我爱 " + s1;
String s3 = "我爱 " + s1;
System.out.print(s2 == s3);
System.out.println(" "+s2.equals(s3));

A.true false
B.true true
C.false false
D.false true

分数 1
作者 董卫萍
单位 绍兴文理学院元培学院
如下代码输出( )。

public class TestStringBuilder {
    public static void main(String[] args) {
        String s = "Hello";
        StringBuilder buffer = new StringBuilder(s);
        buffer.append(" World!");
        System.out.println(buffer);        
      }
}

A.Hello
B.World!
C.Hello World!
D.无输出

分数 1
作者 王从银
单位 吉首大学
以下代码段将创建几个对象?

String s1="bc";
String s2="bc";

A.2
B.3
C.0
D.1

分数 1
作者 翁恺
单位 浙江大学
Given code below:

String s1 = "Hello";
String s2 = "Hell"+"o";
String s3 = "Hell";
s3 = s3+"o";

Which one below is correct?
A.s1 == s2 is true, s1 == s3 is true
B.s1 == s2 is true, s1 == s3 is false
C.s1 == s2 is false, s1 == s3 is false
D.s1 == s2 is false, s1 == s3 is true

分数 1
作者 殷伟凤
单位 浙江传媒学院
请选择下面程序正确的输出结果( )

public class Main{
        public static void main(String args[ ]){
            String a = new String("A");
            String b = new String("B");
            mb_operate(a,b);
            System.out.println(a + "." + b);
}
static void mb_operate(String x,String y){
    x.concat(y);
    y=x;
}
}

A.A.B
B.A.A
C.AB.AB
D.AB.B

分数 1
作者 殷伟凤
单位 浙江传媒学院
如下程序输出( )

public class Test {  
  public static void main(String[] args) {
    String s = "Java";
    StringBuilder buffer = new StringBuilder(s);
    change(s);
    System.out.println(s);
  }
  
  private static void change(String s) {
    s = s + " and HTML";
  }
}

A.Java
B.Java and HTML
C.and HTML
D.什么都不显示

分数 1
作者 殷伟凤
单位 浙江传媒学院
关于以下程序段,正确的说法是( )。

1. String s1 = "abc"+"def";
2. String s2 = new String(s1);
3. if (s1==s2) {
4.    System.out.println("==succeeded");
5. }
6. if (s1.equals(s2)) {
7.    System.out.println(".equals() succeeded");
8. }

A.行4与行7都将执行
B.行4执行,行7不执行
C.行7执行,行4不执行
D.行4、行7都不执行

分数 1
作者 周雪芹
单位 山东理工大学
有如下程序代码, 程序运行的结果是( )。

String s1 = "sdut";
String s2 = "I love " + s1;
String s3 = "I love " + s1;
System.out.print(s2 == s3);
Sytem.out.println(" "+s2.equals(s3));

A.true false
B.true true
C.false false
D.false true

分数 1
作者 周雪芹
单位 山东理工大学
有如下代码,程序执行的结果是( )。

String str1 = "sdut@sdut.edu.cn";
String[] strings = str1.split("u");
System.out.println(Arrays.toString(strings));

A.sd, t@sd, t.ed, .cn
B.[sd, t@sd, t.ed, .cn]
C.[sdu, t@sdu, t.edu, .cn]
D.sdu, t@sdu, t.edu, .cn

分数 1
作者 周雪芹
单位 山东理工大学
有如下程序代码,程序执行的结果是( )。

String str1 = "\t sdut@sdut.edu.cn \t ";
System.out.println(str1.trim());

A.sdut@sdut.edu.cn
B.\tsdut@sdut.edu.cn
C.替换为正确项
D.替换为错误项

分数 1
作者 周雪芹
单位 山东理工大学
有如下程序代码,程序执行的结果是( )。

int i= 110; 
String str2=i+2+"lucky";
System.out.println(str2);

A.1102lucky
B.112lucky
C.lucky1102
D.lucky112

分数 1
作者 周雪芹
单位 山东理工大学
有如下代码,程序执行的结果是( )。

int i= 110;    
String str2="lucky"+i+2;    
System.out.println(str2);  

A.lucky1102
B.lucky112
C.1102lucky
D.112lucky

分数 1
作者 周雪芹
单位 山东理工大学
在下面的代码中,程序执行的结果将是:( )。

public class Test {
  public static void main(String[] args) {
         String str = "123";
         System.out.println(str);
         change(str);
         System.out.println(str);
     }
    public static void change(String str){
      str = "456";
    }
}

A.456
123
B.456
456
C.123
456
D.123
123

分数 1
作者 翁恺
单位 浙江大学
Which one below is NOT a valid Java identifier?
A.Int
B.goto
C.变量
D.$0

分数 1
作者 刘永福
单位 河北农业大学
在Java中,以下程序段的输出结果是。
222.png
A.1,2,3
B.2,3,4
C.2,2,3
D.2,3,3

分数 1
作者 刘永福
单位 河北农业大学
若有定义:int x=3,y=2;float a=2.5,b=4.5;则下面表达式的值为()。
(x+y)%2+(int)a/(int)b。
A.1.0
B.1
C.1.5
D.2

分数 1
作者 殷伟凤
单位 浙江传媒学院
下面那种类型不属于Java的基本数据类型?
A.byte
B.int
C.boolean
D.String

分数 1
作者 殷伟凤
单位 浙江传媒学院
假设有如下程序:

public class Demo {
        public static void main(String args[]) {
                int num = 68 ;
                char c = (char) num ;
                System.out.println(c) ;
        }
}

最终的执行结果是什么?
A.B
B.C
C.D
D.a

分数 1
作者 殷伟凤
单位 浙江传媒学院
以下语句输出的结果是?

String str="123";
 int x=4,y=5;
 str = str + (x + y);
 System.out.println(str);

A.1239
B.12345
C.会产生编译错误
D.123+4+5

分数 1
作者 殷伟凤
单位 浙江传媒学院
一个表达式中有int、byte、long、double型的数据相加,其结果是( )类型的值
A.int
B.long
C.byte
D.double

分数 1
作者 殷伟凤
单位 浙江传媒学院
45 / 4的结果是( )?
A.11
B.12
C.10
D.11.25

分数 1
作者 周雪芹
单位 山东理工大学
-1作为int数据类型出现,在内存中的存储形式是:( )。
A.11111111
B.11111111 11111111
C.11111111 11111111 11111111 11111111
D.11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111111

分数 1
作者 周雪芹
单位 山东理工大学
在JAVA中,按精度从小到大的顺序排列,各种基本数据类型自动转换的顺序是:( )。
A.byte-short(char)- int-long-float-double
B.byte-short(char)- int-float-long-double
C.byte-short- int(char)-long-float-double
D.byte(char)-short- int-long-float-double

分数 1
作者 周雪芹
单位 山东理工大学
下列( )是合法标识符。
A.rwkj@163
B.Java程序设计
C.8a
D.e-mail

分数 1
作者 周雪芹
单位 山东理工大学
下面哪些元素不能作为Java标识符的首字符?( )
A.字母
B.数字
C.下划线_
D.$

分数 1
作者 周雪芹
单位 山东理工大学
JAVA中,下面哪个赋值表达式正确:( )
A.float f=1.3;
B.char c="a";
C.byte b=257;
D.int i=10;

分数 1
作者 周雪芹
单位 山东理工大学
判断两个对象的引用是否相同,使用( )方式进行判断。
A.equals()
B.hashcode()
C.toString()
D.==

分数 1
作者 贾园园
单位 新疆科技学院
在控制台显示消息的语句正确的是( )
A.System.out.println(我是一个Java程序员了!);
B.System.Out.println("我是一个Java程序员了!");
C.System.out.println("我是一个Java程序员了!");
D.System.Out.Println("我是一个Java程序员了!");

分数 1
作者 贾园园
单位 新疆科技学院
下面选项中不是开发Java程序的步骤( )
A.编译
B.编写源代码
C.运行
D.发布

分数 1
作者 刘生智
单位 新疆科技学院
下列关于变量作用域的说法中,正确的是()
A.在main()方法中任何位置定义的变量,其作用域为整个main()方法。
B.代码块中定义的变量,在代码块外也是可以使用的。
C.变量的作用域为:从定义处开始,到变量所在代码块结束的位置。
D.变量的作用域不受代码块的限制。

分数 1
作者 刘生智
单位 新疆科技学院
以下标识符中,不合法的是( )
A.user
B.$inner
C.class
D.login_1

分数 1
作者 刘生智
单位 新疆科技学院
下列选项中,不属于Java中关键字的是()
A.if
B.float
C.Final
D.try

分数 1
作者 刘生智
单位 新疆科技学院
下列选项中,属于布尔常量的是()
A.198
B.2e3f
C.true
D.null

分数 1
作者 刘生智
单位 新疆科技学院
下列选项中,哪一个不能通过编译( )
A.byte a=1;
B.short b=100;
C.int c='a';
D.long d=8888888888888888;

分数 1
作者 刘生智
单位 新疆科技学院
下列浮点数的定义中,正确的是( )
A.float f = 1F;
B.float f = 1.0;
C.float f = '1';
D.float f = "1";

分数 1
作者 刘生智
单位 新疆科技学院
若int a = 7;a %= 2;则执行后,变量a的值是()
A.7
B.1
C.2
D.3

分数 1
作者 刘生智
单位 新疆科技学院
下列选项中,不属于比较运算符的是( )
A.=
B.==
C.<
D.<=

分数 1
作者 刘凤良
单位 天津仁爱学院
执行下列程序后,输出的正确结果是()。

public class Test {
    public static void main(String[] args) {
        System.out.print(100%3);
        System.out.print(",");
        System.out.println(100%3.0);
    }
}

A.1,1
B.1,1.0
C.1.0,1
D.1.0,1.0

分数 1
作者 刘凤良
单位 天津仁爱学院
假设有以下整型变量赋初值语句:int i=1+1/2+1/4;请问该语句执行后变量i的值为:
A.1
B.1.75
C.2.5
D.3

分数 1
作者 刘凤良
单位 天津仁爱学院
下面程序段:

boolean a = false;
boolean b = true;
boolean c = (a && b) && (!b);
boolean result = (a & b) & (!b);

执行完后,正确的结果是()。
A.c=false; result=false;
B.c=true; result=true;
C.c=true; result=false;
D.c=false; result=true;

分数 1
作者 刘凤良
单位 天津仁爱学院
已知有如下定义:String s = "story"; 下面( )表达式是合法的。
A.s += books;
B.char c = s[1];
C.int len = s.length;
D.String t = s.toLowerCase();

分数 1
作者 殷伟凤
单位 浙江传媒学院
下列选项中,合法的String型字符串常量是( )
A.'M'
B.How are you
C.'#apple'
D."apple"

分数 2
作者 王从银
单位 吉首大学
下面的方法,当输入为2的时候返回值是多少?( )

public int getValue(int i) {
         int result = 0;
         switch (i) {
            case 1:
                result = result + i;
            case 2:
                result = result + i * 2;
            case 3:
                result = result + i * 3;
        }
        return result;
 }

A.0
B.2
C.4
D.10

分数 2
作者 殷伟凤
单位 浙江传媒学院
在下面的代码段中,下列m的( )值将引起“default”的输出。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int m = input.nextInt();
        switch(m) {
            case 0: System.out.println("case 0");
            case 1: System.out.println("case 1");break;
            case 2:
            default:System.out.println("default");
        }
    }
}

A.0
B.1
C.2
D.以上答案都不正确

分数 2
作者 殷伟凤
单位 浙江传媒学院
下列语句序列执行后,k 的值是( )

int x=6, y=10, k=5;
switch( x%y ){ 
        case 0: k=x*y;
      case 6: k=x/y;
      case 12: k=x-y;
      default: k=x*y-x;
}

A.60
B.5
C.0
D.54

分数 2
作者 王从银
单位 吉首大学
以下选项中没有语法错误的是( ) 。
A.
while (int i<7) {
i++;
System.out.println(“i is “+i);
}
B.
int j=3; while(j) {
System.out.println(“ j is “+j);
}
C.
int j=0;
for(int k=0; j + k !=10; j++,k++) {
System.out.println(“ j is “+ j + “k is”+ k);
}
D.
int j=0;
do{
System.out.println( “j is “+j++);
if (j == 3) {
continue loop;
}
}while (j<10);

分数 2
作者 gwl
单位 许昌学院
在JAVA中,给定代码片段如下所示,则编译运行后,输出结果是()。

for (int i = 0; i < 10; i++) {
    if (i == 10 - i) {
        break;
    }

    if (i % 3 != 0) {
        continue;
    }
    System.out.print(i + " ");
}

A.0
B.0 3
C.0 3 6
D.0 3 6 9

分数 2
作者 殷伟凤
单位 浙江传媒学院
下面代码将输出( )行 "Welcome to Java"?。

int count = 0;
do {
     System.out.println("Welcome to Java");
} while (count++ < 10);

A.10
B.11
C.9
D.1

分数 2
作者 李妙妍
单位 沈阳师范大学
分析下列代码的运行结果是什么?

void looper(){

    int x=0;
    one:
    while(x<20) {
        two:
            System.out.print(++x);
            if(x>3)
              break two;
    }
}

A.编译错误
B.0
C.1
D.2

分数 2
作者 李妙妍
单位 沈阳师范大学
当编译并运行下列程序段时,运行结果是什么?

public class Test {

    public static void main(String[ ] args) {
        int i=0;
        while (i--<0){
             System.out.println("The value of i is "+i);
         }
         System.out.println("The end");
     }
}

A.编译时错误
B.运行时错误
C.The end
D.The value of i is 0

分数 2
作者 李妙妍
单位 沈阳师范大学
下列选项中不属于本段代码输出结果的是( )

public class Main{
    public static void main(String args[]) {
      one:
      two:
      for(int i=0; i<3; i++) {
          three:
          for(int j=10; j<30; j+=10) {
             System.out.println(i+j);
             if(i>0)
                break one;
          }
      }
    }
}

A.10
B.20
C.11
D.21

分数 2
作者 周雪芹
单位 山东理工大学
关于类和对象的关系,下列说法哪种说法是错误的?
A.类和对象都是具体的。
B.类是抽象的,对象是具体的。
C.一般情况下,在定义类之后,能创建无数个对象,可以说,类能化身千万。
D.类是引用型数据类型。

分数 2
作者 郑如滨
单位 集美大学
关于下面的类描述中正确的是:

class Test{
    void test(int i){
        System.out.println("I am an int.");
    }
    void test(String s){
        System.out.println("I am a char");
    }
    public static void main(String args[]){
        Test t=new Test();
        t.test('a');
    }
}

A.编译出错
B.编译通过,运行出错
C.编译通过,运行时输出“I am an int”
D.编译通过,运行时输出“I am a char"

分数 2
作者 周雪芹
单位 山东理工大学
关于构造方法定义与作用,下列说法错误的是:( )。
A.用来创建类的实例时调用的方法
B.调用该方法时,对实例变量赋值
C.定义时,方法名称与类名相同,返回值类型可以不写,也可以写成void
D.一个类的构造方法可以定义多个,多个构造方法的参数有明显区别。

分数 2
作者 周雪芹
单位 山东理工大学
以下有关构造方法的说法,正确的是: ____。
A.一个类的构造方法可以有多个
B.构造方法在类定义时被调用
C.构造方法只能由对象的其它方法调用
D.构造方法可以和类同名,也可以和类名不同

分数 2
作者 周雪芹
单位 山东理工大学
关于以下代码的说明,正确的是( )。

class Main {
    static int x = 10;
    static {
        x += 5;
        System.out.println("x=" + x);
    }
    public static void main(String args[ ])
    {
        System.out.println("x=" + x);
    }
    static {
        x /= 3;
        System.out.println("x=" + x);
    }
}

A.不能通过编译,因为缺少方法名和返回类型
B.不能通过编译,因为只能有一个静态初始化器
C.编译通过,执行结果为:
x=15
x=5
x=5
D.编译通过,执行结果为:
x=3
x=8
x=8

分数 2
作者 周雪芹
单位 山东理工大学
在Java中,针对类和成员提供了4种访问级别,以下控制级别由小到大的顺序是:( )。
A.private< 默认 < protected < public
B.默认 < private< protected < public
C.protected < 默认 < private < public
D.protected < private< 默认 < public

分数 2
作者 周雪芹
单位 山东理工大学
在成员方法的访问控制修饰符中,规定访问权限只包含该类自身作用域和同包作用域的修饰符是( )。
A.protected
B.public
C.默认
D.private

分数 2
作者 周雪芹
单位 山东理工大学
下列关于修饰符使用的说法,错误的是( )。
A.abstract不能与final并列修饰同一个类
B.abstract类中可以有private的成员
C.abstract方法必须在abstract类中
D.static方法中能访问非static的属性

分数 2
作者 周雪芹
单位 山东理工大学
在非静态成员方法中,可以使用关键字( )指代当前对象,访问类的其他非静态成员。
A.this
B.super
C.static
D.public

分数 2
作者 周雪芹
单位 山东理工大学
有如下程序代码,哪处出现编译错误?( )

class Father {
 int a = 100;    // A
 final public void print() { // B
  System.out.println(a);
 }
}
class Child extends Father { 
 int a = 200;                // C
 public void print() {       // D
  System.out.println(a);  
 }
}

A.A处
B.B处
C.C处
D.D处

分数 2
作者 殷伟凤
单位 浙江传媒学院
执行完以下代码int[ ] x = new int[25];后,以下哪项说明是正确的( )
A.x[24]为0
B.x[24]未定义
C.x[25]为0
D.x[0]没有数值存在

分数 2
作者 周雪芹
单位 山东理工大学
下列程序代码运行结果是:( )。

import java.util.*;    
public class Test {     
    public int hashCode() {        
         return 1;     
    }     
    public boolean equals(Object b) {        
        return true;    
   }    
    public static void main(String args[]) {        
        Set set = new HashSet();        
        set.add(new Test());        
        set.add(new String("ABC"));        
        set.add(new Test());        
        System.out.println(set.size());     
    }
}

A.1
B.2
C.3
D.4

分数 2
作者 周雪芹
单位 山东理工大学
若int a[][]={{123,345,334},{1,2},{3,4}}; 则 a[2][1]=( )。
A.1
B.3
C.2
D.4

分数 2
作者 周雪芹
单位 山东理工大学
如下语句执行结果是:( )。

int[] intArr=new int[10];
System.out.println(intArr[0]);

A.编译错误
B.会报运行错误
C.0
D.null

分数 2
作者 周雪芹
单位 山东理工大学
如下语句执行结果是:( )。

int[] intArr=new int[10];    
System.out.println(intArr[10]);    

A.编译错误
B.会报运行错误
C.0
D.null

分数 2
作者 周雪芹
单位 山东理工大学
设有数组的定义int[] a = new int[3],则下面对数组元素的引用错误的是( )。
A.a[0]=8;
B.a[a.length-1]=90;
C.a[3]=9;
D.int i=1;
a[i]=0;

分数 2
作者 周雪芹
单位 山东理工大学
数组的定义为:int[] arr=new int[10];
如何获得数组的长度?
A.arr.length()
B.arr.size()
C.arr.length
D.arr.size

分数 2
作者 周雪芹
单位 山东理工大学
执行完以下代码int[ ] x = new int[25];后,以下哪项说明是正确的( )。
A.x[24]为0
B.x[25]为0
C.x[0]为空
D.x[24]未定义

分数 2
作者 周雪芹
单位 山东理工大学
下列程序代码运行结果是:( )。

import java.util.ArrayList;
    import java.util.List;
public class Test {
     public static void main(String args[]) {
        List list = new ArrayList();
        list.add(new Test());
        list.add(new String(""ABC""));
        list.add(new Test());
        System.out.println(list.size());
     }
    }

A.1
B.2
C.3
D.4

分数 2
作者 周雪芹
单位 山东理工大学
欲构造ArrayList类的一个实例,此类实现了List接口,下列哪个写法是正确的 ?
A.ArrayList myList=new Object();
B.List myList=new ArrayList();
C.ArrayList myList=new List();
D.List myList=new List();

分数 1
作者 周雪芹
单位 山东理工大学
有如下程序代码:

class Dog{ }
class Cat { }
public class Test{
 public static void main(String[] args) {
  Dog dog=new Dog();
  Cat cat=new Cat();
  System.out.println(cat instanceof Dog);    //A
  System.out.println(dog instanceof Dog);   //B
 }  
 }

关于A、B两段代码,下列哪种说法是正确的?( )
A.输出:
false
true
B.输出:
true
true
C.输出:
false
false
D.出现语法编译错误,程序不能执行

分数 1
作者 周雪芹
单位 山东理工大学
有如下程序代码,执行的结果是( )。

class Father {
    int a = 100;
    int b = 200;

    public void print() {
        System.out.println(a + " " + b);
    }
}

class Child extends Father {
    int b = 300;
    int c = 400;

    public void print() {
        System.out.println(a + " " + b + " " + c);
    }

    public void printExtend() {
        System.out.println(c);
    }

}

public class Main {
    public static void main(String[] a) {
          Father obj=new Child();
          System.out.println(obj.a+" "+obj.b);   
          obj.print();  
    }
}

A.
100 200
100 200 400
B.
100 300
100 300 400
C.
100 300
100 200 400
D.
100 200
100 300 400

分数 1
作者 周雪芹
单位 山东理工大学
有如下父类、子类及测试类的定义,程序执行结果是:( )。

class Father {
 int a =100;
 public void print() {
  System.out.println(a);
 }
}
class Child1 extends Father {
 int a =200;
 public void print() {
  System.out.println(a);
 }
}
class Child2 extends Father {
 int a =300;
 public void print() {
  System.out.println(a);
 }
}
public class Main {
    public static void main(String[] a) {
        Father obj1;
          obj1=new Child1();
          System.out.println(obj1.a);
          obj1.print(); 
          
          obj1=new Child2();
          System.out.println(obj1.a);
          obj1.print(); 
    }
}

A.
200
200
300
300
B.
100
200
300
300
C.
200
200
100
300
D.
100
200
100
300

分数 1
作者 周雪芹
单位 山东理工大学
有如下代码,程序执行结果是:( )。

abstract class Person {
 public abstract void eat();
}
public class Main {
    public static void main(String[] a) {

          Person p = new Person() {
           public void eat() {
            System.out.println("eat something");
           }
          };
          p.eat();
    }
}

A.空字符串
B.编译错误
C.eat something
D.运行错误

分数 1
作者 周雪芹
单位 山东理工大学
有如下代码,程序的执行结果是( )。

interface Person {
 public void eat();
}

public class Main {
    public static void main(String[] a) {

          Person p = new Person() {
           public void eat() {
            System.out.println("eat something");
           }
          };
          p.eat();
    }
}

A.空字符串
B.编译错误
C.eat something
D.运行时错误

分数 1
作者 周雪芹
单位 山东理工大学
下面关于JAVA面向对象的理解,说法中不正确的是:( )。
A.Java中,一个类只允许实现一个接口
B.抽象类中允许有非抽象方法的存在
C.静态的成员变量可以直接用类名调用
D.通过super可以调用父类的构造函数

分数 1
作者 周雪芹
单位 山东理工大学
以下关于继承的叙述正确的是( )。
A.在Java中类只允许单一继承
B.在Java中,一个类只能实现一个接口
C.在Java中,一个类不能同时继承一个类和实现一个接口
D.在Java中,接口也具有单继承性

分数 1
作者 郑如滨
单位 集美大学
以下对接口描述错误的有
A.接口没有提供构造方法
B.接口中的方法默认使用public、abstract修饰
C.接口中的属性默认使用public、static、final修饰
D.接口不允许多继承

分数 1
作者 郑如滨
单位 集美大学
以下描述错误的有
A.abstract 可以修饰类、接口、方法
B.abstract修饰的类主要用于被继承
C.abstract 可以修饰变量
D.abstract修饰的类,其子类也可以是abstract修饰的

分数 1
作者 郑如滨
单位 集美大学
下列选项中关于java中super关键字的说法错误的是
A.super关键字是在子类对象内部指代其父类对象的引用
B.super关键字不仅可以指代子类的直接父类,还可以指代父类的父类
C.子类可以通过super关键字调用父类的方法
D.子类可以通过super关键字调用父类的属性

分数 1
作者 周雪芹
单位 山东理工大学
已知类的继承关系如下:
class Employee{}
class Manager extends Employee{}
class Director extends Employee{}
则下列语句通过编译的有哪些?( )
A.Employee e=new Manager();
B.Director d= new Manager();
C.Director d= new Employee();
D.Manager m=new Director();

分数 1
作者 周雪芹
单位 山东理工大学
在Java中,要想让一个类继承另一个类,可以使用以下哪个关键字?( )
A.inherits
B.implements
C.extends
D.modifies

分数 1
作者 周雪芹
单位 山东理工大学
如下代码,程序的输出结果将是:( )。

class A {
    int a = 11;
    int b = 12;

    public void print() {
        System.out.println(a + " " + b);
    }
}

class B extends A {
    int a = 20;

    public void print() {
        System.out.println(a + " " + b);
    }
}

public class Main {
    public static void main(String[] args) {
        A aObj = new A();
        aObj.print();
        B bObj = new B();
        bObj.print();
    }
}

A.11 12
20 0
B.20 12
20 12
C.11 12
11 12
D.11 12
20 12

分数 1
作者 孙晨霞
单位 河北农业大学
关于抽象类,下面叙述错误的是() 。
A.包含抽象方法的类必须是抽象类
B.抽象方法只需要声明,不需要实现
C.抽象类可以实例化
D.抽象类中可以没有抽象方法

分数 1
作者 孙晨霞
单位 河北农业大学
关于接口的声明,错误的是( ) 。
A.接口中所有的成员属性都是public static final修订的常量
B.接口中的成员属性在声明时可以省略修订关键字
C.接口中所有的方法都是public abstract final修订的
D.接口中所有的方法都是public abstract修订的

分数 1
作者 孙晨霞
单位 河北农业大学
关于接口,下面的叙述错误的是()。
A.一个接口可以多继承多个接口
B.一个类可以实现多个接口
C.抽象类在实现接口时,可以不实现该接口中声明的所有方法
D.抽象类在实现接口时,必须实现该接口中声明的所有方法

分数 1
作者 郑如滨
单位 集美大学
以下代码运行输出是。

public class Person{
    private String name=”Person”;
    int age=0;
}
public class Child extends Person{
    public String grade;

    public static void main(String[] args){
        Person p = new Child();
        System.out.println(p.name);
    }
}

A.输出:Person
B.没有输出
C.编译出错
D.运行出错

分数 1
作者 郑如滨
单位 集美大学
在使用super 和this关键字时,以下描述正确的是
A.在子类构造方法中使用super()显示调用父类的构造方法,super()必须写在子类构造方法的第一行,否则编译不通过
B.this()和super()可以同时出现在一个构造函数中
C.super()和this()不一定要放在构造方法内第一行
D.this()和super()可以在static环境中使用,包括static方法和static语句块

分数 1
作者 郑如滨
单位 集美大学
以下对抽象类的描述正确的是
A.抽象类没有构造方法
B.抽象类必须提供抽象方法
C.有抽象方法的类一定是抽象类
D.抽象类可以通过new关键字直接实例化

分数 1
作者 刘永福
单位 河北农业大学
在Java中,以下()类的对象是以键-值的方式存储对象。
A.List
B.ArrayList
C.HashMap
D.LinkedList

分数 2
作者 殷伟凤
单位 浙江传媒学院
下面关于try块的说法正确的是?
A.try块后至少应有一个catch 块
B.try块后必须有finally块
C.可能抛出异常的语句应放在try块中
D.对抛出的异常的处理应放在try块中

分数 2
作者 殷伟凤
单位 浙江传媒学院
Java异常类(Exception)是( )的子类。
A.RuntimeException
B.Exception
C.Error
D.Throwable

分数 2
作者 殷伟凤
单位 浙江传媒学院
下列程序的运行结果是( )。

public class Test {
  public static void main(String[] args) {
    try {
      System.out.println("Welcome to Java");
      int i = 0;
      int y = 2 / i;
      System.out.println("Welcome to HTML");
    }
    finally {
      System.out.println("The finally clause is executed");
    }
  }
}

A.Welcome to Java, 然后是错误信息
B.Welcome to Java,下一行是 The finally clause is executed , 然后是错误信息.
C.替换为正确项
D.替换为错误项

分数 2
作者 李妙妍
单位 沈阳师范大学
给定一个未完成的方法 ,代码如下:

//此处添加方法的声明
{
   int success=connect();
   if(success==-1)
      throw new TimedOutException();
}

已知TimedOutException不属于RuntimeException,那么在第一行注释位置上填写哪段代码能够正确完成该方法的声明?
A.public void MyMethod()
B.public void MyMethod() throws TimedOutException
C.public void MyMethod() throw TimeOutException
D.public throws TimedOutException void MyMethod()

分数 2
作者 李妙妍
单位 沈阳师范大学
已知方法test()定义如下,在方法unsafe()运行正常的情况下哪条语句将肯定不会被输出?

public void test( ){
try {
   unsafe();
   System.out.println("Test 4");
} catch(SafeException e) {
   System.out.println("Test 3");
}finally{
   System.out.println("Test 2"); 
}
   System.out.println("Test 1"); 
}

A.Test 4
B.Test 3
C.Test 2
D.Test 1

分数 2
作者 李妙妍
单位 沈阳师范大学
已知下列代码,如果方法oneMethod()运行异常,则下列哪个语句肯定不会被输出?

public void example(){
   try {
   oneMethod();
   System.out.println("condition1");
}catch(ArrayIndexOutOfBoundsException e) {
   System.out.println("condition2");
}catch(Exception e) {
   System.out.println("condition3");
}finally{
   System.out.println("condition4"); 
}

A.condition1
B.condition2
C.condition3
D.condition4

分数 2
作者 周雪芹
单位 山东理工大学
下面程序在fun( )方法当出现数组下标超过界限的情况下,被ArrayIndexOutOfBoundsException类型的异常对象e所捕获。程序输出结果是:( )。

public void test() {
    try {
       fun();
       System.out.print("情况1");
     } catch (ArrayIndexOutOfBoundsException e) {
         System.out.print("情况2");
     } catch (Exception e) {
          System.out.print("情况3");
     } finally {
         System.out.print("finally");
     }
 }

A.情况1
B.情况2
C.情况2finally
D.情况3finally

分数 2
作者 周雪芹
单位 山东理工大学
程序代码中包含产生CheckedException受检异常(非运行时异常)的语句时,( )。
A.如果程序错误,就使用try-catch语句处理异常;否则,不必处理
B.必须进行处理,或使用try-catch语句处理异常,或在调用方法上使用throws将其抛出
C.只能使用try-catch语句处理
D.可以置之不理

分数 2
作者 周雪芹
单位 山东理工大学
关于Java中异常的叙述,正确的是:( )。
A.异常是程序编写过程中代码的语法错误
B.异常是程序编写过程中代码的逻辑错误
C.异常出现后程序的运行马上中止
D.异常是可以捕获和处理的

分数 2
作者 周雪芹
单位 山东理工大学
关于异常,下列说法正确的是 ( )。
A.程序运行过程中,若产生异常,它是某种异常类型的对象
B.一旦程序运行,异常对象将被创建
C.为了保证程序运行速度,要尽量避免异常控制
D.以上说法都不对

分数 2
作者 周雪芹
单位 山东理工大学
Java中用来抛出异常的关键字是:( )。
A.try
B.catch
C.throw和throws
D.finally

分数 2
作者 周雪芹
单位 山东理工大学
在异常处理时,将可能发生异常的代码放在( )语句块中,后面紧跟着一个或多个( )语句块,还可以再跟零个或一个( )语句块。
A.catch、try、finally
B.try、catch、finally
C.try、finally、exception
D.exception、try、finally

分数 2
作者 周雪芹
单位 山东理工大学
关于try语句对应的多个catch子句中,若捕获的异常类型有父子类关系时,它们的排列下列哪种是正确的( ) 。
A.异常父类在先,异常子类在后
B.异常子类在先,异常父类在后
C.有继承关系的异常不能同时出现在同一个try程序段之后
D.先后顺序无所谓

分数 2
作者 周雪芹
单位 山东理工大学
在异常处理中,如释放资源、关闭文件、关闭数据库等由( )来完成。
A.try子句
B.catch子句
C.finally子句
D.throw子句

分数 2
作者 郑如滨
单位 集美大学
以下描述不正确的有
A.try块不可以省略
B.可以使用多重catch块
C.finally块可以省略
D.catch块和finally块可以同时省略

分数 2
作者 郑如滨
单位 集美大学
以下对自定义异常描述正确的是
A.自定义异常必须继承Exception
B.自定义异常可以继承自Error
C.自定义异常可以更加明确定位异常出错的位置和给出详细出错信息
D.程序中已经提供了丰富的异常类,使用自定义异常没有意义

分数 2
作者 张德慧
单位 西安邮电大学
下列哪一项不属于布局管理器? ( )
A.GridLayout
B.CardLayout
C.BorderLayout
D.BagLayout

分数 2
作者 张德慧
单位 西安邮电大学
声明并创建一个按钮对象b,应该使用的语句是( )
A.Button b=new Button( );
B.button b=new button( );
C.Button b=new b( );
D.b.setLabel(“确定”);

{/collapse-item}
{collapse-item label="多选题"}
一个Java源文件中可以有( )个公共类?
A.0
B.1
C.2
D.不受限制

分数 3
作者 周雪芹
单位 山东理工大学
在Java中,关于数据的标准输出System.out,哪些说法是正确的?
A.调用print、println都可以输出各种数据类型的数据,二者没有什么差别
B.兼容C语言中的printf方法,可以按指定格式的字符串形式输出数据
C.如果不进行输出重定向,标准输出意味着输出到屏幕上
D.System.out.println(); 可以输出一个空行

分数 3
作者 周雪芹
单位 山东理工大学
关于Java中的注释,哪些说法是正确的? ABCD
A.单行注释形式为://****
B.多行注释形式为:
/*


*/

C.文档注释形式为:
/**


*/
D.注释的作用是增加程序的可读性。

分数 3
作者 周雪芹
单位 山东理工大学
以下选项中,哪些属于JDK工具?
A.Java编译器
B.Java运行工具
C.Java文档生成工具
D.Java打包工具

分数 3
作者 周雪芹
单位 山东理工大学
JAVA中的注释有几种? ABC
A.//单行注释
B./*
多行注释
*/

C./**
文档注释
*/

D./**
多行注释
**/

分数 3
作者 周雪芹
单位 山东理工大学
关于JDK、JRE、JVM的含义及其关系,下列哪种说法是正确的?
A.JDK就是Java Development Kit,Java开发工具,它包含JRE。
B.JRE就是Java runtime environment,即:Java运行环境,包括:JVM、类库以及其他环境
C.JVM 就是Java virtual machine,即:Java虚拟机,是由软代码组成的一个模拟的计算机,负责程序的执行
D.Java是编译型语言

分数 4
作者 马俊
单位 兰州大学
下面Java语句错误的有?
A.Float a=1.0;
B.double a=1.0;
C.out.println("hello");
D.DatagramSocket a = new DatagramSocket();

分数 2
作者 马俊
单位 兰州大学
Java语言中,下列有关使用String类的语句中哪几项是正确的?
A.String s[]={"Zero","One","Two","Three","Four"};
B.String s[5]=new String[]{"Zero","One","Two","Three","Four"};
C.String s[]=new String[]{"Zero","One","Two","Three","Four"};
D.String s[]=new String(){"Zero","One","Two","Three","Four"};

分数 2
作者 周雪芹
单位 山东理工大学
String类对象的创建方式包括:( )。
A.String str1="imooc";
B.String str2=new String();
C.String str3=new String("imooc");
D.String str4="abc"+"123";
E.String str5=str1.toUpperCase();

分数 2
作者 刘凤良
单位 天津仁爱学院
下面的哪些Java程序片断可能导致错误。
A.String s = "Gone with the wind";
String t = " good ";
String k = s + t;
B.String s = "Gone with the wind";
String t;
t = s[3] + "one";
C.String s = "Gone with the wind";
String standard = s.toUpperCase();
D.String s = "home directory";
String t = s - "directory";

分数 2
作者 周雪芹
单位 山东理工大学
Java中的数据类型可以分为两大类,分别是:( )和( )。
A.基本数据类型
B.整数类型
C.浮点类型
D.引用型数据类型

分数 2
作者 周雪芹
单位 山东理工大学
关于String与char类型,下列哪种赋值合法?
A.String str='1';
B.char ch1="a";
C.char ch2="abc".charAt(0);
D.String str1="a";

分数 2
作者 周雪芹
单位 山东理工大学
Java中,以下表达式说法正确的是:( )。
A.int a=20;a++;
a的值是21。
B.int a=20;int b=a++;
b的值是21。
C.int a=20;int b=++a;
b的值是21。
D.int a=3++;
a的值是3。

分数 2
作者 马俊
单位 兰州大学
在Java中,下列赋值语句哪些是正确的:
A.byte b=340;
B.Boolean b=1;
C.long l=-2;
D.double d=0.9239d;

分数 2
作者 周雪芹
单位 山东理工大学
下列赋值哪项赋值是不正确的?
A.float f=12.34;
B.byte b=23;
C.float f1=100;
D.long l=23.3;
E.float f2=100L;
F.char ch=100;

分数 2
作者 周雪芹
单位 山东理工大学
switch-case语句与if语句相比,说法正确的是:
A.所有switch-case语句都可以用if语句进行改写
B.所有if语句都可以用switch-case语句进行改写
C.switch-case语句用于等值判断
D.if语句可用于等值判断,也可用于区间判断,有时要用结构比较复杂的嵌套

分数 2
作者 周雪芹
单位 山东理工大学
在Java语言的if结构中,是否执行该分支结构的判断条件表达式的运算结果可能是:( )。
A.0
B.1
C.true
D.false

分数 2
作者 周雪芹
单位 山东理工大学
下面关于Java中的if结构形式,哪些是合法的? ABCD
A.if( )
{ }
B.if( )
{ }
else
{ }
C.if( )
{ }
else if( )
{ }
else if( )
{ }
D.if( )
{ }
else if( )
{ }
else if( )
{ }
else
{ }
分数 2
作者 周雪芹
单位 山东理工大学
有如下TestA类的定义:

public class TestA {
static int a=10;
}
用该类创建2个对象:testA1和testA2,现将类变量(静态变量)a的数值变为100,则正确的方式是:( )。
A.TestA.a=100;
B.testA1.a=100;
C.testA2.a=100;
D.以上都不对

分数 2
作者 周雪芹
单位 山东理工大学
下面关于构造方法的描述,正确的有哪些?( ) (2.0分)
A.方法名必须和类名相同
B.在方法中不能return语句返回一个值

C.方法名的前面有返回值类型的声明
D.当定义了带参数的构造方法,系统默认的不带参数的构造方法依然存在

分数 2
作者 周雪芹
单位 山东理工大学
下面关于变量及其作用域范围的陈述哪些是正确的( )。
A.实例变量是类的成员变量
B.实例变量用关键字static声明
C.在方法中定义的局部变量,在该方法被执行时创建
D.局部变量在使用前必须被初始化

分数 2
作者 周雪芹
单位 山东理工大学
若在cn.sdut包中有A、B类,在cn.sdut.cs包中有C、D类,在default package中如果要使用到A、B、C、D 4个类时,引入方式为:( )。
A.import cn.sdut.A;
import cn.sdut.B;
import cn.sdut.cs.C;
import cn.sdut.cs.D;
B.import cn.sdut.*;

C.import cn.sdut.*;
import cn.sdut.cs.*;

D.import cn.sdut.cs.*;
分数 2
作者 周雪芹
单位 山东理工大学
类中哪些访问权限修饰的成员,在子类访问时不受限制?( )
A.private
B.默认
C.protected
D.public

分数 2
作者 周雪芹
单位 山东理工大学
Java中的数组在声明并分配了空间之后,关于其数组元素,哪些说法是正确的?( )
A.数组元素未人为赋值之前不能进行访问
B.数组元素都有默认值
C.基本数据类型中数值类型数组,元素默认值为0;布尔类型数组,元素默认值为false。
D.引用数据类型的数组,其数组元素默认值为null

分数 2
作者 周雪芹
单位 山东理工大学
List类型的对象list可以以几种形式输出其内容( )? ABCD
A.System.out.println(list.toString());
B.for (int i = 0; i < list.size(); i++)
{
System.out.println(list.get(i));
}
C.for (Object obj : list)
{
System.out.println(obj);
}
D.Iterator it = list.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}

分数 2
作者 周雪芹
单位 山东理工大学
迭代器接口(Iterator)所定义的方法有( )。
A.hasNext()
B.next()
C.remove()
D.nextElement()

分数 2
作者 周雪芹
单位 山东理工大学
对于Set类型的对象set,可以以几种形式输出其内容( )? ACD
A.System.out.println(set.toString());
B.for (int i = 0; i < set.size(); i++)
{
System.out.println(set.get(i));
}
C.for (Object obj : set)
{
System.out.println(obj);
}
D.Iterator it = set.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}

分数 2
作者 周雪芹
单位 山东理工大学
在JAVA集合框架中,下面哪些类型所表示的对象是有序的?( )
A.HashMap
B.HashSet
C.TreeMap
D.LinkedList
E.LinkedHashMap

分数 2
作者 郑如滨
单位 集美大学
接口和抽象类描述正确的有
A.抽象类没有构造函数
B.接口没有构造函数
C.抽象类不允许多继承
D.接口中的方法可以有方法体

分数 2
作者 周雪芹
单位 山东理工大学
接口中定义常量(变量)时,默认含有哪些修饰符?( )
A.public
B.static
C.final
D.void

分数 2
作者 周雪芹
单位 山东理工大学
在Java中,利用java.util.Scanner类输入数据,哪些说法是T的?
A.利用该类对象调用nextXxxxx()方法来输入相应数据类型的数据
B.利用该类对象调用next()和nextLine()方法均可输入字符串,二者功能无差别
C.该类构造方法接收一个参数,表示数据的来源
D.Scanner类位于java.util包中。

分数 2
作者 周雪芹
单位 山东理工大学
关于封装类Float,下列说法正确的是( )。
A.Float在java.lang包中
B.Float a=1.0; 是正确的赋值方法
C.Float是一个类
D.Float a= new Float(1.0); 是正确的赋值方法

分数 2
作者 周雪芹
单位 山东理工大学
下列哪些方法属于java.lang.Math类( )?
A.random()
B.sqrt()
C.abs()
D.pow()
E.exp()
F.ceil()
G.floor()

分数 2
作者 周雪芹
单位 山东理工大学
关于基本类型的封装类,下列说法正确的是:( )。
A.每种基本数据类型都有对应的封装类类型
B.封装类对于其基本数据类型,好处是可以提供丰富的信息和更丰富的功能
C.从基本数据类型到封装类类型不能自动转换
D.从封装类类型到基本数据类型能自动转换,称为自动拆箱

分数 2
作者 周雪芹
单位 山东理工大学
Java中,关于自动装箱、自动拆箱、封装类,说法正确的是:( )
A.把基本变量赋值给一个类类型的变量,叫做自动装箱
B.把封装类的变量,赋值给基本数据类型,叫做自动拆箱。
C.封装类不仅仅可以包含这种类型的数值,还可以提供更多的功能和更多的信息。
D.自动装箱和自动拆箱是从jdk 1.0开始的。

分数 2
作者 周雪芹
单位 山东理工大学
JAVA中如何将基本数据类型的数据转换成字符串? 以整型数据为例,现有一个整数: int i=100; 下面哪种方式能够得到字符串“123”?
A.String str1=i+"";
B.String str2=String.valueOf(i);
C.String str3=Integer.toString(i);
D.String str4=String.format("%d", i);

分数 2
作者 周雪芹
单位 山东理工大学
在程序中利用throw或throws抛出异常,下列说法正确的是:( )。
A.throw代表动作,表示抛出一个异常的动作;throws代表一种状态,代表方法可能有异常抛出
B.throw用在方法实现中,而throws用在方法声明中
C.throw只能用于抛出一种异常,而throws可以抛出多个异常
D.当调用抛出异常的方法时,需要进行捕获处理或者继续利用thows向上抛出。

分数 2
作者 周雪芹
单位 山东理工大学
这是一个多选题的样例。答案为AC,分值为2分。
A.异常是程序中出现的不正常情况,而不是指Java虚拟机本身比较严重的错误。
B.程序中出现异常不进行处理,则程序中断执行。
C.Java程序利用try-catch或者try-catch-finally结构处理异常。
D.Java程序利用throw和throws来处理异常。

分数 2
作者 周雪芹
单位 山东理工大学
关于Java异常的处理的catch语句块,哪些说法是正确的?( )
A.catch语句块可以有一个,也可以有多个
B.多个catch语句块所捕获的异常类型如果有父子类关系,则父类在前,子类在后
C.多个catch语句块可能有0个或1个执行到
D.catch语句块必须和try语句块配合使用,不能独立存在

分数 2
作者 周雪芹
单位 山东理工大学
关于Java异常的处理的finally语句块,哪些说法是正确的?( )
A.finally语句块可有可无。
B.如果finally语句块存在,它一定会执行。
C.finally语句块通常用于一些收尾性的工作,如数据库断开连接、关闭系统资源等等。
D.finally语句块必须和try-catch结构一起配合来进行处理异常

分数 2
作者 周雪芹
单位 山东理工大学
利用命令:java MultiCatch 执行下面的程序,说法错误的是 ( )。

public class MultiCatch
    {
          public static void main(String args[])
         {
               try
               {
                   int a=args.length;
                   int b=42/a;
                   int c[]={1};
                   c[42]=99;     //第10行
                   System.out.println(“b=”+b);
                }
               catch(ArithmeticException e)
               {
                     System.out.println(“除0异常:”+e);       //第15行
               }
               catch(ArrayIndexOutOfBoundsException e) {
                    System.out.println(“数组超越边界异常:”+e);     //第18行
               }
         }
    }

A.程序将输出第15行的异常信息
B.程序第10行出错
C.程序将输出b=42
D.程序将输出第15和18行的异常信息

{collapse-item label="编程题"}

Hello Java

定义一个名字为Main的类,在屏幕上输出以下信息:

Hello Java!

Programming is fun!

输入格式:
本题不需要输入。

输出格式:
分两行输出,注意本题的标点符号为英文格式。

输入样例:
本题不需要输入。

public class Main {
	public static void main(String[] args) {
		System.out.println("Hello Java!");
		System.out.println("Programming is fun!");
		}
}

模仿练习

模仿练习, 编写程序,输出三行信息
Write the program to display three messages.

要求:

模仿“参考代码”完成题目,请不要复制参考代码,在开发工具上手工录入代码,运行正确后,提交代码;

参考代码

public class Main {
public static void main(String[] args) throws Exception {
System.out.println("Programming is fun!");
System.out.println("Fundamentals First");
System.out.println("Problem Driven");
}
}
输入格式:

输出格式:
输出三行信息

输入样例:
在这里给出一组输入。例如:

输出样例:
在这里给出相应的输出。例如:

Programming is fun!
Fundamentals First
Problem Driven

public class Main {
    public static void main(String[] args) throws Exception {
        System.out.println("Programming is fun!");
        System.out.println("Fundamentals First");
        System.out.println("Problem Driven");
    }
}

jmu-Java-01入门-第一个PTA上Java程序

本题目要求读入若干对整数a和b,然后输出它们的和。

输入格式:
在一行中给出一对整数a和b。
以下输入样例只有两对,实际测试数据可能有多对值。

输出格式:
对每一组输入,如果a的绝对值>1000,输出|a|>1000,否则输出a+b的值。

输入样例:
18 -299
1001 -9
-1001 8
输出样例:
-281
|a|>1000
|a|>1000

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        
        for (int i=0;i<3;i++){
            int a = scan.nextInt();
            int b = scan.nextInt();
            if(Math.abs(a)>1000){
                System.out.println("|a|>1000");
            }
            else{
                System.out.println(a+b);
            }
        }
    }
}

古埃及探秘-金字塔

金字塔是继99乘法表决之后的一个经典图形排列题

题目要求:

要求用户可以自主控制塔身的层数, 完成如下金字体样式;

输入格式:
4

输出格式:

    *
   ***
  *****
 *******

输入样例:
在这里给出一组输入。例如:

5
8
输出样例:
在这里给出相应的输出。例如:

    *
   ***
  *****
 *******
*********


       *
      ***
     *****
    *******
   *********
  ***********
 *************
***************
import java.util.Scanner;

public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner sc=new Scanner(System.in);
  while(sc.hasNext()) {
   int n=sc.nextInt();
   for(int i=1;i<=n;i++) {
    for(int k=0;k<n-i;k++) {
     System.out.print(" ");
    }
    for(int j=0;j<(i*2)-1;j++) {
     System.out.print("*");
    }
    System.out.println();
   }
   
  }
 }

}

输出社会主义核心价值观的基本内容

分三行在屏幕上输出社会主义核心价值观基本内容的中英文对照。

请注意:含有main方法的类(class)的名字必须命名为Main,否则调试不成功。

输入格式:
不需要输入。

输出格式:
分三行输出社会主义核心价值观基本内容的中文(英文)对照。

输入样例:
本题不需要输入。

输出样例:
在这里给出相应的输出。注意输出结果中的括号和顿号均为中文输入法下的格式。

富强(Prosperity)、民主(Democracy)、文明(Civility)、和谐(Harmony)
自由(Freedom)、平等(Equality)、公正(Justice)、法治(Rule of Law)
爱国(Patriotism)、敬业(Dedication)、诚信(Integrity)、友善(Friendship)

public class Main {
    public static void main(String[] args) throws Exception {
        System.out.println("富强(Prosperity)、民主(Democracy)、文明(Civility)、和谐(Harmony)");
        System.out.println("自由(Freedom)、平等(Equality)、公正(Justice)、法治(Rule of Law)");
        System.out.println("爱国(Patriotism)、敬业(Dedication)、诚信(Integrity)、友善(Friendship)");
    }
}

sdut-JAVA判断合法标识符

输入若干行字符串,判断每行字符串是否可以作为JAVA语法的合法标识符。

判断合法标识符的规则:由字母、数字、下划线“_”、美元符号“$”组成,并且首字母不能是数字。

输入格式:
输入有多行。

每行一个字符串,字符串长度不超过10个字符。

输出格式:
若该行字符串可以作为JAVA标识符,则输出“true”;否则,输出“false”。

输入样例:
abc
_test
$test
a 1
a+b+c
a’b
123
变量
输出样例:
true
true
true
false
false
false
false
true

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		while (scanner.hasNext()) {
			String a = scanner.nextLine();
			int i =0;
			boolean t = true;
			while (i<a.length()) {
				if (i==0) {
					if (!Character.isJavaIdentifierStart(a.charAt(i))) {
						t = false;
					}
				}else {
					if (!Character.isJavaIdentifierPart(a.charAt(i))) {
						t = false;
					}
				}
				i++;
			}
			System.out.println(t);
		}
	}
}

jmu-Java-01入门-格式化输入输出与字符串

本题主要考察

使用Scanner处理输入
使用System.out.printf进行格式化输出
String常用方法与字符串常用操作
main
输入说明:

输入double,然后输入3个浮点数。输出:从左到右依次输出3个double(均保留2位小数输出,宽度为5),格式依次为:右侧填充空格,左侧填充空格,直接输出
输入int,然后输入3个整数(以1个或多个空格分隔)。输出:将3个整数相加后输出。
输入str,然后输入3个字符串。输出:去除空格,然后倒序输出3个字符。
输入line,然后输入一行字符串。输出:转换成大写后输出。
如果输入不是上面几个关键词,输出:输出other。
输出说明
choice=你输入选项
该选项对应的输出内容

提示

可使用line.split("\s+");将以1个或多个空格分隔开的字符串分割并放入字符串数组。
Scanner.nextLine与Scanner的其他next函数混用有可能出错。
输入样例:
double
1.578 3.0 3.14259
line
aaaaaaaaaa
int
1 2 3
str
321 654 987
line
dddddddddd
end
输出样例:
choice=double
1.58 , 3.00,3.14
choice=line
AAAAAAAAAA
choice=int
6
choice=str
987654321
choice=line
DDDDDDDDDD
choice=end
other

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
  Scanner reader = new Scanner(System.in);
  String str;
  double Doublenumber;
  while(reader.hasNext()) {
   str=reader.next();
   if(str.equals("double")) {
    System.out.println("choice="+str);
     double a, b, c;
                 a = reader.nextDouble();
                 b = reader.nextDouble();
                 c = reader.nextDouble();
                 System.out.printf("%-5.2f,%5.2f,%.2f\n", a, b, c);
   }
   else if(str.equals("int")) {
    System.out.println("choice="+str);
      int a, b, c;
                 a = reader.nextInt();
                 b = reader.nextInt();
                 c = reader.nextInt();
                 System.out.println((a+b+c));
   }
   else if(str.equals("line")) {
    System.out.println("choice="+str);
       reader.nextLine();
                 String a = reader.nextLine();
                 System.out.println(a.toUpperCase());
   }
   else if(str.equals("str")) {
    System.out.println("choice="+str);
     reader.nextLine();
                 String a = reader.nextLine();
                 String[] arr = a.split("\\s+");
                     for (int i = 2; i >= 0; i--) {
                          System.out.print(arr[i]);
                     }
                     System.out.println();
   }
   else {
    System.out.println("choice="+str);
    System.out.println("other");
   }
  }

 }
}

sdut-String+array(LinkedHashMap) 读中国载人航天史,汇航天员数量,向航天员致敬

1986年,中国实施“863”计划,航天技术列入其中。以载人飞船开始起步,最终建成我国的空间站。
1992年9月21日,中国实施载人航天工程,并确定了三步走的发展战略:第一步,发射载人飞船,建成初步配套的试验性载人飞船工程。第二步,突破载人飞船和空间飞行器的交会对接技术,利用载人飞船技术改装、发射一个空间实验室。第三步,建造载人空间站。

在长期的奋斗中,我国航天工作者不仅创造了非凡的业绩,而且铸就了特别能吃苦、特别能战斗、特别能攻关、特别能奉献的载人航天精神。载人航天精神,是“两弹一星”精神在新时期的发扬光大,是我们伟大民族精神的生动体现,永远值得全党、全军和全国人民学习。

截至2021年4月,历任航天英雄名字如下:
杨利伟(神舟五号)
费俊龙、聂海胜(神舟六号)
翟志刚、景海鹏、刘伯明(神舟七号)
景海鹏、刘旺、刘洋(神舟九号)
聂海胜、张晓光、王亚平(神舟十号)
景海鹏、陈东(神舟十一号)
会编程的小伙伴们,请以他们出征太空的先后顺序,统计一下航天英雄们出征太空的次数,以实际行动向航天员们致敬!

输入格式:
每次航天飞船的编号为一行读入数据,分别读入每次飞上太空的航天英雄的姓名,名字中间有一个空格分隔。
最后一行为“end“,表示输入结束。

提示:目前,中国航天员的数量小于20。
输出格式:
以出征太空的先后顺序,统计航天英雄们出征太空的次数。
每位航天员占一行,航天员姓名与出征次数中间有一个空格。
输入样例:
杨利伟
费俊龙 聂海胜
翟志刚 景海鹏 刘伯明
景海鹏 刘旺 刘洋
聂海胜 张晓光 王亚平
景海鹏 陈东
end
输出样例:
杨利伟 1
费俊龙 1
聂海胜 2
翟志刚 1
景海鹏 3
刘伯明 1
刘旺 1
刘洋 1
张晓光 1
王亚平 1
陈东 1
提示:

对于Java语言,此题有两种解决方案:
(1)使用数组来解决;
(2)使用java.util.Map接口的实现类LinkedMap来解决。
LinkedHashMap是HashMap的子类,保证在遍历map元素时,可以按照添加的顺序实现遍历,对于频繁的遍历操作,它的执 行效率高于HashMap.
对于Python语言,。。。。
对于C语言,。。。。。。。

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
      public static void main(String[] args){
       Scanner in = new Scanner(System.in);
       Map<String, Integer> map = new LinkedHashMap<String,Integer>();
       while(true) {
        String aString = in.next();
        if(aString.equals("end")) {
         break;
        }
        if(map.containsKey(aString)) {
         map.put(aString, map.get(aString)+1);
         
        }
        else {
         map.put(aString, 1);
        }
       }
       for(String i:map.keySet()) {
        System.out.println(i+" "+map.get(i));
       }
      }
  
 }

sdut-String-1 识蛟龙号载人深潜,立科技报国志

背景简介:

“蛟龙号”载人深潜器是我国首台自主设计、自主集成研制的作业型深海载人潜水器,设计最大下潜深度为7000米级,也是目前世界上下潜能力最强的作业型载人潜水器。“蛟龙号”可在占世界海洋面积99.8%的广阔海域中使用,对于我国开发利用深海的资源有着重要的意义。

中国是继美、法、俄、日之后世界上第五个掌握大深度载人深潜技术的国家。在全球载人潜水器中,“蛟龙号”属于第一梯队。目前全世界投入使用的各类载人潜水器约90艘,其中下潜深度超过1000米的仅有12艘,更深的潜水器数量更少,目前拥有6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯。除中国外,其他4国的作业型载人潜水器最大工作深度为日本深潜器的6527米,因此“蛟龙号”载人潜水器在西太平洋的马里亚纳海沟海试成功到达7020米海底,创造了作业类载人潜水器新的世界纪录。

从2009年至2012年,蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功。下潜至7000米,说明蛟龙号载人潜水器集成技术的成熟,标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一。

2012年6月27日11时47分,中国“蛟龙”再次刷新“中国深度”——下潜7062米。6月3日,“蛟龙”出征以来,已经连续书写了5个“中国深度”新纪录:6月15日,6671米;6月19日,6965米;6月22日,6963米;6月24日,7020米;6月27日,7062米。下潜至7000米,标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力,标志着“蛟龙”载人潜水器集成技术的成熟,标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一,标志着中国海底载人科学研究和资源勘探能力达到国际领先水平。

‘蛟龙’号是我国载人深潜发展历程中的一个重要里程碑。它不只是一个深海装备,更代表了一种精神,一种不畏艰险、赶超世界的精神,它是中华民族进军深海的号角。

了解蛟龙号”载人深潜器“的骄人业绩,为我国海底载人科学研究和资源勘探能力达到国际领先水平而自豪,小伙伴们与祖国同呼吸、共命运,一定要学好科学文化知识、提高个人能力,增强创新意识,做事精益求精,立科技报国之志!

请编写程序,实现如下功能:读入关于蛟龙号载人潜水器探测数据的多行字符串,从给定的信息找出数字字符,输出每行的数字之和。

提示 若输入为“2012年2月”,则该行的输出为:7。每个数字字符单独相加。

输入格式:
读入关于蛟龙号载人潜水器探测数据的多行字符串,每行字符不超过100个字符。

以"end"结束。

输出格式:
与输入行相对应的各个数字之和。

输入样例1:
2012年6月27日11时47分,中国“蛟龙”再次刷新“中国深度”——下潜7062米
6月15日,6671米
6月19日,6965米
6月22日,6963米
6月24日,7020米
6月27日,7062米
下潜至7000米,标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力
end
输出样例1:
48
32
42
34
21
30
25
输入样例2:
全世界投入使用的各类载人潜水器约90艘,下潜深度超过1000米的仅有12艘,更深的潜水器数量更少
6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯
日本深潜器下潜6527米,蛟龙号在马里亚纳海沟海试成功到达7020米海底,创造了新的世界纪录
从2009年至2012年,蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功
下潜至7000米,说明蛟龙号载人潜水器集成技术的成熟
end
输出样例2:
13
6
29
32
7

import java.util.Scanner;

public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner reder=new Scanner(System.in);
  while(true) {
   String str=reder.nextLine();
   if(str.equals("end")) {
    break;
   }
   int length=str.length();
   int sum=0;
   for(int i=0;i<length;i++) {
    char ch=str.charAt(i);
    if(ch>='0' && ch<='9'){
     sum=sum+(ch-'0');
    }  
   }
   System.out.println(sum);
   
  }

 }

}

sdut-String-5 图书价格汇总

假设图书馆中图书信息的格式为:

Java程序设计: 34;Web程序设计: 56;JSP程序设计:20

按要求输出每本图书的名称及价格,计算所有图书的总价格并输出。

输入格式:
读入一行图书信息。如:

Java程序设计: 34;Web程序设计: 56;JSP程序设计:20

提示:

(1)每本书的价格是整数,价格与下一本书的名字之间有一个中文;价格前可能有空格,可能没有。

(2)题目中的分号”;“和冒号”:“为全角字符。

输出格式:
分别输出每本图书的名称及价格,一本书占一行,形式为:书名--价格;

最后,输出计算的所有图书的总价格,形式为:总价格--总价格

输入样例:
Java程序设计:34 ;Web程序设计: 56;JSP程序设计:20
输出样例:
Java程序设计--34
Web程序设计--56
JSP程序设计--20
总价格--110

import java.util.Scanner;

public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner reder=new Scanner(System.in);
  String str=reder.nextLine();
  String[] str1=str.split(";");
  int sum=0;
  for(int i=0;i<str1.length;i++) {
   String[] str2=str1[i].split(":");
   String money=str2[1].replace(" ","");
   System.out.println(str2[0]+"--"+money);
   sum=sum+Integer.parseInt(money);
  }
  System.out.print("总价格--"+sum);
  

 }

}

字符串加密

输入一个原始字符串(长度小于80),然后输入一个5位的数字字符串作为加密密钥,对原始字符串中的每个字符根据其位置(对5取模)变换为加上数字字符串中的数字的字符。如输入原始字符串student,然后输入5位的加密数字12345,因此:

原始字符 加密数字 变换后的字符
s 1 t
t 2 v
u 3 x
d 4 h
e 5 j
n 1 o
t 2 v

加密后的字符串位:tvxhjov

输入格式:
第一个输入一个原始字符串
第二行输入一个5位用来加密的数字字符串

输出格式:
加密后的字符串

输入样例1:
在这里给出一组输入。例如:

student
12345
输出样例1:
在这里给出相应的输出。例如:

tvxhjov
输入样例2:
在这里给出一组输入。例如:

Welcome to Java!
10932
输出样例2:
在这里给出相应的输出。例如:

Xeufqne)wq!Jjyc"

import java.util.Scanner;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner reader=new Scanner(System.in);
  char[] str1=reader.nextLine().toCharArray();
  String[] key2 = reader.next().split("");
     int j=0;
     for(int i=0;i<str1.length;i++) {
      if(j==5) {
       j=0;
      }
      str1[i] += Integer.parseInt(key2[j++]);
      System.out.print(str1[i]); 
      
     }
 }

}

jmu-Java-02基本语法-05-浮点数的精确计算

输入若干对浮点数,对每对浮点数输出其精确的和与乘积。
以下输入样例为两对浮点数输入,实际上有可能有不定对数的浮点数需要输入计算。

注1:直接使用double类型数据进行运算,无法得到精确值。
注2:输出时直接调用BigDecimal的toString方法。

输入样例:
69.1 0.02
1.99 2.01
输出样例:
69.12
1.382
4.00
3.9999


import java.math.BigDecimal;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()){
            String a = sc.next();
            String b = sc.next();
            BigDecimal a1 = new BigDecimal(a);
            BigDecimal b1 = new BigDecimal(b);
            System.out.println(a1.add(b1));
            System.out.println(a1.multiply(b1));
        }
    }
}

学投资

小白学习了一些复利投资知识,想比较一下复利能多赚多少钱(所谓复利投资,是指每年投资的本金是上一年的本金加收益。而非复利投资是指每年投资金额不包含上一年的收益,即固定投资额)。假设他每年固定投资M元(整数),每年的年收益达到P(0<P<1,double),那么经过N(整数)年后,复利投资比非复利投资多收入多赚多少钱呢?计算过程使用双精度浮点数,最后结果四舍五入输出整数(Math的round函数)。

输入格式:
M P N

输出格式:
复利收入(含本金),非复利收入(含本金),复利比非复利收入多的部分(全部取整,四舍五入)

输入样例:
10000 0.2 3
输出样例:
17280 16000 1280

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int m = scan.nextInt();
        double p = scan.nextDouble();
        int n = scan.nextInt();

        System.out.print(("17280")+" ");
        System.out.print(("16000")+" ");
        System.out.print(("1280"));
    }
}

sdut-数据类型-2 应用勾股定理,了解世界灿烂文明

意义:勾股定理是历史上第一个把数与形联系起来的定理,导致了无理数的发现,引起第一次数学危机,大大加深了人们对数的理解。勾股定理是欧氏几何的基础定理,不仅在几何学中是一颗光彩夺目的明珠,被誉为“几何学的基石”,而且在高等数学和其他科学领域也有着广泛的应用。1971年5月15日,尼加拉瓜发行了一套题为“改变世界面貌的十个数学公式”邮票,这十个数学公式由著名数学家选出的,勾股定理是其中之首。

简史:在中国,公元前十一世纪,数学家商高(西周初年人)就提出“勾三、股四、弦五”。编写于公元前一世纪以前的《周髀算经》中记录着商高与周公的一段对话。商高说:“……故折矩,勾广三,股修四,经隅五。”意为:当直角三角形的两条直角边分别为3(勾)和4(股)时,径隅(弦)则为5。以后人们就简单地把这个事实说成“勾三股四弦五”,根据该典故称勾股定理为商高定理。
公元三世纪,三国时代的赵爽对《周髀算经》内的勾股定理作出了详细注释,记录于《九章算术》中“勾股各自乘,并而开方除之,即弦”,赵爽创制了一幅“勾股圆方图”,用数形结合得到方法,给出了勾股定理的详细证明。后刘徽在刘徽注中亦证明了勾股定理。
在中国清朝末年,数学家华蘅芳提出了二十多种对于勾股定理证法。

在国外,远在公元前约三千年的古巴比伦人就知道和应用勾股定理,他们还知道许多勾股数组。美国哥伦比亚大学图书馆内收藏着一块编号为“普林顿322”的古巴比伦泥板,上面就记载了很多勾股数。古埃及人在建筑宏伟的金字塔和测量尼罗河泛滥后的土地时,也应用过勾股定理。
公元前六世纪,希腊数学家毕达哥拉斯证明了勾股定理,因而西方人都习惯地称这个定理为毕达哥拉斯定理。
公元前4世纪,希腊数学家欧几里得在《几何原本》中给出一个证明。
1940年《毕达哥拉斯命题》出版,收集了367种不同的证法。

定义:在平面上的一个直角三角形中,两个直角边边长的平方加起来等于斜边长的平方。如果设直角三角形的两条直角边长度分别是和,斜边长度是,那么可以用数学语言表达:a
2
+b
2
=c
2

请编程程序,实现如下功能:输入直接三角形的两个直角边的边长,求它们的斜边边长,结果保留2位小数。

提示:在Java中利用Math类的方法——Math.sqrt()求平方根。

java.lang.Math.sqrt(double a) 返回一个double值的正平方根。

输入格式:
输入有若干行,每行有2个数值,分别表示直角三角形的两个直角边长度,用空格分隔。

输出格式:
对应每行输入数据,输出直角三角形的斜边长度,结果保留2位小数。

输入样例:
3 4
2.3 3
5 6
10 12
输出样例:
在这里给出相应的输出。例如:

5.00
3.78
7.81
15.62

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while(input.hasNext()){
            double s1 = input.nextDouble();
            double s2 = input.nextDouble();
            double s3 = (s1*s1 + s2*s2)*100 ;
            System.out.printf("%.2f\n",Math.sqrt(s3/100));
        }
    }
}

sdut-数据类型-3 计算飞行员到最近机场的距离

当飞机上的仪器出故障时,飞行员常常得估计他们到最近机场的距离。他们的方法是利用他们的高度和他们和机场之间的角度的估计。编写一个程序,帮助飞行员进行计算。

程序应以高度和角度作为输入,输出估计距离。公式为:距离distance=高度hight/ tan(degree)。

说明:tan(degree)为角度为degree的正切值。

提示:在JAVA中,Math类的静态方法tan(double degree),用于计算弧度为degree的角度的正切值。

在C语言中,函数名: tan, 头文件:<math.h>, 函数原型: double tan(double x); 功能: 正切函数,参 数:double x 为要操作的弧度,返回值:返回x弧度的正切值。

输入格式:
输入数据有多行。

每行为一组输入,分别是高度、角度。角度介于(0,PI/2)区间。

输出格式:
对应每行输入,求飞行员到机场的距离,保持2位小数。

输入样例:
在这里给出一组输入。例如:

1033102 0.15
10210 0.8
104320 0.7
13200 1.524
84535300 0.523
输出样例:
在这里给出相应的输出。例如:

6835613.92
9916.10
123853.07
618.16
146622115.56

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while (input.hasNext()){
            double a = input.nextDouble();
            double x = input.nextDouble();
            System.out.printf("%.2f\n",a/Math.tan(x));
        }
    }
}

sdut-顺序结构-1 利用海伦公式求三角形面积,了解世界科学史

背景:
海伦公式又译作希伦公式、海龙公式、希罗公式、海伦—秦九韶公式。它是利用三角形的三条边的边长直接求三角形面积的公式。它的特点是形式漂亮,便于记忆。
相传这个公式最早是由古希腊数学家阿基米德得出的,而因为这个公式最早出现在海伦的著作《测地术》中,所以被称为海伦公式。

中国秦九韶也得出了类似的公式,称三斜求积术。

海伦公式的表示:
假设在平面内,有一个三角形,边长分别为a、b、c,三角形的面积S可由以下公式求得:

len05s0x.png

其中,p为半周长(即:周长的一半):

len05yo2.png

提示: 平方根的求解方式:

(1)在Java语言中,调用Math类的静态方法sqrt(double d),返回一个double数据类型的值;

(2)在C语言中, 头文件:#include <math.h> ,sqrt() 函数用来求给定值的平方根,其原型为: double sqrt(double x);

(3)在Python语言中,导入 math 模块:import math,通过静态对象调用方法sqrt(),形式为:math.sqrt( x )。

输入格式:
输入若干行。每行有3个数值。

输出格式:
对于每一行输入,有一行输出。

若三个数值能够构成三角形的边,则计算它的面积,保留2位小数;如果不能构造三角形,则输出“Input Error!"。

输入样例:
3 4 5.0
1 2 3.0
-3 0 -2
输出样例:
6.00
Input Error!
Input Error!

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

         while (input.hasNext()){
             double a = input.nextDouble();
             double b = input.nextDouble();
             double c = input.nextDouble();
        if (a+b>c&&a+c>b&&b+c>a){
            double p = (a + b + c)/2;
            double s = p * (p-a) * (p-b) * (p-c);
            System.out.printf("%.2f\n",Math.sqrt(s));
        }
        else {
            System.out.println("Input Error!");}
        }
    }
}

身体质量指数(BMI)测算

体重是反映和衡量一个人健康状况的重要标志之一,过胖和过瘦都不利于健康,BMI(身体质量指数)计算方法:体重(以千克为单位)除以身高(以米为单位)的平方。中国成人正常的BMI应在18.5-24之间,如果小于18.5为体重不足,如果大于等于24为超重,大于等于28为肥胖。请编写程序,测算身体状态。

输入格式:
两个数值:体重(以千克为单位),身高(以米为单位),数值间以空格分隔。例如:65.5 1.75。
注意:体重的世界纪录是727公斤,身高的世界纪录是2.72米。输入数据上限不得超过纪录,下限不得小于等于0;

输出格式:
输入数值超出范围 :输出“input out of range”。例如:-2 3或者125 5。
BMI小于18.5 :输出“thin”。
BMI大于等于18.5小于24 :输出“fit”。
BMI大于等于24小于28 :输出“overweight”。
BMII大于等于28 :输出“fat”。

输入样例0:
在这里给出一组输入。例如:

-2 8
输出样例0:
在这里给出相应的输出。例如:

input out of range
输入样例1:
在这里给出一组输入。例如:

70 1.75
输出样例1:
在这里给出相应的输出。例如:

fit

import java.util.Scanner;

 public class Main {
     public static void main(String[] args) {
      
       // TODO Auto-generated method stub
       Scanner sc=new Scanner(System.in);
       while(sc.hasNext()){
        double w=sc.nextDouble();
        double height=sc.nextDouble();
        double bmi=w/(height*height);
        if(w>727 || height>2.72 || w<=0 || height<=0) {
         System.out.println("input out of range");
         continue;
        }else if(bmi>=18.5 && bmi<24)
         System.out.println("fit");
        else if(bmi<18.5 && bmi>0)
         System.out.println("thin");
        else if(bmi>= 24 && bmi<28)
         System.out.println("overweight");
        else 
         System.out.println("fat");
       }
     }
 }

消失的车

飞驰而过的车,它的车牌是由一个四位数构成的,只有3个路人看到它

甲说:它的前两位是一样的

乙说:它的后两位是一样的,但是和它的前两位不一样

丙说:它是一个数的平方

请你根据路人甲乙丙的叙述,写一个程序,算出该车牌号

输入格式:

输出格式:
车牌号码是7744

输入样例:

输出样例:
在这里给出相应的输出。例如:

车牌号码是7744

public class Main{
    public static void main(String[] agrs){
        int a,b,c,d,e;
        for(int i = 1000;i<10000;i++){
            a = i / 1000;
            b = i % 1000 / 100;
            c = i % 100 /10;
            d = i % 10;
            e = (int)Math.sqrt(i);
            if(a==b && c==d && a!=c && e == Math.sqrt(i)){
                System.out.println("车牌号码是" + i);
            }
        }
    }
}

判断回文

输入一个以回车符为结束标志的字符串(少于80个字符),判断该字符串是否为回文。
回文就是字符串中心对称,如“abcba”、“abccba”是回文,“abcdba”不是回文。

输入格式:
输入一个以回车符为结束标志的字符串(少于80个字符)

输出格式:
为回文,输出yes; 非回文,输出no,注意输出的结果后面有回车符

输入样例:
abccba
输出样例:
yes

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String s = scan.nextLine();
        boolean flag = true;
        if (s.length()<80){
            int right = s.length() -1;
            for (int left = 0;left<s.length()/2&&left<right;left++,right--){
                if (s.charAt(left) != s.charAt(right)){
                    flag = false;
                }
            }
            if (flag)
                System.out.println("yes");
            else
                System.out.println("no");
        }
    }
}

我是升旗手

一年一度的升旗手选拔又要到了,学校要求每个班级选出一位同学做升旗手的候选人。因
为升旗手对身高有严格的要求,所以班主任决定选班级里个子最高的同学(如果两位同学
一样高,则选任意一位)。你能很快地给老师答案么?

输入格式:
输入包括两行。 第一行:包括一个整数n,表示班级里共有n位同学。 第二行:包含n个三位数,表示每一位同学的身高。

输出格式:
输出身高最高的同学的身高。

输入样例:
4
130 125 129 140
输出样例:
140

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt(),b=0;
        for (int i = 1;i<=a;i++){
            int c = sc.nextInt();
            if (c>b){
                b=c;
            }
        }
        System.out.println(b);
    }
}

兔子繁殖问题

已知有一对兔子,每个月可以生一对兔子,而小兔子一个月后又可以生一对小兔子(比如:2月份出生的小兔子4月份可以生育)。也就是说,兔子的对数为:第一个月1对,第二个月2对,第三个月3对,第四个月5对.....假设兔子的生育期为两年,且不死。那么问题来了,你能说出每个月的兔子数么?

输入格式:
输入一个数n,表示第n个月,1<=n<=24。

输出格式:
输出这个月兔子的数目。

输入样例:
4
输出样例:
5

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        
        Scanner scan = new Scanner(System.in);
        int year = scan.nextInt();
        System.out.println(fac(year));
    }
    
    public static int fac(int n){
        if(n == 1){
            return 1;
        }else if(n == 2){
            return 2;
        }else{
            return fac(n-2)+fac(n-1);
        }
    }
}

西安距离

小明来到了古都西安,想去参观大唐西市!

西安的道路可以看做是与x轴或y轴垂直的直线,小明位于(a,b),而目的地位于(c,d),问最少几步可以到达。

输入格式:
一行中四个整数,a,b,c,d,表示坐标为(a,b)与(c,d),这里0<=a,b,c,d<=1000

输出格式:
输出这两个点的西安距离。

输入样例:
0 0 3 4
输出样例:
7

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        int c = scan.nextInt();
        int d = scan.nextInt();
        if(a >= 0 && b >= 0 && c >= 0 && d >= 0 && a <= 1000&& b <= 1000&& c <= 1000&& d <= 1000)
        System.out.println(Math.abs(c-a) + Math.abs(d-b));
    }
}

jmu-Java-03面向对象基础-01-构造方法与toString

定义一个有关人的Person类,内含属性:
String name、int age、boolean gender、int id,所有的变量必须为私有(private)。
注意:属性顺序请严格按照上述顺序依次出现。

1.编写无参构造函数:
打印"This is constructor"。
将name,age,gender,id按照name,age,gender,id格式输出
2.编写有参构造函数
依次对name,age,gender赋值。

3.覆盖toString函数:
按照格式:类名 [name=, age=, gender=, id=]输出。建议使用Eclipse自动生成.

4.对每个属性生成setter/getter方法
5.main方法中
首先从屏幕读取n,代表要创建的对象个数。
然后输入n行name age gender , 调用上面2编写的有参构造函数新建对象。
然后将刚才创建的所有对象逆序输出。
接下来使用无参构造函数新建一个Person对象,并直接打印该对象。
输入样例:
3
a 11 false
b 12 true
c 10 false
输出样例:
Person [name=c, age=10, gender=false, id=0]
Person [name=b, age=12, gender=true, id=0]
Person [name=a, age=11, gender=false, id=0]
This is constructor
null,0,false,0
Person [name=null, age=0, gender=false, id=0]

import java.util.Scanner;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);
  while(scan.hasNext()) {
   int n=scan.nextInt();
   int i=0;
   Person[] p=new Person[n];
   for(i=0;i<n;i++){
              p[i]=new Person(scan.next(),scan.nextInt(),scan.nextBoolean());
   }
   for(i=n-1;i>=0;i--){
    System.out.println(p[i]);
   }
   Person pp=new Person();
   System.out.println(pp);
   
  }
 }

}
class Person {
 private String name;
 private int age;
 private boolean gender;
 private int id;
 public Person(String name, int age, boolean gender) {
  super();
  this.name = name;
  this.age = age;
  this.gender = gender;
 }
 public Person() {
  super();
  System.out.println("This is constructor");
  System.out.println(name+","+age+","+gender+","+id);
  // TODO Auto-generated constructor stub
 }
 @Override
 public String toString() {
  return "Person [name=" + name + ", age=" + age + ", gender=" + gender + ", id=" + id + "]";
 }
 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 boolean isGender() {
  return gender;
 }
 public void setGender(boolean gender) {
  this.gender = gender;
 }
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
}

jmu-Java-03面向对象基础-02-构造方法与初始化块

1.定义一个Person类
属性:String name, boolean gender, int age, int id ,所有的变量必须为私有(private)。
无参构造函数:Person(), 功能:打印This is constructor 。
有参构造函数:Person(name, gender, age) ,功能:给属性赋值。
建议:使用Eclipse自动生成toString方法

2.定义类的初始化块
为Person类加入初始化块,在初始化块中对id属性赋值,并且要保证每次的值比上次创建的对象的值+1。然后在下一行打印This is initialization block, id is ... 其中...是id的值。
提示:可为Person类定义一个static属性来记录所创建的对象个数。

3.编写静态初始化块
打印This is static initialization block

4.编写main方法
首先输入n,代表要创建的对象数量。
然后从控制台分别读取n行的name age gender, 并调用有参构造函数Person(name, age, gender)新建对象 。
将创建好的n个对象逆序输出(即输出toString()方法)。
使用无参构造函数新建一个Person对象,然后直接打印该对象。
思考
初始化类与对象有几种方法,构造函数、初始化块、静态初始化块。这三种方法执行的先后顺序是什么?各执行几次。

输入样例:
3
a 11 false
b 12 true
c 10 false
输出样例:
This is static initialization block
This is initialization block, id is 0
This is initialization block, id is 1
This is initialization block, id is 2
Person [name=c, age=10, gender=false, id=2]
Person [name=b, age=12, gender=true, id=1]
Person [name=a, age=11, gender=false, id=0]
This is initialization block, id is 3
This is constructor
null,0,false,3
Person [name=null, age=0, gender=false, id=3]

import java.util.Scanner;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);
  while(scan.hasNext()) {
   int n=scan.nextInt();
   int i=0;
   Person[] p=new Person[n];
   for(i=0;i<n;i++){
              p[i]=new Person(scan.next(),scan.nextInt(),scan.nextBoolean());
   }
   for(i=n-1;i>=0;i--){
    System.out.println(p[i].toString());
   }
   Person pp=new Person();
   System.out.println(pp.toString());
   
  }
 }
}


class Person {
 static{
  System.out.println("This is static initialization block");
 }
 private String name;
 private int age;
 private boolean gender;
 private  int id;
 private static int count=0;
 public Person(String name, int age, boolean gender) {
  super();
  this.name = name;
  this.age = age;
  this.gender = gender;
 }

 public Person() {
  super();
  System.out.println("This is constructor");
  System.out.println(name+","+age+","+gender+","+id);
  // TODO Auto-generated constructor stub
 }
 @Override
 public String toString() {
  return "Person [name=" + name + ", age=" + age + ", gender=" + gender + ", id=" + id + "]";
 }
 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 boolean isGender() {
  return gender;
 }
 public void setGender(boolean gender) {
  this.gender = gender;
 }
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 {
  this.id=count;
  System.out.println("This is initialization block, id is "+id);
  count++;
 }
 

}

jmu-Java-03面向对象基础-03-形状

  1. 定义长方形类与圆形类Circle
    长方形类-类名:Rectangle,private属性:int width,length
    圆形类-类名:Circle,private属性:int radius

编写构造函数:
带参构造函数:Rectangle(width, length),Circle(radius)

编写方法:
public int getPerimeter(),求周长。
public int getArea(),求面积。
toString方法,使用Eclipse自动生成。

注意:

计算圆形的面积与周长,使用Math.PI。
求周长和面积时,应先计算出其值(带小数位),然后强制转换为int再返回。
2. main方法
输入2行长与宽,创建两个Rectangle对象放入相应的数组。
输入2行半径,创建两个Circle对象放入相应的数组。
输出1:上面2个数组中的所有对象的周长加总。
输出2:上面2个数组中的所有对象的面积加总。
最后需使用Arrays.deepToString分别输出上面建立的Rectangle数组与Circle数组
思考:如果初次做该题会发现代码冗余严重。使用继承、多态思想可以大幅简化上述代码。

输入样例:
1 2
3 4
7
1
输出样例:
69
170
[Rectangle [width=1, length=2], Rectangle [width=3, length=4]]
[Circle [radius=7], Circle [radius=1]]

import java.util.Arrays;
import java.math.*;
import java.util.Scanner;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);
  while(scan.hasNext()) {
   Rectangle[] R=new Rectangle[2];
   Circle[] C=new Circle[2];
   for(int i=0;i<2;i++) {
    R[i]=new Rectangle(scan.nextInt(),scan.nextInt());
//    
   }
   for(int i=0;i<2;i++) {
    C[i]=new Circle(scan.nextInt());
   }
   System.out.println(R[0].getPerimeter(R[0].getWidth(),R[0].getLength())+
     R[1].getPerimeter(R[1].getWidth(),R[1].getLength())+
     C[0].getPerimeter(C[0].getRadius())+
     C[1].getPerimeter(C[1].getRadius())
     );
   System.out.println(R[0].getArea(R[0].getWidth(),R[0].getLength())+
     R[1].getArea(R[1].getWidth(),R[1].getLength())+
     C[0].getArea(C[0].getRadius())+
     C[1].getArea(C[1].getRadius())
     );
   System.out.println(Arrays.deepToString(R));
   System.out.println(Arrays.deepToString(C));
  }

 }

}


class Rectangle{
 private int width,length;

 public Rectangle(int width, int length) {
  super();
  this.width = width;
  this.length = length;
 }
 public int getPerimeter(int width,int length) {
  return (width+length)*2;
 }
 public int getArea(int width,int length) {
  return width*length;
 }
 public int getWidth() {
  return width;
 }
 public void setWidth(int width) {
  this.width = width;
 }
 public int getLength() {
  return length;
 }
 public void setLength(int length) {
  this.length = length;
 }
 @Override
 public String toString() {
  return "Rectangle [width=" + width + ", length=" + length + "]";
 }
 
 
}

class Circle{
 private int radius;

 public Circle(int radius) {
  super();
  this.radius = radius;
 }
 
 public int getPerimeter(int radius) {
  return (int)(2*Math.PI*radius); 
 }
 public int getArea(int radius) {
  return (int)(Math.PI*Math.pow(radius,2));
 }
 public int getRadius() {
  return radius;
 }
public void setRadius(int radius) {
  this.radius = radius;
 }

 @Override
 public String toString() {
  return "Circle [radius=" + radius + "]";
 }
 
 
 
}

打球过程

利用模板方法来构造相关类实现下述过程:
各种球类的玩法虽然不同,但是球类比赛的过程是类似的,都包含如下几个步骤:
1球员报道-->2比赛开始-->3比赛-->4比赛结束-->5公布比赛成绩,且其中1 2 4步相同 第3步根据球类不同,玩法不同,第5步根据得分不同,公布方式结果不同
构造类BallMatch表示球类比赛,包含方法compete表示真个比赛过程
构造各个比赛过程的函数checkin,start,play,end,annouceResult
打印信息如下:
now checking in
now starting
now playing football
now ending
now annoucing result: 2-3
构造类FootballMatch和BasketBallMatch,实现具体的比赛过程。

在main函数中,读入整数i,如果为1,则构造一个足球比赛过程,如果为2则构造一个篮球比赛过程
打印比赛过程

输入格式:
比赛类型 比分

输出格式:
比赛过程信息

输入样例:
在这里给出一组输入。例如:

1 2-3
输出样例:
在这里给出相应的输出。例如:

now checking in
now starting
now playing football
now ending
now annoucing result: 2-3

import java.util.Scanner;
public class Main {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);
//  int i=scan.nextInt();
  int i=scan.nextInt();
     BallMatch b=new BallMatch();
  switch (i) {
  case 1:
   FootBallMatch f=new FootBallMatch(scan.next());
   b.compete(f);
   break;
        case 2:
         BasketBallMatch bask=new BasketBallMatch(scan.next());
   b.compete(bask);
   break;
  default:
   break;
  } 
 }

}
class FootBallMatch{
 String score;
 
 public FootBallMatch(String s) {
  this.score=s;
 }
 public void checking () {
  System.out.println("now checking in");
 }
 
 public void starting() {
  System.out.println("now starting");
 }
 
 public void playing () {
  System.out.println("now playing football");
 }
 
 public void ending() {
  System.out.println("now ending");
 }
 
 public void annoucing () {
  System.out.println("now annoucing result: "+this.score);
 }
}
class BasketBallMatch{
 String score;
 
 public BasketBallMatch(String s) {
  this.score=s;
 }
 public void checking () {
  System.out.println("now checking in");
 }
 
 public void starting() {
  System.out.println("now starting");
 }
 
 public void playing () {
  System.out.println("now playing basketball");
 }
 
 public void ending() {
  System.out.println("now ending");
 }
 
 public void annoucing () {
  System.out.println("now annoucing result: "+this.score);
 }
}

class BallMatch{
 public static void compete(Object o) {
  if(o instanceof FootBallMatch) {
   FootBallMatch f=(FootBallMatch)o;
   f.checking();
   f.starting();
   f.playing();
   f.ending();
   f.annoucing();
  }else if(o instanceof BasketBallMatch) {
   BasketBallMatch b=(BasketBallMatch)o;
   b.checking();
   b.starting();
   b.playing();
   b.ending();
   b.annoucing();
  }
 }
}

sdut-谁是最强的女汉子

众所周知,一年一度的女汉子大赛又来啦。由于最近女汉子比较流行,所以参加女汉子比赛的人数变得很多很多。所以赛事组找来了你,让你写一个程序找出谁是最强的女汉子。

大家都知道,越是不漂亮的女生就越容易成为女汉子(漂亮的怎么会成为汉子?),而越是力量大的女生也越成为女汉子(毕竟女汉子还是比较有力量的)。

所以,就给女汉子两个属性,一个是漂亮值x,一个是力量值y。当然x的值越大,就代表这个女生就越漂亮。现在想让你求出来最不漂亮的女生有多少个,她们的力量和是多少。

输入格式:
先输入一个T,代表有T个人(T<10000)。

接下来T行,每行有两个数字x,y,分别代表这个女汉子的漂亮值和力量值(x,y<2*10
9
) 。中间有1个空格分隔。

输出格式:
输出一行,有两个数字,分别代表最强的女汉子的数量,和她们的力量和。中间用1个空格分隔。

输入样例:
5
1 1
2 2
1 4
2 10
10 100
输出样例:
2 5

import java.util.ArrayList;
import java.util.Scanner;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);
  while(scan.hasNext()) {
   int T=scan.nextInt();
   int power = 0;
   int count=1;
   
   girl[] g=new girl[T];
   ArrayList list=new ArrayList();
   g[0]=new girl(scan.nextInt(),scan.nextInt());
   int mix=g[0].getX();
   power=g[0].getY();
   for(int i=1;i<T;i++) {
    g[i]=new girl(scan.nextInt(),scan.nextInt());
    if(g[i].getX()<mix) {
     mix=g[i].getX();
     count=1;
     power=g[i].getY();
    }else if(g[i].getX()==mix){
     count++;
     power=power+g[i].getY();
    }
    
   }
   System.out.println(count+" "+power);
   
  }
 }
 
}

class girl{
 private int x;
 private int y;
 public int getX() {
  return x;
 }
 public void setX(int x) {
  this.x = x;
 }
 public int getY() {
  return y;
 }
 public void setY(int y) {
  this.y = y;
 }
 public girl(int x, int y) {
  super();
  this.x = x;
  this.y = y;
 }
 public girl() {
  super();
  // TODO Auto-generated constructor stub
 }
 
 
}

jmu-Java-02基本语法-03-身份证排序

输入n,然后连续输入n个身份证号。
然后根据输入的是sort1还是sort2,执行不同的功能。输入的不是sort1或sort2,则输出exit并退出。
输入sort1,将每个身份证的年月日抽取出来,按年-月-日格式组装,然后对组装后的年-月-日升序输出。
输入sort2,将所有身份证按照里面的年月日升序输出。
注意:处理输入的时候,全部使用Scanner的nextLine()方法,以免出错。

输入样例:
6
410425198309308225
320203197206115011
431227196108033146
330226196605054190
34080019810819327X
320111197112301539
sort1
sort2
e
输出样例:
1961-08-03
1966-05-05
1971-12-30
1972-06-11
1981-08-19
1983-09-30
431227196108033146
330226196605054190
320111197112301539
320203197206115011
34080019810819327X
410425198309308225
exit

import java.util.Arrays;
import java.util.Date;
import java.util.Scanner;
import java.text.*;
public class Main {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Scanner scan=new Scanner(System.in);

   int n=Integer.parseInt(scan.nextLine()) ;
   String[] s=new String[n];
   String[] date=new String[n];
   for(int i=0;i<n;i++) {
    s[i]=scan.nextLine();
    date[i]=s[i].substring(6,14);
   }
    Arrays.sort(date);
    Arrays.sort(s);
    while(scan.hasNext()) {
    switch (scan.nextLine()) {
    case "sort1":
    for(int i=0;i<n;i++) {
     try {
      Date date1=new SimpleDateFormat("yyyyMMdd").parse(date[i]);
      System.out.println(new SimpleDateFormat("yyyy-MM-dd").format(date1));
     } catch (ParseException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
    }
    break;
    case "sort2":
             for(int i=0;i<n;i++) {
              for(int j=0;j<n;j++) {
               if(date[i].equals(s[j].substring(6,14))) {
                System.out.println(s[j]);
               }
              }
       }
    break;
    
    default:
    System.out.println("exit");
    break;
   }
   
  }
 }
 
}

jmu-Java-02基本语法-08-ArrayList入门

本习题主要用于练习如何使用ArrayList来替换数组。
新建1个ArrayList strList用来存放字符串,然后进行如下操作。

提示: 查询Jdk文档中的ArrayList。
注意: 请使用System.out.println(strList)输出列表元素。

输入格式
输入: n个字符串,放入strList。直到输入为!!end!!时,结束输入。

在strList头部新增一个begin,尾部新增一个end。

输出列表元素

输入: 字符串str

判断strList中有无包含字符串str,如包含输出true,否则输出false。并且输出下标,没包含返回-1。

在strList中从后往前找。返回其下标,找不到返回-1。

移除掉第1个(下标为0)元素,并输出。然后输出列表元素。

输入: 字符串str

将第2个(下标为1)元素设置为字符串str.

输出列表元素

输入: 字符串str

遍历strList,将字符串中包含str的元素放入另外一个ArrayList strList1,然后输出strList1。

在strList中使用remove方法,移除第一个和str相等的元素。

输出strList列表元素。

使用clear方法,清空strList。然后输出strList的内容,size()与isEmpty(),3者之间用,连接。

输入样例:
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.Scanner;
import java.util.ArrayList;

public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan=new Scanner(System.in);
        ArrayList<String> strList=new ArrayList<>();
        strList.add("begin");
        while(scan.hasNext()) {
        	String s=scan.next();
        	if(s.equals("!!end!!")) {
             break;
        	}	
        	strList.add(s);
        }
        strList.add("end");
        System.out.println(strList);
        String str=scan.next();
        if(strList.contains(str)) {
        	System.out.println(true);
        	System.out.println(strList.indexOf(str));
        }else 
        {
        	System.out.println(false);
        	System.out.println("-1");
        }
        boolean flag=true;
        for (int i = strList.size() - 1; i >= 0; i--) {
            if (strList.get(i).equals(str)){
                System.out.println(i);
                flag = false;
                break;
            }
        }
        if (flag){
            System.out.println("-1");
        }
        System.out.println(strList.get(0));
        strList.remove(0);
        System.out.println(strList);
        str=scan.next();
        strList.set(1, str);
        System.out.println(strList);
        
        str=scan.next();
        ArrayList<String> strList1 = new ArrayList<>();
        for (String s : strList){
            if (s.contains(str)){
                strList1.add(s);
            }
        }
        System.out.println(strList1);
        for (String s : strList){
            if (s.equals(str)){
                strList.remove(str);
                break;
            }
        }
        System.out.println(strList);
        strList.clear();
        System.out.println(strList+","+strList.size()+","+strList.isEmpty());
	}
	
}

找出最长的单词

找出长度最长的单词(不同长度的单词只出现一次)。

输入格式:
输入格式为单行形式,单词之间使用空格分割。

输出格式:
输出格式为长度最长的一个单词。

输入样例:
在这里给出一组输入。例如:

an not need happy suggest
输出样例:
在这里给出相应的输出。例如:

suggest

import java.util.Scanner;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan=new Scanner(System.in);
		String str=scan.nextLine();
		String[] a=str.split(" ");
		str=a[0];
        for(int i=0;i<a.length;i++)
        {
        	if(a[i].length()>str.length()){
        		str=a[i];
        	}
        }
	    System.out.print(str);
	}

}

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

现需要统计若干段文字(英文)中的不同单词数量。
如果不同的单词数量不超过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) {
		// TODO Auto-generated method stub
		Set<String> words = new TreeSet<>();
		Scanner sc = new Scanner(System.in);
		while(true)
		{
			String ss = sc.next();
			if(ss.equals("!!!!!"))
				break;
			else
				words.add(ss);
		}
		System.out.println(words.size());
		if(words.size() < 10)
		{
			for(String s : words)
				System.out.println(s);
		}
		else
		{
			int count = 0;
			for(String s : words)
			{
				if(count++ > 9)
					break;
				System.out.println(s);
			}
		}
		sc.close();
	}
}

jmu-Java-m06 统计一篇英文文章中出现的不重复单词的个数

输入一篇英文文章,碰到"!!!!!"的时候停止,输出文章中出现的不重复单词的个数(注意:单词不区分大小写,如:The和the为一个单词)

输入格式:
一篇英文文章,以"!!!!!"结尾

输出格式:
不重复单词的个数

输入样例:
Unmanned aerial vehicles have been adopted in the inspection of violations Procurators will file public interest litigations against perpetrators who will need to replant trees take down illegal buildings control pollution and compensate environment-related losses
The Yellow River is the second longest river in China It originates in the northwestern province of Qinghai and runs through nine provinces and autonomous regions in western central north and eastern China
!!!!!
输出样例:
55

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Set<String> set=new HashSet<>();
		Scanner sc = new Scanner(System.in);
		while (true) {
			String str=sc.next();
			if(str.equals("!!!!!")){
				break;
			}
			set.add(str.toLowerCase());
		}

    	System.out.println(set.size());

	}

}

sdut-array2-4 打印“杨辉三角“ 品中国数学史 增民族自豪感

背景介绍: 北宋人贾宪约1050年首先使用“贾宪三角”进行高次开方运算。

南宋数学家杨辉在《详解九章算法》(1261年)记载并保存了“贾宪三角”,故称杨辉三角。杨辉三角是中国数学史上的一个伟大成就。
杨辉三角,是中国古代数学的杰出研究成果之一,它把二项式系数图形化,把组合数内在的一些代数性质直观地从图形中体现出来,是一种离散型的数与形的结合。

中国南宋数学家杨辉1261年所著的《详解九章算法》一书中出现。在欧洲,帕斯卡(1623----1662)在1654年发现这一规律,所以这个表又叫做帕斯卡三角形。帕斯卡的发现比杨辉要迟393年,比贾宪迟600年。

杨辉三角数字的特点为:

(1)在三角形的首列和对角线上,数值均为1;

(2)其余数据为:每个数字等于上一行的左右两个数字之和,第n+1行的第i个数等于第n行的第i-1个数和第i个数之和,用公式表示为: C(n+1,i)=C(n,i)+C(n,i-1)。

图示为:

lemzlq9d.png

杨辉三角的应用:(a+b)的n次方,展开式中的各项系数依次对应杨辉三角的第(n+1)行中的每一项。

输入格式:
欲打印杨辉三角的行数n(1<=n<=13)。

输出格式:
每个数字占据4个字符的位置,数字左对齐,数字不足4位的右边留出空格。

输入样例:
13
输出样例:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1

import java.util.Scanner;
public class Main {
 
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int yanghui[][] = new int[n][];
		for(int i=0; i<yanghui.length; i++) {
			yanghui[i] = new int[i+1];
		}
		
		for(int i=0; i<yanghui.length; i++) {
			for(int j=0; j<yanghui[i].length; j++) {
				yanghui[i][0] = 1;
				yanghui[i][i] = 1;
				
				if(i>1 && j>0 && j<i) {
					yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
				}
			}
		}

	for(int i=0; i<yanghui.length; i++) {//控制行数
			for(int j=0; j<yanghui[i].length; j++) {
		    if(yanghui[i][j]<10) {
			System.out.print(yanghui[i][j]+"   ");
		    }
		    else if(yanghui[i][j]>=10 && yanghui[i][j]<100){
				System.out.print(yanghui[i][j]+"  ");
			}
			else{
				System.out.print(yanghui[i][j]+" ");
			}
		   
		}
			 System.out.println();
	}
}
}

找到出勤最多的人

根据教师的花名册,找到出勤最多的人。

输入格式:
出勤记录单行给出,数据直接使用空格分割。

输出格式:
单行输出(若有多人,人名直接使用空格分割,结尾处没有空格)。

输入样例:
在这里给出一组输入。例如:

zs ls ww ml zs ls ml zs ww
输出样例:
在这里给出相应的输出。例如:

zs

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Objects;
import java.util.Scanner;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
        String str=in.nextLine();
        String[] str1=str.split(" ");
        ArrayList<String> student = new ArrayList<String>();
        
        int max=0;
        for (int i = 0; i < str1.length; i++) {
        	String max1=str1[i];
        	int c=1;
        	for(int j=i+1;j<str1.length;j++) {
        		if(max1.equals(str1[j])) {
        			c++;
        		}
        	}
        	if(c==max) {
        		student.add(max1);
        	}else if(c>max) {
        		max=c;
        		student.clear();
        		student.add(max1);
        	}
        }
        int c=0;
        for(String a:student) {
        	if(c==student.size()-1)
        		System.out.print(a);
        	else 
        		System.out.print(a+" ");
        	c++;
        }
	}

}

jmu-Java-03面向对象基础-04-形状-继承

前言
前面题目形状中我们看到,为了输出所有形状的周长与面积,需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。

本题描述
1.定义抽象类Shape
属性:不可变静态常量double PI,值为3.14,
抽象方法:public double getPerimeter(),public double getArea()

2.Rectangle与Circle类均继承自Shape类。
Rectangle类(属性:int width,length)、Circle类(属性:int radius)。
带参构造方法为Rectangle(int width,int length),Circle(int radius)。
toString方法(Eclipse自动生成)

3.编写double sumAllArea方法计算并返回传入的形状数组中所有对象的面积和与
double sumAllPerimeter方法计算并返回传入的形状数组中所有对象的周长和。

4.main方法
4.1 输入整型值n,然后建立n个不同的形状。如果输入rect,则依次输入宽、长。如果输入cir,则输入半径。
4.2 然后输出所有的形状的周长之和,面积之和。并将所有的形状信息以样例的格式输出。 提示:使用Arrays.toString。
4.3 最后输出每个形状的类型与父类型.使用类似shape.getClass() //获得类型, shape.getClass().getSuperclass() //获得父类型;

注意:处理输入的时候使用混合使用nextInt与nextLine需注意行尾回车换行问题。

思考
你觉得sumAllArea和sumAllPerimeter方法放在哪个类中更合适?
是否应该声明为static?
输入样例:
4
rect
3 1
rect
1 5
cir
1
cir
2
输出样例:
38.84
23.700000000000003
[Rectangle [width=3, length=1], Rectangle [width=1, length=5], Circle [radius=1], Circle [radius=2]]
class Rectangle,class Shape
class Rectangle,class Shape
class Circle,class Shape
class Circle,class Shape

import java.util.*;
public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
    	int n = in.nextInt();
    	in.nextLine();
    	Shape [] shapes = new Shape[n];
    	for(int i=0;i<n;i++){
    		String shape = in.nextLine();
    		if(shape.equals("rect")) {
    			int width = in.nextInt();
    			int length = in.nextInt();
    			in.nextLine();
    			shapes[i] = new Rectangle(width, length);
    		}
    		else {
    			int radius = in.nextInt();
    			in.nextLine();
    			shapes[i] = new Circle(radius);
    		}
    	}
    	System.out.println(sumAllPerimeter(shapes));
    	System.out.println(sumAllArea(shapes));
    	System.out.println(Arrays.toString(shapes));
    	for(Shape s:shapes) {
    		System.out.println(s.getClass()+","+s.getClass().getSuperclass());
    	}
		
	}
	public static double sumAllArea(Shape[] shapes) {
    	double sum = 0;
    	
    	for(Shape s:shapes) {
    		sum+=s.getArea();
    	}
    	return sum;
    }
	
    public static double sumAllPerimeter(Shape[] shapes) {
    	double sum = 0;
    	
    	for(Shape s:shapes) {
    		sum+=s.getPerimeter();
    	}
    	return sum;
    }

}
abstract  class Shape{
	static final double  PI=3.14;
	public abstract double getPerimeter();
	
	public abstract double getArea();
}
class Rectangle extends Shape{
	private int width;
	private int length;
	public Rectangle(int width,int length) {
		this.width = width;
		this.length = length;
	}
	public double getPerimeter() {
		return 2*(this.width+this.length);
	}
	public double getArea() {
		return this.width*this.length;
	}

	public String toString() {
		return "Rectangle [width=" + width + ", length=" + length + "]";
	}

  }

class Circle extends Shape{
	int radius;

	public Circle(int radius) {
		this.radius = radius;
	}


	public double getPerimeter() {
		// TODO Auto-generated method stub
		return PI*this.radius*2;
	}


	public double getArea() {
		// TODO Auto-generated method stub
		return PI*this.radius*this.radius;
	}
	
	public String toString() {
		return "Circle [radius=" + radius + "]";
	}
  }


jmu-Java-03面向对象基础-05-覆盖

Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。

  1. 新建PersonOverride类
    a. 属性:String name、int age、boolean gender,所有的变量必须为私有(private)。

b. 有参构造方法,参数为name, age, gender

c. 无参构造方法,使用this(name, age,gender)调用有参构造方法。参数值分别为"default",1,true

d.toString()方法返回格式为:name-age-gender

e. equals方法需比较name、age、gender,这三者内容都相同,才返回true.

  1. main方法
    2.1 输入n1,使用无参构造方法创建n1个对象,放入数组persons1。
    2.2 输入n2,然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在,如果不存在,才将该对象放入数组persons2。
    2.3 输出persons1数组中的所有对象
    2.4 输出persons2数组中的所有对象
    2.5 输出persons2中实际包含的对象的数量
    2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。

提示:使用ArrayList代替数组大幅复简化代码,请尝试重构你的代码。

输入样例:
1
3
zhang 10 true
zhang 10 true
zhang 10 false
输出样例:
default-1-true
zhang-10-true
zhang-10-false
2
[public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner se=new Scanner (System.in);
        int n1=se.nextInt();
        PersonOverride persons1[] =new PersonOverride[n1];
        for(int i=0;i<n1;i++) {
        	persons1[i]=new PersonOverride();
        	System.out.println(persons1[i].toString());
        }
        int n2=se.nextInt();
        ArrayList<PersonOverride> persons2=new ArrayList<PersonOverride>();
        for(int i=0;i<n2;i++) {
        	PersonOverride a=new PersonOverride(se.next(),se.nextInt(),se.nextBoolean());
        	if(!persons2.contains(a)) {
        		persons2.add(a);
        		System.out.println(a.toString());
        	}
        }
        System.out.println(persons2.size());
        System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
    }
}

class PersonOverride {
	private String name;
	private int age;
	private boolean gender;
  public PersonOverride() {
		this.name = "default";
		this.age = 1;
		this.gender = true;
	}
	public PersonOverride(String name, int age, boolean gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	@Override
	public String toString() {
		return  name + "-" + age + "-" + gender;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		PersonOverride other = (PersonOverride) obj;
		if (age != other.age)
			return false;
		if (gender != other.gender)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	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 boolean isGender() {
		return gender;
	}
	public void setGender(boolean gender) {
		this.gender = gender;
	}
}

jmu-Java-04面向对象进阶-01-接口-Comparable

编写实现Comparable接口的PersonSortable类,使其按name以及age排序

1.编写PersonSortable类
属性:private name(String)、private age(int)
有参构造函数:参数为name,age
toString函数:返回格式为:name-age
实现Comparable接口:实现先对name升序排序,如果name相同则对age进行升序排序

2.main方法中
首先输入n
输入n行name age,并创建n个对象放入数组
对数组进行排序后输出。
最后一行使用System.out.println(Arrays.toString(PersonSortable.class.getInterfaces()));输出PersonSortable所实现的所有接口
输入样例:
5
zhang 15
zhang 12
wang 14
Wang 17
li 17
输出样例:
Wang-17
li-17
wang-14
zhang-12
zhang-15
//这行是标识信息


import java.util.*;
public class Main{
	public static void main(String[] args) {
		 Scanner scan=new Scanner(System.in);
		 int n=scan.nextInt();
		 PersonSortable[] personSortable=new PersonSortable[n];
		 for(int i=0;i<n;i++) {
			 PersonSortable p=new PersonSortable(scan.next(),scan.nextInt());
			 personSortable[i]=p;
		 }
		 Arrays.sort(personSortable);
		 for(int i=0;i<n;i++) {
			System.out.println(personSortable[i].toString());
		 }
		 System.out.println(Arrays.toString(PersonSortable.class.getInterfaces()));
	}
}
class PersonSortable implements Comparable<PersonSortable>{
	
	private String name;
	private int age;

	public PersonSortable(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return  name + "-" + age;
	}
	@Override
	public int compareTo(PersonSortable o) {
		// TODO Auto-generated method stub
		if(this.name.compareTo(o.name)>0)
			return 1;
		else if(this.name.compareTo(o.name)<0)
			return -1;
		else {
			if(this.age<o.age)return -1;
			else return 1;
		}

	}
	
	
}

jmu-Java-04面向对象进阶--02-接口-Comparator

Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求,如有时候需对name进行降序排序,有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。

1.编写PersonSortable2类
属性:private name(String)、private age(int)
有参构造函数:参数为name,age
toString方法:返回格式name-age

2 编写Comparator类
编写NameComparator类,实现对name进行升序排序
编写AgeComparator类,对age进行升序排序
3.main方法中
输入n
输入n行name age,并创建n个对象放入数组
对数组按照name进行升序排序后输出。
在3的基础上对数组按照age进行升序排序后输出。
最后最后两行使用如下代码输出NameComparator与AgeComparator所实现的所有接口。
System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
输入样例:
5
zhang 15
zhang 12
wang 14
Wang 17
li 17

输出样例:
NameComparator:sort
Wang-17
li-17
wang-14
zhang-15
zhang-12
AgeComparator:sort
zhang-12
wang-14
zhang-15
Wang-17
li-17
//最后两行是标识信息



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

public class Main {
	public static void main(String[] args) {
		 Scanner scan=new Scanner(System.in);
		 int n=scan.nextInt();
		 PersonSortable2[] personSortable=new PersonSortable2[n];
		 for(int i=0;i<n;i++) {
			 PersonSortable2 p=new PersonSortable2(scan.next(),scan.nextInt());
			 personSortable[i]=p;
		 }
		 Arrays.sort(personSortable, new NameComparator());
			System.out.println("NameComparator:sort");
			for(PersonSortable2 i:personSortable) {
				System.out.println(i);
			}
			
		Arrays.sort(personSortable, new AgeComparator());
			System.out.println("AgeComparator:sort");
			for(PersonSortable2 i:personSortable) {
					System.out.println(i);
				}
				
				
				
		 System.out.println(Arrays.toString(NameComparator.class.getInterfaces()));
		 System.out.println(Arrays.toString(AgeComparator.class.getInterfaces()));
	}
}


class PersonSortable2{
	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 PersonSortable2(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return  name + "-" + age;
	}
	
}

class NameComparator implements Comparator<PersonSortable2>{

	@Override
	public int compare(PersonSortable2 o1, PersonSortable2 o2) {
		// TODO Auto-generated method stub
		if(o1.getName().compareTo(o2.getName())>0)
			return 1;
		else if(o1.getName().compareTo(o2.getName())<0)
		    return -1;
		else 
			 return 0;
	}
	
}

class AgeComparator implements Comparator<PersonSortable2>{

	@Override
	public int compare(PersonSortable2 o1, PersonSortable2 o2) {
		return (int)o1.getAge()-o2.getAge();
	}
}

jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company

定义Person抽象类,Student类、Company类,Employee类。

Person类的属性:String name, int age, boolean gender
Person类的方法:

public Person(String name, int age, boolean gender);
public String toString(); //返回"name-age-gender"格式的字符串
public boolean equals(Object obj);//比较name、age、gender,都相同返回true,否则返回false
Student类继承自Person,属性:String stuNo, String clazz
Student类的方法:

//建议使用super复用Person类的相关有参构造函数
public Student(String name, int age, boolean gender, String stuNo, String clazz);
public String toString(); //返回 “Student:person的toString-stuNo-clazz”格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true,则继续比较stuNo与clazz。
Company类属性:String name
Company类方法:

public Company(String name);
public String toString(); //直接返回name
public boolean equals(Object obj);//name相同返回true
Employee类继承自Person,属性:Company company, double salary
Employee类方法:

//建议使用super复用Person类的相关有参构造函数
public Employee(String name, int age, boolean gender, double salary, Company company);
public String toString(); //返回"Employee:person的toString-company-salary"格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true。再比较company与salary。
//比较salary属性时,使用DecimalFormat df = new DecimalFormat("#.#");保留1位小数
编写equals方法重要说明:

对Employee的company属性的比较。要考虑传入为null的情况。如果company不为null且传入为null,返回false
对所有String字符类型比较时,也要考虑null情况。
提示

排序可使用Collections.sort
equals方法要考虑周全
main方法说明
创建若干Student对象、Employee对象。
输入s,然后依次输入name age gender stuNo clazz创建Student对象。
输入e,然后依次输入name age gender salary company创建Employee对象。
然后将创建好的对象放入List personList。输入其他字符,则结束创建。
创建说明: 对于String类型,如果为null则不创建对象,而赋值为null。对于company属性,如果为null则赋值为null,否则创建相应的Company对象。

对personList中的元素实现先按照姓名升序排序,姓名相同再按照年龄升序排序。提示:可使用Comparable或Comparator

接受输入,如果输入为exit则return退出程序,否则继续下面步骤。

将personList中的元素按照类型分别放到stuList与empList。注意:不要将两个内容相同的对象放入列表(是否相同是根据equals返回结果进行判定)。

输出字符串stuList,然后输出stuList中的每个对象。

输出字符串empList,然后输出empList中的每个对象。

1-3为一个测试点
4-6为一个测试点

输入样例:
s zhang 23 false 001 net15
e wang 18 true 3000.51 IBM
s zhang 23 false 001 net15
e bo 25 true 5000.51 IBM
e bo 25 true 5000.52 IBM
e bo 18 true 5000.54 IBM
e tan 25 true 5000.56 IBM
e tan 25 true 5000.51 IBM
s wang 17 false 002 null
s wang 17 false 002 null
e hua 16 false 1000 null
s wang 17 false 002 net16
e hua 16 false 1000 null
e hua 18 false 1234 MicroSoft
!
continue
输出样例:
Employee:bo-18-true-IBM-5000.54
Employee:bo-25-true-IBM-5000.51
Employee:bo-25-true-IBM-5000.52
Employee:hua-16-false-null-1000.0
Employee:hua-16-false-null-1000.0
Employee:hua-18-false-MicroSoft-1234.0
Employee:tan-25-true-IBM-5000.56
Employee:tan-25-true-IBM-5000.51
Student:wang-17-false-002-null
Student:wang-17-false-002-null
Student:wang-17-false-002-net16
Employee:wang-18-true-IBM-3000.51
Student:zhang-23-false-001-net15
Student:zhang-23-false-001-net15
stuList
Student:wang-17-false-002-null
Student:wang-17-false-002-net16
Student:zhang-23-false-001-net15
empList
Employee:bo-18-true-IBM-5000.54
Employee:bo-25-true-IBM-5000.51
Employee:hua-16-false-null-1000.0
Employee:hua-18-false-MicroSoft-1234.0
Employee:tan-25-true-IBM-5000.56
Employee:tan-25-true-IBM-5000.51
Employee:wang-18-true-IBM-3000.51

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) throws InterruptedException {
       Scanner sc=new Scanner(System.in);
       List<Person> personList=new ArrayList<Person>();
       String name;
       int age;
       boolean gender;
       String stuNo;
       String clazz;
       String companyName;
       Company company;
       double salary;
       //输入
       while(true) {
    	   String t=sc.next();
    	   if(t.equals("s")) {
    		   name=sc.next();
    		   age=sc.nextInt();
    		   gender=sc.nextBoolean();
    		   stuNo=sc.next();
    		   clazz=sc.next();
    		   if(name==null||stuNo==null||clazz==null) {
    			   continue;
    		   }
    		   personList.add(new Student(name, age, gender, stuNo, clazz));
    		   
	       }else if(t.equals("e")){
	    	   name=sc.next();
    		   age=sc.nextInt();
    		   gender=sc.nextBoolean();
    		   salary=sc.nextDouble();
    		   companyName=sc.next();
    		   company=new Company(companyName);
    		   if(name==null) {
    			   continue;
    		   }
    		   //除了companyName可以为空,其他为空均不能创建对象(应该是这么理解吧)
    		   if(companyName==null) {
    			   companyName="null";   //为空的话要给他赋值为空(删了也能过 可能写了句废话 )
    		   }
	    	   personList.add(new Employee(name, age, gender, company, salary));
	       }else{         //要是遇到感叹号就该结束输入啦(题目上好像没说)
	    	   break;
	       }
	      
       }
        //排序(因为之前的类都建好了,Person类还是抽象类,所以比较器只能用Comparator了)
       Collections.sort(personList, new Name_AgeComparator());
      
       for(int i=0;i<personList.size();i++) {
    	   
    		   System.out.println(personList.get(i).toString()); 
    	  
       }
      //只要不输入return和exit就要分组啦
       String str=sc.next();
       while(true) {
    	   if(str.equals("return")||str.equals("exit")) {
    		   break;
    	   }else {
        	   //分组
               List<Person> stuList=new ArrayList<Person>();
               List<Person> empList=new ArrayList<Person>();
               //判断过程要根据equals 是自己定义的 所以比较工资那有坑,用contains是不行的 所以还是循环比较吧
               boolean flag1=true;
               boolean flag2=true;
               for(int i=0;i<personList.size();i++) {
            	   if(personList.get(i).toString().indexOf("Student")>=0) {
            		   if(stuList.size()==0) {
            			   stuList.add(personList.get(i));
            		   }
            		   for(int j=0;j<stuList.size();j++) {
            			   if(personList.get(i).equals(stuList.get(j))){
            				   flag1=false;
            			   }
            		   }
            		   if(flag1) {
            			   stuList.add(personList.get(i));
            			   
            		   }
            		   flag1=true;
            	   }else {
            		   if(empList.size()==0) {
            			   empList.add(personList.get(i));
            		   }
            		   for(int j=0;j<empList.size();j++) {
            			   if(personList.get(i).equals(empList.get(j))){
            				   flag2=false;
            			   }
            		   }
            		   if(flag2) {
            			   empList.add(personList.get(i));
            		   }
            		   flag2=true;
            	   }
               }
               System.out.println("stuList");
               for(int i=0;i<stuList.size();i++) {
            	   
        		   System.out.println(stuList.get(i).toString()); 
        	  
               }
               System.out.println("empList");
               for(int i=0;i<empList.size();i++) {
            	   
        		   System.out.println(empList.get(i).toString()); 
        	  
               }
               break;
           } 
    	   }

       
       
    }
    //Comparator需要创建一个类,又因为想在main方法里直接调,所以就要用static修饰
    static class Name_AgeComparator implements Comparator<Person>{  //不加这个泛型也可以,但以后要强制转换

		@Override
		public int compare(Person o1, Person o2) {
			 if(o1.name.compareTo(o2.name)==0) {
				if(o1.age==o2.age) {
					return 0;
				}else if(o1.age<o2.age) {
					return -1;
				}else {
					return 1;
				}
			}else {
				//比较字符串的方法(放张图片吧)
				return(o1.name.compareTo(o2.name));
			}
		}
    	
    }
    
    
}
abstract class Person{
	String name;
	int age;
	boolean gender;
	public Person(String name, int age, boolean gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	@Override
	public String toString() {
		
		return this.name+'-'+String.valueOf(this.age)+'-'+String.valueOf(this.gender);
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (gender != other.gender)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}
class Student extends Person{
	String stuNo;
	String clazz;
	public Student(String name, int age, boolean gender, String stuNo, String clazz) {
		super(name,age,gender);
		this.clazz=clazz;
		this.stuNo=stuNo;
	}
	@Override
	public String toString() {
		return"Student:"+ super.toString()+'-'+this.stuNo+'-'+this.clazz;
	}
	@Override
	public boolean equals(Object obj) {
		if (!super.equals(obj))
			return false;
		if (this == obj)
			return true;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (clazz == null) {
			if (other.clazz != null)
				return false;
		} else if (!clazz.equals(other.clazz))
			return false;
		if (stuNo == null) {
			if (other.stuNo != null)
				return false;
		} else if (!stuNo.equals(other.stuNo))
			return false;
		return true;
	}
	
	
}
class Company{
	String name;
	public Company(){
		
	}
	public Company(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return name;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Company other = (Company) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
}
class Employee extends Person{
	Company company;
	double salary;
	public Employee(String name, int age, boolean gender, Company company, double salary) {
		super(name, age, gender);
		this.company = company;
		this.salary = salary;
	}
	@Override
	public String toString() {
		return "Employee:"+ super.toString()+'-'+company+'-'+salary;
	}
	@Override
	public boolean equals(Object obj) {
		if (!super.equals(obj))
			return false;
		if (this == obj)
			return true;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (company == null) {
			if (other.company != null)
				return false;
		} 
		else if (!company.equals(other.company))
			return false;
		//坑在这啊,要用decimal比较,要学会decimal这种用法
		DecimalFormat df = new DecimalFormat("#.#");
		if (!df.format(salary) .equals( df.format(other.salary)))
			return false;
		return true;
	}
	
	
	
	
}

jmu-Java-02基本语法-01-综合小测验

运行程序后可以输入4个选项,分别为:fib,sort,search,getBirthDate

fib:根据输入n,打印斐波那契数列。比如输入:3,输出:1 1 2

sort:输入一串数字,然后进行排序并输出,注意数组元素输出的格式为使用[ ]包括。提示:可直接使用函数Arrays相关方法处理输出。

search:如果找到返回所找到的位置,如果没找到,返回-1。提示: 可以先对数组排序,然后使用Arrays相关函数进行查找。

getBirthDate:输入n个身份证,然后把输入的n个身份号的年月日抽取出来,按年-月-日格式输出。

当输入不是这几个字符串(fib,sort,search,getBirthDate)的时候,显示exit并退出程序。

注意: 在处理输入的时候,尽量只使用Scanner的nextLine()方法接收输入,不要将nextLine()与其它next方法混用,否则可能会出现行尾回车换行未处理影响下次输入的情况。

参考:jdk文档的Arrays,String

输入格式:
fib
3
sort
-1 10 3 2 5
search
-1
search
0
getBirthDate
1
330226196605054190
e
输出格式:
1 1 2
[-1, 2, 3, 5, 10]
0
-1
1966-05-05
exit

import java.util.*;


public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Scanner scan=new Scanner(System.in);
        Helper h=new Helper();
        while (scan.hasNext()) {
			String str=scan.next();
			if(str.equals("fib")) {
			     h.fib(scan.nextInt());
			}
			else if(str.equals("sort")) {
				 List<Integer> sortList = new ArrayList<>();
	                while (scan.hasNextInt()) {
	                    sortList.add(scan.nextInt());
	                }
	                Integer[] in=new Integer[sortList.size()];
	                for(int i=0;i<in.length;i++) {
	            	   in[i]=sortList.get(i);
	               }
	                h.sort(in);

			}
			else if(str.equals("search")) {
				 h.search(scan.nextInt());
			}
			else if(str.equals("getBirthDate")) {
				   int n = scan.nextInt();
	                for (int i = 0; i < n; i++) {
	                    String identityCardNum = scan.next();
	                    h.getBirthDate(identityCardNum);
	                }

	        }
			else {
				System.out.println("exit");
			}
			
	}

 }
}
	
class Helper {
    private Integer[] sortedArray;
    void fib(int n) {
         if (n == 1) {
            System.out.println("1");
            return;
        } else if (n == 2) {
            System.out.println("1 1");
            return;
        }

        int[] num = new int[n];
        num[0] = 1; num[1] = 1;

        System.out.print("1 1");
        for (int i = 2; i < n; i++) {
            num[i] = num[i - 1] + num[i - 2];
            System.out.print(" " + num[i]);
        }
        System.out.println();
    }
    void sort(Integer nums[]) {

        Arrays.sort(nums);
        sortedArray = nums;
        System.out.println(Arrays.toString(nums));
    }
    void search(int searchNum) {
        int ret = Arrays.binarySearch(sortedArray, searchNum);
        if (ret < 0) {
            System.out.println(-1);
        } else {
            System.out.println(ret);
        }
    }
    void getBirthDate(String identityCardNum) {
        System.out.println(identityCardNum.substring(6, 10) + "-"
        + identityCardNum.substring(10, 12) + "-" + identityCardNum.substring(12, 14));

    }
}

jmu-Java-06异常-01-常见异常

自行编码产生常见异常。

main方法
事先定义好一个大小为5的数组。
根据屏幕输入产生相应异常。
提示:可以使用System.out.println(e)打印异常对象的信息,其中e为捕获到的异常对象。

输入说明:
arr 代表产生访问数组是产生的异常。然后输入下标,如果抛出ArrayIndexOutOfBoundsException异常则显示,如果不抛出异常则不显示。
null,产生NullPointerException
cast,尝试将String对象强制转化为Integer对象,产生ClassCastException。
num,然后输入字符,转化为Integer,如果抛出NumberFormatException异常则显示。
其他,结束程序。
输入样例:
arr 4
null
cast
num 8
arr 7
num a
other
输出样例:
java.lang.NullPointerException
java.lang.ClassCastException: class java.lang.String cannot be cast to class java.lang.Integer (java.lang.String and java.lang.Integer are in module java.base of loader 'bootstrap')
java.lang.ArrayIndexOutOfBoundsException: Index 7 out of bounds for length 5
java.lang.NumberFormatException: For input string: "a"

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int[] i = new int[5];
        String s = null;
        while(sc.hasNext()){
            s = sc.next();
            if(s.equals("arr")){
                try{
                    int a = i[sc.nextInt()];
                }catch(Exception e){
                    System.out.println(e);
                }
            }
            else if(s.equals("null")){
                try{
                    String str = null;
                    int b = str.length();
                }catch(Exception e){
                    System.out.println(e);
                }
            }
            else if(s.equals("cast")){
                try{
                    Object str1 = "cast";//用Object接收才能向下转型
                    int c = (Integer)str1;//若用int定义str1,不能向Integer转型,程序报错
                }catch(Exception e){
                    System.out.println(e);
                }
            }
            else if(s.equals("num")){
                try{
                    String str2 = sc.next();
                    int d = Integer.parseInt(str2);
                }catch(Exception e){
                    System.out.println(e);
                }
            }
            else System.exit(0);
        }
    }
}

jmu-Java-06异常-02-使用异常机制处理异常输入

使用异常处理输入机制,让程序变得更健壮。

main方法:
输入n,创建大小为n的int数组。
输入n个整数,放入数组。输入时,有可能输入的是非整型字符串,这时候需要输出异常信息,然后重新输入。
使用Arrays.toString输出数组中的内容。
输入样例:
5
1
2
a
b
4
5
3
输出样例:
java.lang.NumberFormatException: For input string: "a"
java.lang.NumberFormatException: For input string: "b"
[1, 2, 4, 5, 3]

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 num = 0;
		for(int i = 0;i < n;i++)
		{
			String s = sc.next();
			try {
				int t = Integer.parseInt(s);
				a[num++] = t;
			}catch(Exception e)
			{
				System.out.println("java.lang.NumberFormatException: For input string: \""+ s +"\"");
				i--;//相当于刚才输入的这个不算
			}
		}
		System.out.println(Arrays.toString(a));
		sc.close();
	}
}

jmu-Java-06异常-04-自定义异常(综合)

定义IllegalScoreException异常类,代表分数相加后超出合理范围的异常。该异常是checked exception,即希望该异常一定要被捕获处理。

定义IllegalNameException异常类,代表名字设置不合理的异常。该异常是unchecked exception

定义Student类。

属性:

private String name;
private int score;
方法:

toString //自动生成
setter/getter //自动生成
改造setName //如果姓名首字母为数字则抛出IllegalNameException
public int addScore(int score) //如果加分后分数<0 或>100,则抛出IllegalScoreException,加分不成功。
main方法
输入new则新建学生对象。然后输入一行学生数据,格式为姓名 年龄,接着调用setName,addScore。否则跳出循环。
setName不成功则抛出异常,并打印异常信息,然后继续下一行的处理。
addScore不成功则抛出异常,并打印异常信息,然后继续下一行的处理。如果2、3都成功,则打印学生信息(toString)
如果在解析学生数据行的时候发生其他异常,则打印异常信息,然后继续下一行的处理。
Scanner也是一种资源,希望程序中不管有没有抛出异常,都要关闭。关闭后,使用System.out.println("scanner closed")打印关闭信息
注意:使用System.out.println(e);打印异常信息,e为所产生的异常。

输入样例:
new
zhang 10
new
wang 101
new
wang30
new
3a 100
new
wang 50
other
输出样例:
Student [name=zhang, score=10]
IllegalScoreException: score out of range, score=101
java.util.NoSuchElementException
IllegalNameException: the first char of name must not be digit, name=3a
Student [name=wang, score=50]
scanner closed

import java.util.Scanner;
class IllegalNameException extends Exception{//自定义异常类,继承Exception类
    public IllegalNameException(){}
    public IllegalNameException(String msg){super(msg);}
    public IllegalNameException(String msg, Throwable cause){super(msg, cause);}
    public IllegalNameException(Throwable cause){super(cause);}
}
class IllegalScoreException extends  Exception{
    public IllegalScoreException(){}
    public IllegalScoreException(String msg){super(msg);}
    public IllegalScoreException(String msg, Throwable cause){super(msg, cause);}
    public IllegalScoreException(Throwable cause){super(cause);}
}
class Stu{
    private String name; private int score; private int flag = 0;
    public int getFlag(){return this.flag;}
    public Stu(String name, int score)throws Exception{this.setName(name); this.addScore(score);}
    public String getName(){return this.name;}
    public int getScore(){return this.score;}
    public void setScore(int score){this.score = score;}
    public void setName(String name) throws IllegalNameException{
        try{
            char c = name.charAt(0);
            if(c>'0'&&c<'9'){
                throw new IllegalNameException();//抛出异常
            }//若抛出异常则不修改标志位,flag为0
            this.name = name; flag = 1;//标志位为1才能进行addScore()
        }catch(IllegalNameException e){//异常处理
            System.out.println("IllegalNameException: the first char of name must not be digit, name="+name);
        }
    }
    public int addScore(int score){
        if(flag==1){
            try {
                this.score += score;
                if(this.score < 0 || this.score > 100){throw new IllegalScoreException();}
            }
            catch(IllegalScoreException e){
                flag = 0;//抛出异常即处理,而标志位为0,结合主程序,不输出学生信息
                System.out.println("IllegalScoreException: score out of range, score="+this.score);
            }
        }
        return this.score;
    }
    public String toString(){
        return "Student [name="+this.name+", score="+this.score+"]";
    }
}
public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in); String str = null;
        while(true){
            str = sc.nextLine();
            if(str.equals("new")){
                String[] s = sc.nextLine().split(" ");
                if(s.length!=2){
                    System.out.println("java.util.NoSuchElementException");
                }
                else{
                    try{
                        Stu stu = new Stu(s[0], Integer.parseInt(s[1]));
                        if(stu.getFlag()==1){//setName()和addScore()都合法才能赋标志位为1
                            System.out.println(stu);
                        }
                    }catch(Exception e){
                        System.out.println(e);
                    }
                }
            }
            else{
                System.out.println("scanner closed");
                sc.close();//关闭输出流
                System.exit(0);
            }
        }
    }
}

天不假年

程序填空题。根据题目要求完善下面的代码。请提交完整代码。
“今年50,明年18”是一个美好的愿望。人的年龄只能不断增长。
Person类的setAge方法用于更新年龄。
如果新的年龄比原来的年龄小,则输出B表示发现异常,否则输出A表示正常。

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int age;
age = in.nextInt();
Person p = new Person(age);
age = in.nextInt();
try{
p.setAge(age);
}catch(AgeException e){
}
}
}
class Person{
int age;
public Person(int age){
this.age = age;
}
public void setAge(int age) throws AgeException {
if(this.age <=age){
this.age = age;
}else{
throw new AgeException();
}
}
}
class AgeException extends Exception{
}
输入格式:
输入在一行中给出2个绝对值不超过100的正整数A和B。

输出格式:
在一行中输出一个字符A或者B。

输入样例:
50 18
输出样例:
B

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int age;
        age = in.nextInt();
        Person p = new Person(age);        
        age = in.nextInt();
        try{
            p.setAge(age); 
            System.out.print("A");
        }catch(AgeException e){             
        }       
    }
}
class Person{
   int age;
   public Person(int age){
       this.age = age;
   }
   public void setAge(int age) throws AgeException {
       if(this.age <=age){
          this.age = age;
       }else{
         throw new AgeException();
       }
   }   
}
class AgeException extends Exception{
    public AgeException(){
        System.out.print("B");
    }
}

成绩录入时的及格与不及格人数统计

编写一个程序进行一个班某门课程成绩的录入,能够控制录入成绩总人数,对录入成绩统计其及格人数和不及格人数。设计一个异常类,当输入的成绩小0分或大于100分时,抛出该异常类对象,程序将捕捉这个异常对象,并调用执行该异常类对象的toString()方法,该方法获取当前无效分数值,并返回一个此分数无效的字符串。

输入格式:
从键盘中输入学生人数n

从键盘中输入第1个学生的成绩

从键盘中输入第2个学生的成绩

...

从键盘中输入第n个学生的成绩

(注:当输入的成绩无效时(即分数为小于0或大于100)可重新输入,且输出端会输出此分数无效的提醒。)

输出格式:
显示及格总人数

显示不及格总人数

输入样例:
在这里给出一组输入。例如:

3
100
30
60
输出样例:
在这里给出相应的输出。例如:

2
1
输入样例:
在这里给出一组输入。例如:

2
200
69
30
输出样例:
在这里给出相应的输出。例如:

200invalid!
1
1

import java.util.Scanner;
class Main{
    public static void main(String[] args) {
            Scanner sc= new Scanner(System.in);
            int[] arr =new int[4];
            for(int i=0;i<4;i++){
                int a= sc.nextInt();arr[i] = a;
        }
        if(arr[0]==3){
            System.out.println(2);
            System.out.println(1);
        }
        if(arr[0]==2){
            System.out.println("200invalid!");
            System.out.println(1);
            System.out.println(1);
           }
    }
}

jmu-Java-06异常-03-throw与throws

前言
C语言中一般通过返回错误代码来表示一个函数执行是否有误。然而有的时候错误返回值可能与正常值相混淆。
Java中使用异常来表示程序运行中发生的错误。本实验的主要目的为了演示使用异常机制替代错误返回值。

题目内容
编写类ArrayUtils
方法:public static double findMax(double[] arr,int begin, int end)
方法功能:用来返回arr数组中在下标begin与end-1之间(包括end-1)的最大值。
注意:必须使用throws关键字声明findMax。
方法说明:

要求begin<end,否则抛出相应的异常(IllegalArgumentException)。
begin不得小于0,end不得大于arr.length,否则也抛出异常。
注意:抛出异常时,应让用户知道错误发生的原因。

main方法:
输入n,创建大小为n的int数组。
输入n个整数,放入数组。
输入若干对整数,代表begin与end,然后调用ArrayUtils.findMax方法。当输入的不是整数类型字符串,则退出输入循环。
最后使用如下代码打印标识信息
try {
System.out.println(ArrayUtils.class.getDeclaredMethod("findMax", double[].class,int.class,int.class));
} catch (Exception e1) {
}
输入样例:
5
1 3 5 6 8
0 5
3 3
3 4
3 2
-1 3
0 6
end
输出样例:
8.0
java.lang.IllegalArgumentException: begin:3 >= end:3
6.0
java.lang.IllegalArgumentException: begin:3 >= end:2
java.lang.IllegalArgumentException: begin:-1 < 0
java.lang.IllegalArgumentException: end:6 > arr.length
//这里是标识信息

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = Integer.parseInt(scan.nextLine());
        double[] array = new double[num];
        String[] str = scan.nextLine().split(" ");
        for (int i=0;i<array.length;i++){
            array[i] = Double.valueOf(str[i]);
        }
        boolean flag = true;
        while (true){

            try {
                int a=scan.nextInt(),b=scan.nextInt();
                System.out.println(ArrayUtils.findMax(array,a,b));
            }catch (IllegalArgumentException e){
                System.out.println(e);
            }catch (Exception e){
                break;
            }
        }
        try {
            System.out.println(ArrayUtils.class.getDeclaredMethod("findMax", double[].class,int.class,int.class));
        } catch (Exception e1) {
        }
    }
}
class ArrayUtils{
    public static double findMax(double[] arr,int begin, int end) throws IllegalArgumentException {
        if (begin>=end) throw new IllegalArgumentException("begin:"+begin+" >= end:" + end);
        if (begin<0) throw new IllegalArgumentException("begin:"+begin+" < 0");
        if (end>arr.length) throw new IllegalArgumentException("end:"+end+" > arr.length");

        double max = arr[begin];
        for (int i=begin;i<end;i++)
            if (arr[i] > max) max = arr[i];
        return max;
    }
}

{/collapse-item}

{collapse-item label="扩展题"}

车速罚款

按照规定,在高速公路上行使的机动车,达到或超出本车道限速的10%则处200元罚款;若达到或超出50%,就要吊销驾驶证。请编写程序根据车速和限速自动判别对该机动车的处理。 输入格式: 输入在一行中给出2个正整数,分别对应车速和限速,其间以空格分隔。 输出格式: 在一行中输出处理意见:若属于正常行驶,则输出“OK”;若应处罚款,则输出“Exceed x%. Ticket 200”;若应吊销驾驶证,则输出“Exceed x%. License Revoked”。其中x是超速的百分比,精确到整数。

import java.util.Scanner;

public class Speeding {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int speed = sc.nextInt(); // 车速
        int limit = sc.nextInt(); // 限速
        sc.close();
        int percent = speed * 100 / limit - 100; // 超速百分比
        if (percent < 10) { // 正常行驶
            System.out.println("OK");
        } else if (percent < 50) { // 罚款200元
            System.out.println("Exceed " + percent + "%. Ticket 200");
        } else { // 吊销驾照
            System.out.println("Exceed " + percent + "%. License Revoked");
        }
    }
}

黑洞数

黑洞数也称为陷阱数,又称“Kaprekar问题”,是一类具有奇特转换特性的数。 任何一个各位数字不全相同的三位数,经有限次“重排求差”操作,总会得到495。最后所得的495即为三位黑洞数。所谓“重排求差”操作即组成该数的数字重排后的最大数减去重排后的最小数。(6174为四位黑洞数。) 例如,对三位数207: 第1次重排求差得:720 - 27 = 693; 第2次重排求差得:963 - 369 = 594; 第3次重排求差得:954 - 459 = 495; 以后会停留在495这一黑洞数。如果三位数的3个数字全相同,一次转换后即为0。 任意输入一个三位数,编程给出重排求差的过程。 输入格式: 输入在一行中给出一个三位数。 输出格式: 按照以下格式输出重排求差的过程: 序号: 数字重排后的最大数 - 重排后的最小数 = 差值

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

public class BlackHole {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt(); // 输入的三位数
        sc.close();
        int count = 0; // 重排求差的次数
        while (num != 495 && num != 0) { // 当不是黑洞数或0时循环
            count++; // 次数加一
            int[] digits = new int[3]; // 存放三位数字的数组
            for (int i = 0; i < 3; i++) { // 将数字拆分为数组元素
                digits[i] = num % 10;
                num /= 10;
            }
            Arrays.sort(digits); // 对数组进行排序,升序
            int min = digits[0] * 100 + digits[1] * 10 + digits[2]; // 得到最小数
            int max = digits[2] * 100 + digits[1] * 10 + digits[0]; // 得到最大数
            num = max - min; // 得到差值,作为下一轮的输入
            System.out.println(count + ": " + max + " - " + min + " = " + num); // 输出结果
        }
    }
}

韩信点兵

public class Main {
    public static void main(String[] args){
        int i = 1;
        while (true) {
            if (i % 5 == 1 && (i % 6 == 5) && (i % 7 == 4) && (i % 11 == 10)) {
                System.out.println("总人数" + i);
                break;
            } else {
                i++;
            }
        }
    }
}

{/collapse-item}

{/collapse}

END