① java输出学生学号,姓名,成绩
publicclassStudent{
privateintkemu1,kemu2,kemu3,kemu4,kemu5;
publicintgetKemu1(){
returnkemu1;
}
publicvoidsetKemu1(intkemu1){
this.kemu1=kemu1;
}
publicintgetKemu2(){
returnkemu2;
}
publicvoidsetKemu2(intkemu2){
this.kemu2=kemu2;
}
publicintgetKemu3(){
returnkemu3;
}
publicvoidsetKemu3(intkemu3){
this.kemu3=kemu3;
}
publicintgetKemu4(){
returnkemu4;
}
publicvoidsetKemu4(intkemu4){
this.kemu4=kemu4;
}
publicintgetKemu5(){
returnkemu5;
}
publicvoidsetKemu5(intkemu5){
this.kemu5=kemu5;
}
}
上边的是Student类
importjava.util.ArrayList;
importjava.util.Random;
publicclassTest{
publicstaticvoidmain(String[]args){
ArrayList<Student>list=newArrayList<Student>();
//初始化成绩
for(intn=0;n<20;n++){
Studentst=newStudent();
st.setKemu1(newRandom().nextInt(100));
st.setKemu2(newRandom().nextInt(100));
st.setKemu3(newRandom().nextInt(100));
st.setKemu4(newRandom().nextInt(100));
st.setKemu5(newRandom().nextInt(100));
list.add(st);
}
//计算平均成绩
intavg=0;
for(intn=0;n<20;n++){
avg+=list.get(n).getKemu1();
avg+=list.get(n).getKemu2();
avg+=list.get(n).getKemu3();
avg+=list.get(n).getKemu4();
avg+=list.get(n).getKemu5();
}
doubleavg2=avg/20;
System.out.println("全班平均成绩"+avg2);
//计算谁得奖
for(intn=0;n<20;n++){
doubleavg3;
intavg4=0;
avg4+=list.get(n).getKemu1();
avg4+=list.get(n).getKemu2();
avg4+=list.get(n).getKemu3();
avg4+=list.get(n).getKemu4();
avg4+=list.get(n).getKemu5();
avg3=avg4;
System.out.println((n+1)+"成绩为"+avg3);
if(avg3>(avg2*1.2)){
System.out.println((n+1)+"该生获得1等将");
}
if(avg3>(avg2*1.1)){
System.out.println((n+1)+"该生获得2等将");
}
}
}
}
好了 可以了
ArrayList是动态数组
② 高分求做简单JAVA期末考试
1. Application 创建一个类,然后写一个主函数,再写一些程序在主函数里就是一个简单的Appliction
Applet 创建一个类继承Applet类,然后实现init,start,destory方法,这个就可以了
2. Java接口,Java语言中存在的结构,有特定的语法和结构; 包就是一个文件夹
3. 多态包括重载和重构 最通俗的程序例子,昨天刚写的
/**
简单的通俗的讲:
继承就是儿子继承了父亲,一个类内有一个父亲,但一个父亲可以有多个儿子
多态就是儿子虽然继承了父亲的一些特性,但有些特性有了改变
封装就是有些东西儿子是父亲独有的儿子继承不了
*/
class FatherClass {
//FatherClass的成员变量
//父亲公开的属性儿子,孙子,侄子都能访问 a
public int a;
//父亲私有的属性,儿子继承不了,在子类中也不能访问 b
private int b;
//FatherClass的成员方法
//父亲公开的方法儿子,孙子,侄子都能访问 eat
public void eat(){
System.out.println("Father eat!");
}
public void drink(){
System.out.println("Father drinking!");
}
//父亲私有的方法,儿子继承不了,在子类中也不能访问 方法height
private void height(){
System.out.println("Father height!");
}
//父亲的最终方法poor,也就是说儿子不能覆盖这个方法(儿子不能有和父亲方法头一样的函数)
public final void poor(){
System.out.println("Father poor!");
}
}
class SubClass extends FatherClass {
//虽继承了父亲的吃方法,但儿子又拓展了父亲的吃方法,要带餐具(多态中的一:重载)
public void eat(String tool){
System.out.println(tool+" :Son eat!");
}
//和父亲的喝方法一样,不过这是儿子自己的喝方法,不是从父亲那里来的(多态中的二:覆盖或重写或重构)
public void drink(){
System.out.println("Son drinking!");
}
public static void print(){
System.out.println("Static Function!");
}
}
public class ExtendsTest {
public static void main(String[] args) {
SubClass sc=new SubClass();
sc.eat();//儿子继承了父亲的吃方法,可以直接使用
sc.eat("Bowl");//虽然儿子继承了父亲的吃方法,可是儿子也有自己的吃方法(拓展了),得用餐具吃
sc.drink();//这里调用的是儿子的喝方法而不是父亲的噢,父亲的被儿子覆盖了
//sc.height();//父亲私有的儿子不能使用
SubClass.print();//静态方法直接使用 类名.方法名 调用
}
}
5.
面向对象特征:继承,多态,封装
6.
import java.util.Scanner;
public class CountNum {
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print("请输入一个整数:");
int number=sc.nextInt();
int sum=0;
for(int i=1;i<=number;i++){
sum+=i;
}
System.out.println("1+2+...+number="+sum);
}
}
7.
public class Student {
private long id;
private String name;
private int age;
boolean sex;
String phone;
public Student(long i, String n, int a, boolean s, String p) {
this.id = i;
this.name = n;
this.age = a;
this.sex = s;
this.phone = p;
}
int getage() {
return age;
}
boolean getsex() {
return sex;
}
Long getphone() {
return Long.parseLong(phone);
}
public String tostring() {
return name;
}
}
还不多呢
总算弄完了,,
呵呵…………
祝你好运哈。。。
③ java期末考试!!求助!!!
1.
第一种:
当X=10时 X-1=X; 无效表达式
当X=10时 X-=3; 等价于 X=X-3; 运算后x的值:7
当X=10时 X*=1+2; 等价于 X=X*(1+2); 运算后x的值:30
当X=10时 X%=5; 等价于 X=X%5; 运算后x的值:0
第二种:
如果是问 X 经过后三个表达式运算后的值(第一个表达式是错的):
X=X-3; 此时 X=7
X=X*(1+2); 此时 X=21
X=X%5; 此时 X=1
最后X为1
2.
当a=6; b=-4;时 --a%++b; 等价于 (a-1)%(b+1); 运算后的值:2
当a=6; b=-4;时 (--a)<<a;; 等价于 (a-1)<<a; 运算后的值:160
位运算
a-1的值为5
5的二进制为 101
5<<5 表示把五的二进制向左移动5位 即101 00 000换十进制为160
当a=6; b=-4;时 (a<10 && a>10 ? a:b); 等价于
如果a小于10 并且 a大于10 表达式的值为a也就是6 否则表达式的值为b 即-4
一个数不可能同时小于10又大于10 所以 表达式的值为b 也就是-4