java简单题目（一个比较简单的java题，麻烦各位大侠帮帮忙，好的追加分）

本文目录

• 一个比较简单的java题，麻烦各位大侠帮帮忙，好的追加分
• java几道简单的选择题
• 5道简单java选择题
• 简单的java题
• JAVA编程的几个简单题目

一个比较简单的java题，麻烦各位大侠帮帮忙，好的追加分

这是以前学JAVA时做过的例子,可直接用
/*
* 测试类（包含main方法）
*/
public class HelloWorld
{
public static void main(String args)
{
Dog animal1 = new Dog();
Cat animal2 = new Cat();
Frog animal3 = new Frog();
if(animal1.isMammal())
System.out.println("狗是哺乳动物");
else
System.out.println("狗不是哺乳动物");
if(animal1.isCarnivorous())
System.out.println("狗是肉食动物");
else
System.out.println("狗不是肉食动物");
System.out.println("狗通常的情况下，和人打招呼的方式为：" +animal1.sayHello());
System.out.println("狗被抚摸情绪好的时候，打招呼的方式是： " +animal1.sayHello(Animal.COMFORTED));
System.out.println("狗烦躁的时候，会： " +animal1.sayHello(Animal.SCARED));
System.out.println("狗有" +animal1.getNumberOfLegs()+"条腿");
System.out.println();
if(animal2.isMammal())
System.out.println("猫是哺乳动物");
else
System.out.println("猫不是哺乳动物");
if(animal2.isCarnivorous())
System.out.println("猫是肉食动物");
else
System.out.println("猫不是肉食动物");
System.out.println("猫通常的情况下，和人打招呼的方式为： " +animal2.sayHello());
System.out.println("猫情绪好的时候会： " +animal2.sayHello(Animal.COMFORTED));
System.out.println("猫烦躁的时候会：" +animal2.sayHello(Animal.SCARED));
System.out.println("猫有" +animal2.getNumberOfLegs()+"条腿");
System.out.println();
if(animal3.isMammal())
System.out.println("青蛙是哺乳动物");
else
System.out.println("青蛙不是哺乳动物");
if(animal3.isCarnivorous())
System.out.println("青蛙是肉食动物");
else
System.out.println("青蛙不是肉食动物");
System.out.println("青蛙通常的情况下，打招呼的方式为：" +animal3.sayHello());
System.out.println("青蛙情绪好的时候会： " +animal3.sayHello(Animal.COMFORTED));
System.out.println("青蛙受到惊吓是会：" +animal3.sayHello(Animal.SCARED));
if(animal3.getLaysEggs())
System.out.println("青蛙产卵");
else
System.out.println("青蛙不产卵");
if(animal3.getGillFlag())
System.out.println("青蛙有鳃");
else
System.out.println("青蛙没有鳃");
System.out.println("青蛙有" +animal3.getNumberOfLegs()+"条腿");
}
}
/********************************************** 抽象父类 ***********************************************/
abstract class Animal
{
// 下面的两个属性被声明为 public 类型的，而且是静态的
public static final int SCARED = 1;//情绪好
public static final int COMFORTED = 2;//情绪不好，烦躁
//下面的属性被声明为保护类型的，允许在子类中访问
protected boolean mammal = true; //是否哺乳动物属性
protected boolean carnivorous = true; //是否食肉动物属性
protected int mood = COMFORTED;//情绪属性
public boolean isMammal() //判断是否哺乳动物
{
return(mammal);
}
public boolean isCarnivorous() //判断是否食肉动物
{
return(carnivorous);
}
abstract public String sayHello(); //打招呼的方式，该方法是抽象的，所以必须在子类中实现
abstract public String sayHello(int moodval);
public void setMood(int newValue) //设置情绪值
{
mood = newValue;
}
public int getMood() //返回情绪值
{
return(mood);
}
}
/********************************************** 陆生动物接口 ***********************************************/
interface LandAnimal
{
public int getNumberOfLegs(); //返回有多少只脚
}
/********************************************** 水生动物接口 ***********************************************/
interface WaterAnimal
{
public boolean getGillFlag(); //返回是否有腮
public boolean getLaysEggs(); //返回是否产卵
}
/********************************************** 狗类：继承动物类，实现陆生动物接口 *************************/
class Dog extends Animal implements LandAnimal
{
// 下面的属性被声明为私有的，并初始化。
private int numberOfLegs = 4;
// 缺省构造函数确保属性能够正确设置
public Dog()
{
mammal = true; //是哺乳动物
carnivorous = true; //是食肉动物
}
// 重载父类的方法
public String sayHello()
{
return("摇摇尾巴");
}
public String sayHello(int moodval)
{
this.setMood(moodval);
switch (mood) {
case SCARED:
return("呜呜叫");
case COMFORTED:
return("旺旺旺叫");
}
return("摇摇尾巴");
}
// 实现 LandAnimal接口
public int getNumberOfLegs()
{
return(numberOfLegs);
}
}
/********************************************** 猫类：继承动物类，实现陆生动物接口 *************************/
class Cat extends Animal implements LandAnimal
{
//声明并初始化猫的两个属性
private int numberOfLegs = 4;
private boolean tailFlag = true;
// 缺省构造函数
public Cat()
{
mammal = true;
carnivorous = true;
}
// 重载父类的方法
public String sayHello()
{
return("喵喵叫");
}
public String sayHello(int moodval)
{
this.setMood(moodval);
switch (mood) {
case SCARED:
return("嘶嘶叫");//如果情绪烦躁的话，就“嘶嘶叫”
case COMFORTED:
return("咕噜咕噜叫"); //如果情绪好的话，发出“咕噜咕噜”声
}
return("喵喵叫"); //如果情绪好的话，发出“喵～”声
}
// 实现 LandAnimal接口
public int getNumberOfLegs()
{
return(numberOfLegs);
}
}
/**************************** 青蛙类：继承动物类，实现陆生动物接口，实现水生动物接口 *********************/
class Frog extends Animal implements LandAnimal, WaterAnimal
{
//声明并初始化青蛙的四个属性
private boolean gillFlag = true;
private boolean laysEggs = true;
private int numberOfLegs = 4;
private boolean tailFlag = true;
//缺省构造函数
public Frog()
{
mammal = false;
carnivorous = false;
}
// 重写父类的“打招呼”的方法
public String sayHello()
{
return("呱呱呱");
}
public String sayHello(int moodval)
{
this.setMood(moodval);
switch (mood) {
case SCARED:
return("扑通一声跳入水中");
case COMFORTED:
return("呱呱呱");
}
return("呱呱呱");
}
// 实现 WaterAnimal接口
public boolean getGillFlag()
{
return(gillFlag);
}
public boolean getLaysEggs()
{
return(laysEggs);
}
// 实现 LandAnimal接口
public int getNumberOfLegs()
{
return(numberOfLegs);
}
}

