本文目录一览：
- 1、五道java语言描述的数据结构编程题，请求给予详细解答
- 2、几道JAVA题目，求好心人给下答案，感激不尽
- 3、编程JAVA入门基础题，求大神帮忙解答下，详细点谢谢！
- 4、3道java编程题，求解
- 5、java编程基础练习题
- 6、java的简单编程请帮助
- 7、JAVA编程题求答案
- 8、5道简单的JAVA编程题（高分悬赏）
- 9、求一个java编程题的答案
五道java语言描述的数据结构编程题，请求给予详细解答
第一题：
//使用集合提供的工具方法
public static List
//a,b not null
//全部放到一个set里面，使得元素合并
Set
set.addAll(b);
//将set里面的元素放到列表再转为数组
Integer[] array = new ArrayList
//升序排序
Arrays.sort(array);
//将排序后的数组转为list
return Arrays.asList(array);
}
//自己写的算法， a为升序列表，b为降序列表
public static List
//a,b not null
int aSize = a.size();
int bSize = b.size();
List
int aIndex = 0;// 升序列表从首位开始
int bIndex = bSize - 1;// 降序列表从末尾开始
int aEl;
int bEl;
// 循环终止条件为: a 或者 b 列表遍历完
while (aIndex < aSize && bIndex >= 0) {
aEl = a.get(aIndex);
bEl = b.get(bIndex);
if (aEl < bEl) {
result.add(aEl);
aIndex++;
} else {
result.add(bEl);
bIndex--;
}
}
// 将某个未遍历完的列表中的元素添加到结果(包括了任意一个列表为空列表的情况)
if (aIndex < aSize) {
for (int i = aIndex; i < aSize; i++) {
result.add(a.get(i));
}
}
else if (bIndex > 0) {
for (int i = bIndex; i >= 0; i--) {
result.add(b.get(i));
}
}
return result;
}
几道JAVA题目，求好心人给下答案，感激不尽
1.public static main(String[] args){}
2.final
3.2
4.抽象类
5.implements
6.自己意会
7.try是抓捕异常,catch是抓捕后处理,finally是无论有无异常都要走的代码
8...
9...(程序不会的可以私聊)
1、public static void main(String[] args)
2、public finall static
3、3
4、抽象类
5、implements
6、类：一个包含属性、方法，使用class关键字定义
对象：创建对象必须使用new关键字，对象其实在内存中存储的是类的引用地址。
7、try是可能发生异常的内容；
catch是发生异常后要处理的代码；
finally是始终执行的，比如关闭资源等。
8、
public class Demo { //小明今年12岁，他母亲比他大20岁。编程计算多少年后他母亲的年龄是小明的2倍。 public static void main(String[] args) { System.out.println(getYeah()); } public static int getYeah(){ int xmAge = 12,mqAge = 20,yeah = 0; while(true){ if(mqAge / 2 == xmAge){ return yeah; } mqAge++; yeah++; } }}9、
public class Demo { public static void main(String[] args) { new Thread(new Piao()).start(); new Thread(new Piao()).start(); new Thread(new Piao()).start(); new Thread(new Piao()).start(); }}class Piao implements Runnable{ private static int piao = 1; public void run(){ while(true){ synchronized(Piao.class){ if(piao > 100){ System.exit(0); } System.out.println(Thread.currentThread().getName()+"出票：" + piao + "号"); piao++; } } }}
编程JAVA入门基础题，求大神帮忙解答下，详细点谢谢！
数字不近似了 自己做近似
if("y".equals(a)){ if(money>=100) System.out.println("money*0.9"); else System.out.println("money");}else{ if(money>=200) System.out.println("money*0.75"); else System.out.println("money*0.8"); }
public static void main(String[] args){ System.out.println("请输入是否是会员:是(y)/否(其它字符)"); Scanner scanner = new Scanner(System.in); String str = scanner.nextLine(); boolean vip = false; if(str != null && str.contains("y") && str.length() == 1){ vip = true; } System.out.println("请输入购物金额:"); double money = scanner.nextDouble(); double defray = money; if(vip){ if(money >= 200){ defray = money * 0.75; } else{ defray = money * 0.8; } } else{ if(money >= 100){ defray = money * 0.9; } } System.out.println(String.format("实际支付金额:%f" ,defray)); scanner.close(); }
3道java编程题，求解
你好提问者:
若解决了你的问题请采纳，若有疑问请追问。谢谢！
第一题：
Person 类package com.gc.action.baiduTest.personTest;public class Person { public String name; //姓名 public String sex; //性别 public int age; //年龄 //构造函数 public Person(){ } public Person(String name,String sex,String age){ System.out.println("姓名："+name +" 性别："+ sex +" 年龄："+age); } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }}Student 类package com.gc.action.baiduTest.personTest;public class Student extends Person{ public String xuehao;//学号 public String banhao;//班号 //修改信息 public void xiugai(String xuehao,String banhao){ this.xuehao =xuehao; this.banhao =banhao; System.out.println("学号:"+xuehao+"班号:"+banhao); } public void show(){ System.out.println("姓名："+name +" 性别："+ sex +" 年龄："+age+" 学号:"+xuehao+" 班号:"+banhao); } public String getXuehao() { return xuehao; } public void setXuehao(String xuehao) { this.xuehao = xuehao; } public String getBanhao() { return banhao; } public void setBanhao(String banhao) { this.banhao = banhao; } }Test1 测试类package com.gc.action.baiduTest.personTest;public class Test1 { public static void main(String[] args) { Student stu =new Student(); stu.setName("艺馨"); stu.setSex("女"); stu.setAge(18); stu.setXuehao("10010"); stu.setBanhao("02"); stu.show(); }}结果：姓名：艺馨 性别：女 年龄：18 学号:10010 班号:02第二题：
package com.gc.action.baiduTest.fly;/** * 飞行器接口Aerocraft * @author yltd * */public interface Aerocraft { //飞行方法 public void fly();}package com.gc.action.baiduTest.fly;/** * 载客飞行接口AirPlane * @author yltd * */public interface AirPlane { //载客信息方法 public void passenger();}package com.gc.action.baiduTest.fly;/** * 直升机接口Helicopter * @author yltd * */public interface Helicopter { //垂直飞行方法 public void verticaStart();}package com.gc.action.baiduTest.fly;public class Apaqi implements Aerocraft, Helicopter { @Override public void verticaStart() { System.out.println("阿帕奇直升机:垂直飞行"); } @Override public void fly() { System.out.println("阿帕奇直升机:飞行"); }}package com.gc.action.baiduTest.fly;public class KongKe implements Aerocraft, AirPlane { @Override public void passenger() { System.out.println("空客A380客机:载客信息"); } @Override public void fly() { System.out.println("空客A380客机:飞行方法"); }}package com.gc.action.baiduTest.fly;public class Test2 { public static void main(String[] args) { Apaqi a =new Apaqi(); a.fly(); a.verticaStart(); KongKe k =new KongKe(); k.fly(); k.passenger(); }}结果：阿帕奇直升机:飞行阿帕奇直升机:垂直飞行空客A380客机:飞行方法空客A380客机:载客信息
你加个有偿估计会有人帮你-
。。。。。。。估计非常闲才会帮你写
我去，我最开始还以为是什么算法，结果全是些在IDE上点鼠标的操作，自己操作更快吧
package TestPerson;/** * (1) 编写程序实现如下功能：已知Person类包含三个公共成员变量（姓名、性别、年龄）和一个构造方法， * Student类是Person类的派生类，包含两个新的公共成员变量(学号、班号)、两个公共方法（修改年龄、显示基本信息）及一个构造方法。 * 在测试类Test1中，定义一组学生对象，并初始化他们的基本信息，然后依次输出。 */public class Test1 { public static void main(String[] args) { Student[] student = new Student[3]; student[0] = new Student("小李", "男", 12, 20181101, 01); student[1] = new Student("小南", "女", 13, 20001102, 01); student[2] = new Student("小李", "男", 12, 20181103, 01); for(Student stu : student) { stu.showInformation(); } }}class Person { public String name; public String sex; public int age; public Person(String name, String sex, int age) { super(); this.name = name; this.sex = sex; this.age = age; }}class Student extends Person { public long studentId; public long classId; public void setAge(int age) { age = this.age; } public void showInformation() { System.out.println("我的姓名是" + name + "," + "我的性别是" + sex + "," + "我的年龄是" + age + "岁," + "我的学号是" + studentId + "," + "我的班号是" + classId + "班"); } public Student(String name, String sex, int age, long studentId, long classId) { super(name, sex, age); this.studentId = studentId; this.classId = classId; }}不可否认，我现在是有点闲，所以我就帮你写第一个吧，至于后面两个，我就不写了，看看还有没有其他人有点闲时间，看缘分吧
运行结果：
我的姓名是小李,我的性别是男,我的年龄是12岁,我的学号是20181101,我的班号是1班
我的姓名是小南,我的性别是女,我的年龄是13岁,我的学号是20001102,我的班号是1班
我的姓名是小李,我的性别是男,我的年龄是12岁,我的学号是20181103,我的班号是1班
java编程基础练习题
答案是C
A: num1=new double[num2+1];等价为：num1=new double[6];所以num1指向一个有6个元素的double型数组
B num2是一个整数
C:num1[num2]=num3;等价为：num1[5]=2.0;因为数组标识从0开始，所以num1[5]是最后一个元素
D: num1数组的第三个元素没有赋值，默认应该是0.0；
现在都是信息化的时代，没有一门好的技术是难以在社会之中立足的，
现在的电脑技术飞速增长，每家公司都需要电脑人才，你可以去学习电脑专业，
在这个领域中还是有很大的发展空间的，只要自己好好学习，以后的前景不可限量。
这道题的答案是C。
double[] num1; //定义一个double类型的数组num1
double num3=2.0; //定义一个double类型的变量并赋值为2.0
int num2=5; //定义一个int类型的冰凉num2，并赋值为5
num1=new double[num2+1];
//给double类型的数组num1赋值，并初始化为5+1个大小， num2=5，所以是5+1
num1[num2]=num3;
//上面这句翻译过来就是：数组num1[5]=2.0 。 由于数组下标从0开始，所以下标为5的元素是最后一个元素。 所以答案是C
java的简单编程请帮助
数据类型就是对内存位置的抽象表达。程序员可以利用多种数据类型：某些由编程语言定义，某些由外部库定义，还有些则由程序员来定义。很多编程语言都依赖于特定的计算机类型和对数据类型属性的具体编译实现，比如word和integer数据类型的大小等。另一方面，Java的虚拟机负责定义其内置数据类型的各方面内容。这就意味着不管Java虚拟机（JVM）运行在何等低级的操作系统之上，数据类型的属性都是完全一样的。
简单数据类型是不能再简化的、内置的数据类型，由编程语言定义，表示真实的数字、字符和整数。更大、更复杂的数据类型可以采用简单数据类型的组合来定义。在大多数情况下，简单数据类型都具有其硬件等价物。比方说，int简单类型有时存放在32位硬件寄存器内。Java提供了几类简单数据类型表示数字和字符。
简单数据类型通常划分为以下几种类别：实数、整数、字符和布尔值。这些类别中又包含了多种简单类型。比如说，Java定义了两种简单类型：float和double，它们都属于实数类别，另外4种简单类型：byte、short、int和long则都属于整数类别。此外还有一种简单类型char则归于字符类型。布尔值类别只有一种简单类型：boolean。
详情请参考原文出处：http://www.chinaitlab.com/www/news/article_show.asp?id=18917
也许你已经用了Java很久了，在碰上一些不常见的数据类型的时候会忙着找资料；也许你是初学者，这篇文章会帮你对数据类型有一个整体清晰的了解。
1、
e) int i = 10;
2、
b) package MyPackage;
import java.awt.*;
class MyClass{}
c) /*This is a comment */
package MyPackage;
import java.awt.*;
class MyClass{}
3、
d) Exception raised: "java.lang.ArrayIndexOutOfBoundsException: 2"
4、 下面哪句编译时没有错误？(5分)
b) boolean b = true;
boolean b2 = true;
if(b==b2)
{
System.out.println("So true");
}
c) int i=1;
int j = 2;
if(i ==1|| j==2)
System.out.println("OK");
d)
int i=1;
int j = 2;
if(i ==1 &| j==2)
System.out.println("OK");
5、
b) String A="abcdefg";
A+="cde";
c) Integer J=new Integer(27);
J-=7;
d) Integer J=new Integer(27);
J--;
7、 以下Java代码的异常处理有哪些问题（或不够规范），请逐一指出(7分)
1 OutputStreamWriter out = ...
2 java.sql.Connection conn = ...
3 try { //
4 Statement stat = conn.createStatement();
5 ResultSet rs = stat.executeQuery(
6 "select uid, name from user");
7 while (rs.next())
8 {
9 out.println("ID：" + rs.getString("uid") //
10 "，姓名：" + rs.getString("name"));
11 }
12 conn.close(); //
13 out.close();
14 }
15 catch(Exception ex) //
16 {
17 ex.printStackTrace(); //
18 }
作为一个Java程序员，你至少应该能够找出两个问题。但是，如果你不能找出全部六个问题，请继续阅读本文。
本文讨论的不是Java异常处理的一般性原则，因为这些原则已经被大多数人熟知。我们要做的是分析各种可称为“反例”（anti-pattern）的违背优秀编码规范的常见坏习惯，帮助读者熟悉这些典型的反面例子，从而能够在实际工作中敏锐地察觉和避免这些问题。
反例之一：丢弃异常
代码：15行-18行。
这段代码捕获了异常却不作任何处理，可以算得上Java编程中的杀手。从问题出现的频繁程度和祸害程度来看，它也许可以和C/C++程序的一个恶名远播的问题相提并论——不检查缓冲区是否已满。如果你看到了这种丢弃（而不是抛出）异常的情况，可以百分之九十九地肯定代码存在问题（在极少数情况下，这段代码有存在的理由，但最好加上完整的注释，以免引起别人误解）。
这段代码的错误在于，异常（几乎）总是意味着某些事情不对劲了，或者说至少发生了某些不寻常的事情，我们不应该对程序发出的求救信号保持沉默和无动于衷。调用一下 printStackTrace算不上“处理异常”。不错，调用printStackTrace对调试程序有帮助，但程序调试阶段结束之后， printStackTrace就不应再在异常处理模块中担负主要责任了。
丢弃异常的情形非常普遍。打开JDK的ThreadDeath类的文档，可以看到下面这段说明：“特别地，虽然出现ThreadDeath是一种‘正常的情形’，但ThreadDeath类是Error而不是Exception的子类，因为许多应用会捕获所有的Exception然后丢弃它不再理睬。” 这段话的意思是，虽然ThreadDeath代表的是一种普通的问题，但鉴于许多应用会试图捕获所有异常然后不予以适当的处理，所以JDK把 ThreadDeath定义成了Error的子类，因为Error类代表的是一般的应用不应该去捕获的严重问题。可见，丢弃异常这一坏习惯是如此常见，它甚至已经影响到了Java本身的设计。
那么，应该怎样改正呢？主要有四个选择：
1、处理异常。针对该异常采取一些行动，例如修正问题、提醒某个人或进行其他一些处理，要根据具体的情形确定应该采取的动作。再次说明，调用printStackTrace算不上已经“处理好了异常”。
2、重新抛出异常。处理异常的代码在分析异常之后，认为自己不能处理它，重新抛出异常也不失为一种选择。
3、把该异常转换成另一种异常。大多数情况下，这是指把一个低级的异常转换成应用级的异常（其含义更容易被用户了解的异常）。
4、不要捕获异常。
结论一：既然捕获了异常，就要对它进行适当的处理。不要捕获异常之后又把它丢弃，不予理睬。
反例之二：不指定具体的异常
代码：15行。
许多时候人们会被这样一种“美妙的”想法吸引：用一个catch语句捕获所有的异常。最常见的情形就是使用catch(Exception ex)语句。但实际上，在绝大多数情况下，这种做法不值得提倡。为什么呢？
要理解其原因，我们必须回顾一下catch语句的用途。catch语句表示我们预期会出现某种异常，而且希望能够处理该异常。异常类的作用就是告诉 Java编译器我们想要处理的是哪一种异常。由于绝大多数异常都直接或间接从java.lang.Exception派生，catch (Exception ex)就相当于说我们想要处理几乎所有的异常。
再来看看前面的代码例子。我们真正想要捕获的异常是什么呢？最明显的一个是SQLException，这是JDBC操作中常见的异常。另一个可能的异常是 IOException，因为它要操作OutputStreamWriter。显然，在同一个catch块中处理这两种截然不同的异常是不合适的。如果用两个catch块分别捕获SQLException和IOException就要好多了。这就是说，catch语句应当尽量指定具体的异常类型，而不应该指定涵盖范围太广的Exception类。
另一方面，除了这两个特定的异常，还有其他许多异常也可能出现。例如，如果由于某种原因，executeQuery返回了null，该怎么办？答案是让它们继续抛出，即不必捕获也不必处理。实际上，我们不能也不应该去捕获可能出现的所有异常，程序的其他地方还有捕获异常的机会——直至最后由JVM处理。
结论二：在catch语句中尽可能指定具体的异常类型，必要时使用多个catch。不要试图处理所有可能出现的异常。
反例之三：占用资源不释放
代码：3行-14行。
异常改变了程序正常的执行流程。这个道理虽然简单，却常常被人们忽视。如果程序用到了文件、Socket、JDBC连接之类的资源，即使遇到了异常，也要正确释放占用的资源。为此，Java提供了一个简化这类操作的关键词finally。
finally是样好东西：不管是否出现了异常，Finally保证在try/catch/finally块结束之前，执行清理任务的代码总是有机会执行。遗憾的是有些人却不习惯使用finally。
当然，编写finally块应当多加小心，特别是要注意在finally块之内抛出的异常——这是执行清理任务的最后机会，尽量不要再有难以处理的错误。
结论三：保证所有资源都被正确释放。充分运用finally关键词。
反例之四：不说明异常的详细信息
代码：3行-18行。
仔细观察这段代码：如果循环内部出现了异常，会发生什么事情？我们可以得到足够的信息判断循环内部出错的原因吗？不能。我们只能知道当前正在处理的类发生了某种错误，但却不能获得任何信息判断导致当前错误的原因。
printStackTrace的堆栈跟踪功能显示出程序运行到当前类的执行流程，但只提供了一些最基本的信息，未能说明实际导致错误的原因，同时也不易解读。
因此，在出现异常时，最好能够提供一些文字信息，例如当前正在执行的类、方法和其他状态信息，包括以一种更适合阅读的方式整理和组织printStackTrace提供的信息。
结论四：在异常处理模块中提供适量的错误原因信息，组织错误信息使其易于理解和阅读。
反例之五：过于庞大的try块
代码：3行-14行。
经常可以看到有人把大量的代码放入单个try块，实际上这不是好习惯。这种现象之所以常见，原因就在于有些人图省事，不愿花时间分析一大块代码中哪几行代码会抛出异常、异常的具体类型是什么。把大量的语句装入单个巨大的try块就象是出门旅游时把所有日常用品塞入一个大箱子，虽然东西是带上了，但要找出来可不容易。
一些新手常常把大量的代码放入单个try块，然后再在catch语句中声明Exception，而不是分离各个可能出现异常的段落并分别捕获其异常。这种做法为分析程序抛出异常的原因带来了困难，因为一大段代码中有太多的地方可能抛出Exception。
结论五：尽量减小try块的体积。
反例之六：输出数据不完整
代码：7行-11行。
不完整的数据是Java程序的隐形杀手。仔细观察这段代码，考虑一下如果循环的中间抛出了异常，会发生什么事情。循环的执行当然是要被打断的，其次， catch块会执行——就这些，再也没有其他动作了。已经输出的数据怎么办？使用这些数据的人或设备将收到一份不完整的（因而也是错误的）数据，却得不到任何有关这份数据是否完整的提示。对于有些系统来说，数据不完整可能比系统停止运行带来更大的损失。
较为理想的处置办法是向输出设备写一些信息，声明数据的不完整性；另一种可能有效的办法是，先缓冲要输出的数据，准备好全部数据之后再一次性输出。
结论六：全面考虑可能出现的异常以及这些异常对执行流程的影响。
改写后的代码
根据上面的讨论，下面给出改写后的代码。也许有人会说它稍微有点啰嗦，但是它有了比较完备的异常处理机制。
OutputStreamWriter out = ...
java.sql.Connection conn = ...
try {
Statement stat = conn.createStatement();
ResultSet rs = stat.executeQuery(
"select uid, name from user");
while (rs.next())
{
out.println("ID：" + rs.getString("uid") +
"，姓名: " + rs.getString("name"));
}
}
catch(SQLException sqlex)
{
out.println("警告：数据不完整");
throw new ApplicationException(
"读取数据时出现SQL错误", sqlex);
}
catch(IOException ioex)
{
throw new ApplicationException(
"写入数据时出现IO错误", ioex);
}
finally
{
if (conn != null) {
try {
conn.close();
}
catch(SQLException sqlex2)
{
System.err(this.getClass().getName() +
".mymethod - 不能关闭数据库连接: " +
sqlex2.toString());
}
}
if (out != null) {
try {
out.close();
}
catch(IOException ioex2)
{
System.err(this.getClass().getName() +
".mymethod - 不能关闭输出文件" +
ioex2.toString());
}
}
}
JAVA编程题求答案
基本符合你的要求，代码如下：
class Complex
{
public Complex(double r, double i)
{
real = r;
imag = i;
}
public Complex mul(Complex c2)
{
Complex c3 = new Complex(0, 0);
c3.real = this.real * c2.real - this.imag * c2.imag;
c3.imag = this.real * c2.imag + this.imag * c2.real;
return c3;
}
public Complex dev(Complex c2)
{
Complex c4 = new Complex(0, 0);
c4.real = (this.real * c2.real + this.imag * c2.imag) / (c2.real * c2.real + c2.imag *
c2.imag);
c4.imag = (this.real * c2.imag - this.imag * c2.real) / (c2.real * c2.real + c2.imag *
c2.imag);
return c4;
}
public void show()
{
System.out.print("(" + real + "+" + imag + "i" + ")");
}
private double real;
private double imag;
}
public class Comp
{
public static void main(String []args)
{
Complex c1 = new Complex(1, 2);
Complex c2 = new Complex(3, 4);
Complex c3 = new Complex(0, 0);
Complex c4 = new Complex(0, 0);
c3 = c1.mul(c2);
c1.show();
System.out.print(" * ");
c2.show();
System.out.print(" = ");
c3.show();
System.out.println();
c4 = c1.dev(c2);
c1.show();
System.out.print(" / ");
c2.show();
System.out.print(" = ");
c4.show();
System.out.println();
}
}
5道简单的JAVA编程题（高分悬赏）
大题还有小题,没小题的就是有"分别用"这几个字,总共加起来好多啊.
贴都贴不下吧
写完了怎么给你
第一题:
(1)
public class One {
public static void main(String[] args) {
System.out.println("我叫***");
System.out.println("我今年**岁");
System.out.println("我的性别是:*");
System.out.println("我是**班上的学生");
}
}
(2)后缀是java,用javac命令来编译,编译语句是javac One.java
(3)后缀是class,用java命令来运行,运行语句是java One
有问题可以hi我
1）编写一个Java Application程序，名字自己定义，换行输出你的姓名、年龄、性别、班级
public class Text1{
public static void main(String args[]) {
System.out.println("你的姓名");
System.out.println("年龄");
System.out.println("性别");
System.out.println("班级");
}
}
(2)后缀名：.java ；用javac命令运行；命令：javac Text1.java
（3）编译后后缀名：.class；用java命令执行；命令：java Text1
2、编写程序，输出1到100间的所有偶数。分别用for、while、do…while语句实现。
(1)用for
public class ForText{
public static void main(String args[]){
for(int i=1;i<=100;i+=2)
System.out.print(" "+(i+1));
}
}
（2）用while
public class WhileTest{
public static void main(String args[]){
int i=1;
while(i<=100)
{System.out.print(" "+(i+1));
i+=2;
}
}
}
(3)用do……while
public class DoWhileTest{
public static void main(String args[]){
int i=1;
do
{System.out.print(" "+(i+1));
i+=2;
}while(i<100);
}
}
4、编写程序，计算从1到100之间的奇数之和。分别用for、while、do…while语句实现。
(1)用for
public class ForTest{
public static void main(String args[]){
for(int i=1;i<=100;i+=2)
System.out.print(" "+i);
}
}
（2）用while
public class WhileTest{
public static void main(String args[]){
int i=1;
while(i<=100)
{System.out.print(" "+i));
i+=2;
}
}
}
(3)用do……while
public class DoWhileTest{
public static void main(String args[]){
int i=1;
do
{System.out.print(" "+i);
i+=2;
}while(i<100);
}
}
5、
（1）什么是类的继承？什么是父类？什么是子类？举例说明。
继承”是面向对象软件技术当中的一个概念。如果一个类A继承自另一个类B，就把这个A称为"B的子类"，而把B称为"A的父类"。继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。另外，为子类追加新的属性和方法也是常见的做法。
2）编写一个继承的程序。
A、人类(Person)为父类，包含姓名、年龄、性别属性及一个包含所有属性赋值的构造方法和一个没有返回结果的输出方法（换行输出人的所有属性值和会说的语言）。
public Person(){
System.out.println("Person");
say();
}
public void say(){
System.out.println("Person");
}
}
class B extends Person{
public B(){
System.out.println("B");
say();
}
public void say(){
System.out.println("B");
}
}
class C extends B{
public C(){
System.out.println("C");
say();
}
public void say(){
System.out.println("C");
}
}
class Text{
public static void main(String args[]){
C c = new C();
}
}
这么简单的问题
谁回答都是害他
摆脱各位有点常识和责任心!
很详细的帮你写下，呵呵，所以要给分哦！
1、
（1）源程序如下：
public class One {
public static void main(String[] args) {
String name = "张三";
int age = 23;
char sex = '男';
String myclass = "某某专业2班";
System.out.println("姓名：" + name);
System.out.println("姓名：" + age);
System.out.println("姓名：" + sex);
System.out.println("姓名：" + myclass);
}
}
（2）
编写完程序的后缀名是.java，如本题，文件名就是One.java。
开始\运行\cmd，进入“命令提示符窗口”，然后用javac编译器编译.java文件，语句：javac One.java。
（3）
编译成功后，生成的文件名后缀是.class，叫做字节码文件。再用java解释器来运行改程序，语句：java One
2、编写程序，输出1到100间的所有偶数
（1）for语句
public class Two1 {
public static void main(String[] args) {
for(int i=2;i<=100;i+=2)
System.out.println(i);
}
}
（2）while语句
public class Two2 {
public static void main(String[] args) {
int i = 2;
while (i <= 100) {
System.out.println(i);
i += 2;
}
}
}
（3）do…while语句
public class Two3 {
public static void main(String[] args) {
int i = 2;
do {
System.out.println(i);
i += 2;
}while(i<=100);
}
}
3、编写程序，从10个数当中找出最大值。
（1）for循环
import java.util.*;
public class Three1 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int number;
int max = 0;
for (int i = 0; i < 10; i++) {
System.out.print("输入第" + (i + 1) + "个数:");
number = input.nextInt();
if (max < number)
max = number;
}
System.out.println("最大值：" + max);
}
}
（2）while语句
import java.util.*;
public class Three2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int number;
int max = 0;
int i = 0;
while (i < 10) {
System.out.print("输入第" + (i + 1) + "个数:");
number = input.nextInt();
if (max < number)
max = number;
i++;
}
System.out.println("最大值：" + max);
}
}
（3）do…while语句
import java.util.*;
public class Three3 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int number;
int max = 0;
int i = 0;
do {
System.out.print("输入第" + (i + 1) + "个数:");
number = input.nextInt();
if (max < number)
max = number;
i++;
}while(i<10);
System.out.println("最大值：" + max);
}
}
4、编写程序，计算从1到100之间的奇数之和。
（1）for循环
public class Four1 {
public static void main(String[] args) {
int sum=0;
for(int i = 1;i<=100;i+=2){
sum+=i;
}
System.out.println("1~100间奇数和：" + sum);
}
}
（2）while语句
public class Four2 {
public static void main(String[] args) {
int sum = 0;
int i = 1;
while (i <= 100) {
sum += i;
i += 2;
}
System.out.println("1~100间奇数和：" + sum);
}
}
（3）do…while语句
public class Four3 {
public static void main(String[] args) {
int sum = 0;
int i = 1;
do {
sum += i;
i += 2;
} while (i <= 100);
System.out.println("1~100间奇数和：" + sum);
}
}
5、
（1）什么是类的继承？什么是父类？什么是子类？举例说明。
继承:是面向对象软件技术当中的一个概念。如果一个类A继承自另一个类B，就把这个A称为"B的子类"，而把B称为"A的父类"。继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。另外，为子类追加新的属性和方法也是常见的做法。继承需要关键字extends。举例：
class A{}
class B extends A{}
//成员我就不写了，本例中，A是父类，B是子类。
（2）编写一个继承的程序。
class Person {
public String name;
public int age;
public char sex;
public Person(String n, int a, char s) {
name = n;
age = a;
sex = s;
}
public void output1() {
System.out.println("姓名：" + name + "\n年龄:" + age + "\n性别:" + sex);
}
}
class StudentPerson extends Person {
String school, department, subject, myclass;
public StudentPerson(String sc, String d, String su, String m, String n,
int a, char s) {
super(n, a, s);
school = sc;
department = d;
subject = su;
myclass = m;
}
public void output2() {
super.output1();
System.out.println("学校：" + school + "\n系别:" + department + "\n专业:"
+ subject + "\n班级:" + myclass);
}
}
public class Five2 {
public static void main(String[] args) {
StudentPerson StudentPersonDemo = new StudentPerson("某某大学", "某某系别",
" 某专业", "某某班级", " 张三", 23, '男');
StudentPersonDemo.output2();
}
}
求一个java编程题的答案
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
class Student {
private String id;
private String name;
private boolean isMale;
private Date birth;
public Student() {
super();
}
public Student(String id, String name, boolean isMale, Date birth) {
super();
this.id = id;
this.name = name;
this.isMale = isMale;
this.birth = birth;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public boolean isMale() {
return isMale;
}
public void setMale(boolean isMale) {
this.isMale = isMale;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", isMale=" + isMale + ", birth=" + birth + "]";
}
}
public class StudentTest {
public static void main(String[] args) throws ParseException {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-mm-dd");
Student stu = new Student("00001", "Tom", true, dateFormat.parse("2000-01-01"));
System.out.println(stu);
}
}