java几道简单的选择题

(6) 类与对象的关系是( )。
A 类是对象的抽象
----------------------------------------
(7) 下面程序的输出结果是( )。
A Total is 285
----------------------------------------
(8) 以下哪种循环体能保证进入执行( ) 。
C do – while
----------------------------------------
(10) 完全封装类的实现细节应该使用访问权限( ) 。
D private
----------------------------------------
(11) 下列程序段的输出是 ( )
C 编译不能通过
continue 只能loop里用
----------------------------------------
(12) 获取数组temp的长度用( ) .
C temp.length;
----------------------------------------
(13) 设tmp是一个数组类成员，以下哪个选项声明并初始化一个4个元素的数组？( )
A int tmp={1,2,3,4};
----------------------------------------
(14) 程序要调用已定义的包中的类时，可用哪种方法？( ) 。
B import 类名

5道简单java选择题

6、 已知有一个多线程类myThread，除run方法外还包含一个方法void disp()。以下说法正确的是【 】
A) myThread mt=new myThread(); mt.start();mt.disp();运行完线程体run方法后再运行disp()方法
B) myThread mt=new myThread();mt.disp();mt.start();运行完disp()后才能启动线程体run
C) myThread mt=new myThread();mt.start();mt.disp();线程体run一定会在disp结束前结束。
D) myThread mt=new myThread();mt.start();mt.disp();mt.start()和mt.disp()两条命令，哪条放在前面哪条放在后面运行结果一样。
7、 以下说法不正确的是【 】
A) private修饰的成员变量可以在本类或其本包中子类中使用 不正确，只能在本类中访问
B) java类可以同时实现多个接口，但只能继承一个父类 正确
C) static修饰的成员变量可以不经过实例化直接通过类名引用 正确
D) static不可以和abstract修饰符同时使用。 正确
8、 在myweb.htm页面中有如下代码，下列说法不正确的是【 】
《applet width="400" height="300" code="myClock.class" archive="c.jar"》
《/applet》
A) 打包命令jar cf c.jar myClock.class。正确
B) myClock类必须是Applet的子类。 正确
C) myClock类不能独立运行。 错误
D) myClock.class必须放在myweb.htm所在目录下。正确
9、 有如下代码：
public class T {
private int a = 10;
int m = 12;
static int n=1;
public static void main(String arg) {
T t = new T ();
System.out.println(__________);
} }
在空格处如下哪个使用是错误的？【 】
A) t.f
B) this.m 错误，静态方法中不能使用非静态的this对象
C) t.m
D) T.n
10、 有类Copy编译后产生如下错误提示,需要修改的地方是【 】
import java.io.*;
运行时提示错误为：
Copy.java:11:可能损失精度
找到：int
需要：char
while((c=in.read())!=-1)
public class Copy
{ public static void main(String args) throws Exception
{File inputFile = new File("in.txt");
File outputFile = new File("out.txt");
FileReader in = new FileReader(inputFile); ①
FileWriter out = new FileWriter(outputFile);
char c; ②
while ((c = in.read()) != -1) ③
out.write(c); ④
in.close();
out.close();
}
}
A) ①
B) ②
C) ③ IO操作可能残生异常
D) ④
我的答案是： BACBC

简单的java题

1创建学生类
public class Student {
private String sNo;
private String sName;
private int sAge;
private double sScore;

public Student(String n1, String n2, int n3, double n4)
{
sNo=n1;
sName=n2;
sAge=n3;
sScore=n4;
}
public String getNo() {
return sNo;
}

public String getName() {
return sName;
}

public int getAge() {
return sAge;
}

public double getScore() {
return sScore;
}
}
2 分别对应下面的3个问题
public class STest {
public static void main(String args)
{
//2、按照第1题中学生类Student的定义，创建两个该类的对象，输入两个学生的信息，计算并输出两个学生的平均成绩。
Student s1=new Student("100001","张三",21,76);
Student s2=new Student("100002","李四",22,85);
double avg=0;
avg=(s1.getScore()+s2.getScore())/2;
System.out.println(s1.getName()+"、"+s2.getName()+"的平均成绩是:"+avg);

//2、按照第1题中学生类Student的定义，创建三个该类的对象，输入三个学生的信息，计算并输出三个学生成绩的最高分。
Student s3=new Student("100003","王五",19,84);
double maxScore_temp=s1.getScore()》s2.getScore()?s1.getScore():s2.getScore();
double maxScore=s3.getScore()》maxScore_temp?s3.getScore():maxScore_temp;
System.out.println(s1.getName()+"、"+s2.getName()+"、"+s3.getName()+"的最高成绩是:"+maxScore);
//2、按照第1题中学生类Student的定义，创建四个该类的对象，输入四个学生的信息，计算并输出四个学生成绩的最低分
Student s4=new Student("100004","老赵",22,89);
double minScore_temp1=s1.getScore()《s2.getScore()?s1.getScore():s2.getScore();
double minScore_temp2=s3.getScore()《minScore_temp1?s3.getScore():minScore_temp1;
double minScore=s4.getScore()《minScore_temp2?s4.getScore():minScore_temp2;
System.out.println(s1.getName()+"、"+s2.getName()+"、"+s3.getName()+"、"+s4.getName()+"的最低绩是:"+minScore);
}
}

JAVA编程的几个简单题目

第一个：
import java.util.Scanner;
import java.util.*;
public class Validate
{
private int n;
/*count_6、count_7、count_8 用来记录收敛那个数字的个数，在这里我记录只要他出现了10次我就认为他收敛与他了
* 还没想到更好的办法，如果不设置这个，就会出现栈溢出，递归不出来了！不过可以看到结果输出结果确实是对的
*/
private int count_6;
private int count_7;
private int count_8;
private Stack《Integer》 stack= new Stack《Integer》();//栈用来存放素因子
public void scan()
{
Scanner scan = new Scanner(System.in);
try{
n = scan.nextInt();
}catch(NumberFormatException ne){
System.out.println(ne.getMessage());
}
}
public boolean isPrime(int n)
{
if(n》2 && 0 == n%2)//是大于2偶数
{
return false;
}else{
for(int i=3; i《n; i +=2)
{
if(0 == n%i)
return false;
}
return true;
}
}
public void analyze(int n)
{
if(isPrime(n))
{
stack.push(n);
return;
}
if(0 == n%2){
stack.push(2);
n = n/2;
analyze(n);
}else{
for(int i=3; i《n; i +=2)
{
if(isPrime(i)&& 0 == n%i)
{
stack.push(i);
n = n/i;
analyze(n);
}
}
}
}
public void mySort()
{
check(n);
}
public void check(int m)
{
if(isPrime(m)){
m++;
}
else{
analyze(m);
m = 0;
while(!stack.empty())
{
int k = stack.pop().intValue();
m += k;
}
stack.clear();
m++;
}
if(m == 6 || m == 7 || m == 8)
{
if(6 == m)
{
count_6++;
System.out.println("m = " + m);
}else if(7 == m){
count_7++;
System.out.println("m = " + m);
}else if(8 == m){
count_8++;
System.out.println("m = " + m);
}
}
if(count_6 》 10 || count_7 》 10 || count_8 》 10)
{
return;
}
check(m);
}
public static void main(String args)
{
Validate v = new Validate();
v.scan();
v.mySort();
}
}
第二个：
import java.util.Scanner;
class MyException extends Exception
{
public MyException(String msg)
{
super(msg);
}
}
public class MyExceptionTest {
public int scan()
{
int a = 0;
Scanner scan = new Scanner(System.in);
try{
a = scan.nextInt();
}catch(NumberFormatException ne){
System.out.println(ne.getMessage());
}
return a;
}
public int cal(int a, int b) throws MyException
{
if(b==0) throw new MyException("自定义异常： 输入的第二个数为0");
else if(a/b《1) throw new MyException("自定义异常： 相除的结果小于1");
else return a/b;
}
public static void main(String args) {
MyExceptionTest me = new MyExceptionTest();
System.out.print("请输入第一个数:");
int a = me.scan();
System.out.print("请输入第二个数:");
int b = me.scan();
try{
System.out.println("相除的结果:" + me.cal(a, b));
}catch(MyException e){
System.out.println(e.getMessage());
}
}
}
第三个：
import java.util.*;
import java.util.Map.Entry;
public class CountCharacter {
private static Map《String, Integer》 map = new LinkedHashMap《String, Integer》();
private static final int ONE = 1 ; //没有出现过,则设置其出现一次;
private String content = null;
public void scan()
{
Scanner scan = new Scanner(System.in);
content = scan.nextLine();
}
public void count()
{
String text = content.split(" ");
for(int i=0; i《text.length; i++)
{
if (!map.containsKey(text)) {
map.put(text, ONE);
} else {
int value = map.get(text);
map.put(text, value + 1);
}
}
}
public 《K, V extends Number》 Map《String, V》 sortMap(Map《String, V》 map) {
class MyMap《M, N》 {
private M key;
private N value;
private M getKey() {
return key;
}
private void setKey(M key) {
this.key = key;
}
private N getValue() {
return value;
}
private void setValue(N value) {
this.value = value;
}
}
List《MyMap《String, V》》 list = new ArrayList《MyMap《String, V》》();
for (Iterator《String》 i = map.keySet().iterator(); i.hasNext(); ) {
MyMap《String, V》 my = new MyMap《String, V》();
String key = i.next();
my.setKey(key);
my.setValue(map.get(key));
list.add(my);
}
Collections.sort(list, new Comparator《MyMap《String, V》》() {
public int compare(MyMap《String, V》 o1, MyMap《String, V》 o2) {
if(o1.getValue().equals(o2.getValue())) {
return o1.getKey().compareTo(o2.getKey());
}else{
return (int)(o2.getValue().doubleValue() - o1.getValue().doubleValue());
}
}
});
Map《String, V》 sortMap = new LinkedHashMap《String, V》();
for(int i = 0, k = list.size(); i 《 k; i++) {
MyMap《String, V》 my = list.get(i);
sortMap.put(my.getKey(), my.getValue());
}
return sortMap;
}
public static void main(String args) {
CountCharacter cc = new CountCharacter();
cc.scan();
cc.count();
Map《String, Integer》 sortMap = cc.sortMap(cc.map);
Iterator《Entry《String, Integer》》 it = sortMap.entrySet().iterator();
Map.Entry《String,Integer》 entry = null;
int i=0;
while(it.hasNext()&& i《10) {//去前面10个
i++;
entry = (Entry《String,Integer》) it.next();
System.out.println(entry.getKey() + " --》 " + entry.getValue());
}
}
}
第四个：
import java.util.Scanner;
public class IntegerShape{
public static void main(String args){
double a = 0;
int b = 0;
Scanner in = null;
do{
try{
System.out.print("请输入一个的数：");
in=new Scanner(System.in);
a=in.nextFloat();
break;
}catch(Exception ne){
System.out.println("输入数据错误!");
}
}while(true);
do{
try{
System.out.print("请输入显示的行数:");
in=new Scanner(System.in);
b=in.nextInt();
break;
}catch(Exception ne){
System.out.println("输入数据错误!");
}
}while(true);
for(int i=b;i》0;i--)
{
System.out.println(a);
a=a/2;
}
}
}
第五个：
import java.util.Scanner;
import java.util.Vector;
public class MyVector {
private Vector《String》 vectorStr = new Vector《String》(); //用来方单词
private Vector《Integer》 vectorInt = new Vector《Integer》();//用来记录对应下标的单词的个数
private static final int ONE = 1 ; //没有出现过,则设置其出现一次;
private String content = null;
public void scan()
{
Scanner scan = new Scanner(System.in);
content = scan.nextLine();
}
public void countWord()
{
int index = -1;
String text = content.split(" ");
for(int i=0; i《text.length; i++)
{
if(vectorStr.contains(text)){ //若次单词已经存在与vector中则只要修改对应的个数
index = vectorStr.indexOf(text);
int value = vectorInt.get(index)+1;
vectorInt.setElementAt(value, index);
}
else{//若不存在则添加该单词，同时要初始化对应下标的单词的个数
vectorStr.add(text);
vectorInt.add(ONE);
}
}
System.out.println(vectorStr);
}
public void display()
{
for(int i=0; i《vectorStr.size(); i++)
{
System.out.println(vectorStr.get(i) + "-》" + vectorInt.get(i));
}
}
public static void main(String args) {
MyVector mv = new MyVector();
mv.scan();
mv.countWord();
mv.display();
}
}
最后一个了不容易！考虑加点分吧！
import java.util.*;
public class Exp {

private int integer;
private boolean bool = false;
private Stack《Integer》 stack = new Stack《Integer》();

public void scan()
{
System.out.print("输入一个整数：");
Scanner scan = new Scanner(System.in);
while(true){
try{
integer = scan.nextInt();
break;
}catch(Exception e){
System.out.println("输入错误!");
}
}
}

public void operation()
{

for(int i=1; i《integer; i++)
{
int sum = 0;
for(int j = i; j《=integer; j++)
{
stack.push(j);
sum += j;
if(sum == integer)
{
int k = 0, n = stack.size();
bool = true;
System.out.print(integer + " = ");
while(!stack.empty())
{
k++;
if(k《n)
{
System.out.print(stack.pop().intValue() + " + ");
}
else
{
System.out.print(stack.pop().intValue() + "\n");
}
}
stack.clear();
}else if(sum 》 integer){
stack.clear();
}
}
}
if(!bool)
System.out.println("该整数没有连续正整数序列！");
}
public static void main(String args) {
Exp e = new Exp();
e.scan();
e.operation();
}
}
以上运行过了可以！