现在有如下一个数组：
int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}，要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：
int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5}
int oldArr[] = { 1, 3, 4, 5, 0, 0, 6, 6, 0, 5, 4, 7, 6, 7, 0, 5 }; int count = 0; for (int i = 0; i < oldArr.length; i++) { if (oldArr[i] != 0) { count++; } } int[] newArr = new int[count]; int a=0; for (int i = 0; i <oldArr.length; i++) { if (oldArr[i] != 0) { newArr[a]=oldArr[i]; a++; } } System.out.println(Arrays.toString(newArr)); for(int n:newArr) { System.out.print(n+" "); }
现在给出两个数组：
·数组a：{1，7，9，11，13，15，17，19}；
·数组b：{2，4，6，8，10}
两个数组合并为数组c，按升序排列。
public static void main(String[] args) { int[] a= {1,7,9,11,13,15,17,19}; int[] b= {2,4,6,8,10}; int[] c= new int[a.length+b.length]; System.arraycopy(a, 0, c, 0, a.length); System.arraycopy(b, 0, c, a.length, b.length); Arrays.sort(c);//给数组c进行升序拍序，Arrays.sort()是Arrays类的静态方法，可以直接拿来使用 System.out.println(Arrays.toString(c)); } }
（1）定义一个类（Person）
该类中有两个属性，姓名（name）和年龄（age）。定义构造方法，用来初始化数据成员。提供各成员变量的getXXX()和setXXX()方法定义display方法，将姓名和年龄打印出来。（2）定义MainClass类，在main方法中创建人类的实例，然后将信息显示。
package work; public class Person { private String name; private Integer age; @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public Person(String name, Integer age) { this.name = name; this.age = age; } } package work; public class MainClass { public void person(){ Person person=new Person("张三",21); person.display(); } public static void main(String[] args) { MainClass mainClass=new MainClass(); mainClass.person(); } }
（1）定义一个类WuMingFen（无名的粉）
（2）该类有三个属性：粉名:String name; 粉的分量(两)：int quantity ;是否带汤：boolean likeSoup
（3）构造方法1：含三个参数，为三个属性赋值。
（4）构造方法2：含两个参数，为前两个属性赋值
（5）构造方法3：不含参数的构造方法，完成属性的初始化为：.粉名：酸辣面；分量：2两；是否带汤：带汤。
（6）写一个普通方法：String check()，方法的功能：用字符串连接符连接该类的三个属性并返回一个字符串，例如：“牛肉粉、2两、不带汤”。
（7）定义一个主类，分别调用类WuMingFen的3个构造方法完成3个对象的创建，并调用check方法，输出其方法的返回值。
package work; //(1)定义一个类WuMingFen（无名的粉） public class WuMingFen { //(2)该类有三个属性：粉名:String name; 粉的分量(两)：int quantity ;是否带汤：boolean likeSoup private String name; private int quantity; private boolean likeSoup; //（3）构造方法1：含三个参数，为三个属性赋值。 public WuMingFen(String name, int quantity, boolean likeSoup) { this.name = name; this.quantity = quantity; this.likeSoup = likeSoup; } //（4）构造方法2：含两个参数，为前两个属性赋值 public WuMingFen(String name, int quantity) { this.name = name; this.quantity = quantity; } //（5）构造方法3：不含参数的构造方法，完成属性的初始化为：.粉名：酸辣面；分量：2两；是否带汤：带汤。 public WuMingFen() { name="酸辣粉"; quantity=2; likeSoup=true; } //(6）写一个普通方法：String check()，方法的功能：用字符串连接符连接该类的三个属性并返回一个字符串，例如：“牛肉粉、2两、不带汤”。 public String check(){ return name+quantity+likeSoup; } public static void main(String[] args) { //（7）定义一个主类，分别调用类WuMingFen的3个构造方法完成3个对象的创建，并调用check方法，输出其方法的返回值。 WuMingFen wuMingFen1=new WuMingFen("牛肉粉",1,true); WuMingFen wuMingFen2=new WuMingFen("羊肉汤",2); WuMingFen wuMingFen3=new WuMingFen(); wuMingFen1.check(); wuMingFen2.check(); wuMingFen3.check(); System.out.println(wuMingFen1.check()); System.out.println(wuMingFen2.check()); System.out.println(wuMingFen3.check()); } }
2、定义Example06类，代码如下所示：
public class Example06 { public static void main(String[] args) { Student s1 = new Student("Jack", 22); } } 无参的构造方法 一个参数的构造方法 两个参数的构造方法源文件名称：FamilyPerson.java
类名：FamilyPerson
属性
变量名
含义
数据类型
surname
姓
String
name
名
String
方法
方法名
含义
返回值类型含义
setSurname
设置姓
void
setName
设置名
void
源文件名称：MainClass.java
类名：MainClass (主类，即应用程序)
main方法
完成任务
1.实例化三个对象，一个父亲father，一个大儿子sonone，一个二儿子sontwo
2.调用setSurname为姓赋值（例如：张、李、王）
3.调用setName为三个对象的名赋值
4.显示三个对象的姓名
5. 调用setSurname给父亲、大儿子、二儿子改姓
6.再次显示三个对象的姓名
备注
第2步和第5步的代码不完全相同，思考一下。
package work; public class FamilyPerson { private String surname; private String name; public void setSurname(String surname) { this.surname = surname; } public void setName(String name) { this.name = name; } @Override public String toString() { return surname+name; } } package work; public class MainClass { static String surname; public static void main(String[] args) { //1.实例化三个对象，一个父亲father，一个大儿子sonone，一个二儿子sontwo FamilyPerson father=new FamilyPerson(); FamilyPerson sonone=new FamilyPerson(); FamilyPerson sontwo=new FamilyPerson(); //2.调用setSurname为姓赋值（例如：张、李、王） father.setSurname("张"); sonone.setSurname("李"); sontwo.setSurname("王"); //3.调用setName为三个对象的名赋值 father.setName("爸爸"); sonone.setName("明明"); sontwo.setName("天天"); //4.显示三个对象的姓名 System.out.println(father); System.out.println(sonone); System.out.println(sontwo); //5. 调用setSurname给父亲、大儿子、二儿子改姓 surname="赵"; father.setSurname(surname); sonone.setSurname(surname); sontwo.setSurname(surname); //6.再次显示三个对象的姓名 System.out.println(father); System.out.println(sonone); System.out.println(sontwo); } }源文件名称：Tank.java
类名：Tank (坦克)
属性
变量名
含义
数据类型
speed
速度
double
bulletAmount
炮弹数量
int
color
坦克颜色
（所有坦克的颜色都一致，若一个坦克颜色改变则都改变）
char
方法
方法名
含义
返回值含义
speedUp(int x)
加速到x公里/小时（最高时速不能超过200，若超过，给出提示，并自动降为200）
void
speedDown(int x)
减速到x公里/小时
void
setBulletAmount(int x)
设置炮弹数量
void
getSpeed()
获取坦克当前的速度
当前速度
getBulletAmount()
获取炮弹当前的数量
当前炮弹数量
fire()
开火（每开火一次，发射一枚炮弹）
void
conFire(int x)
连续开火（连续发射，共计x枚炮弹，注意连续开火也是一枚枚发射出去的，而不是一次发射x枚）
void
setColor(char x)
将坦克颜色设置为x色
void
brake()
刹车（速度降为0）
void
源文件名称：Fight.java
类名：Fight (主类，即Java应用程序)
main方法完成任务
1.实例化两个坦克对象
2.实现加速、设置炮弹数量、设置所有坦克颜色为绿色功能
3.开火
4.减速
5.设置坦克颜色为黄色（与2中不同，用另一种方法实现对颜色属性的改变）
6.连续开火
每次执行一次动作后，都需要用System.out.println输出坦克类的相关属性值以验证是否被改变。开火后，当炮弹数量为0时，坦克就立即刹车。
package work; public class Tank { protected double speed; protected int bulletAmount; protected char color; public void speedUp(int x) { this.speed = x; speed++; if (x > 200) { System.out.println("最高时速不能超过200公里/小时！"); speed--; } System.out.println("速度为：" + x); } public void speedDown(int x) { this.speed = x; speed--; } public void setBulletAmount(int x) { this.bulletAmount = x; } public double getSpeed() { return speed; } public int getBulletAmount() { return bulletAmount; } public void fire() { bulletAmount--; } public void conFire(int x) { this.bulletAmount = x; if (x > 0) { x--; } } public void setColor(char x) { this.color = x; } public char getColor() { return color; } public void brake() { speed = 0; } } package work; public class Fight { public static void main(String[] args) { Tank t1=new Tank(); Tank t2=new Tank(); t1.speedUp(300); t1.speedUp(188); t1.setBulletAmount(10); t1.setBulletAmount(12); t1.setColor('绿'); t1.fire(); t1.speedDown(150); t2.setColor('黄'); t2.conFire(12); if(t1.bulletAmount>0){ t1.brake(); } if(t2.bulletAmount>0){ t2.brake(); } System.out.print(t1.speed); System.out.println(t1.color); System.out.println(t2.color); System.out.print(t2.speed); } }
1．作为Java应用程序入口的main方法，其声明格式是（）
A．public static int main(String args[]) B．public static void main(String args[])
C．public void main(String args[]) D．public int main(String args[])
2.有一个类A，对于其构造方法的声明正确的是（）。
A．void A(int x){…} B．public A(int x){…}
C．A A(int x){…} D．int A(int x){…}
3. 方法的形参（）。
A．可以没有 B．至少有一个
C．必须定义多个形参 D．至少有两个
4.编译并运行下面的程序，运行结果是（）。
public class A{
public static void main(String args[]){
A a=new A();
a.method(8);
}
void method(int i){
System.out.println(“int: ”+i);
}
void method(long i){
System.out.println(“long: ”+i);
}
A．程序可以编译运行，输出结果为：“int: 8”
B．程序可以编译运行，输出结果为：“long: 8”
C．程序有编译错误，因为两个method()方法必须定义为静态（static）的
D．程序可以编译运行，但是没有输出
5.构造方法在（ ）时被调用。
A．类定义时 B．使用对象的变量时
C．调用对象方法时 D．创建对象时
6.定义类A如下：
class A{
int a,b,c;
public void B(int x,int y, int z){ a=x;b=y;c=z;}
}
下面对方法B的重载哪些是正确的（）。
A．public void A(int x1,int y1, int z1){ a=x1;b=y1;c=z1;}
B．public void B(int x1,int y1, int z1){ a=x1;b=y1;c=z1;}
C．public void B(int x,int y){ a=x;b=y;c=0;}
D．public B(int x,int y, int z){ a=x;b=y;c=z;}
7.下面哪个包是编程时不需要导入就可以直接使用的 。
A．java.net B．java.lang C．java.sql D．java.util
8.当方法中的局部变量与成员变量同名时，必须使用下列哪一个关键字指出成员变量 。
A．static B．super C．this D．new
9.下列类的声明中不合法的是 。
A．class People（）{…} B．class 植物{…}
C．class A{…} D．public class 共有类{…}
10．能作为类的修饰符, 也能作为类成员的修饰符的是 。
A．public B．extends C．Float D．static
11.试完成下述程序片段 。
public class Point{
int x,y;
public Point(int x,int y){
( )=x;
( )=y;
}
}
A．Point.x Point.y B．this.x this.y
C．super.x super.y D．无解
12.重载指的是方法具有相同的名字，但这些方法的参数必须不同。下列哪种说法不属于方法参数的不同 。
A．形式参数的个数不同。 B．形式参数的类型不同。
C．形式参数的名字不同。 D．形式参数类型的排列顺序不同。
13. 关于类的命名，正确说法是（ ）（多选）
A. 可以由数字和英文拉丁字母组成，且可以任意排序
B. 命名要做到见名知意
C. 如果是由多个单词组成，每个单词首字母大写
D. 可以是Java已经定义过的关键字
14. 类中某方法定义如下：
Double fun(int a,int b){
return a*1.0/b;
}
同一类内其它方法调用该方法的正确方式是( )
A. double a=fun(1,2);
B. double a =fun(1.0,2.0);
C. int x =fun(1,2);
D. int x=fun(1.0,2.0);
15. 给定java代码，如下，编译运行，结果是（ ）
public static void main(String[] args){
boolean flag;
System.out.println(“flag”+flag); //局部变量需要先初始化再使用
}
A. 编译错误
B. 编译通过，单出现运行时错误
C. 正常运行，输出flag=false
D. 正常运行，输出flag=
16.下列构造方法的调用方式中，正确的是（ ）
A．按照一般方法调用 B．由用户直接调用
C．只能通过new自动调用 D．被系统调用
17.int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( )。
A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100
C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100
18．下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？( )。
A．private B．无修饰符 C．public D．protected
19.给出下列代码，如何使成员变量m 被方法fun（）直接访问？( )。
class Test
{ private int m;
public static void fun（）
{ ... } }
A．将private int m 改为protected int m
B．将private int m 改为 public int m
C．将private int m 改为 static int m
D．将private int m 改为 int m
20.已知有下列类的说明，则下列哪个语句是正确的？( )。
public class Test
{ private float f = 1.0f;
int m = 12;
static int n=1;
public static void main（String arg［］）
{ Test t = new Test（）; } }
A．t.f； B．this.n； C．Test.m； D．Test.f；
21.给出下列代码，则数组初始化中哪项是不正确的？( )。
byte［］array1,array2［］;
byte array3［］［］;
byte ［］［］ array4;
A．array2 = array1 B．array2=array3
C．array2=array4 D．array3=array4
22.下列代码的执行结果是( )。
public class Test
{ public int aMethod（）
{ static int i=0; i++; System.out.println（i）; }
public static void main（String args［］）
{ Test test = new Test（）; test.aMethod（）; } }
A．编译错误 B．0 C．1 D．运行成功，但不输出
23．为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为( )。
A．static void method( ) B. public void method( )
C．final void method( ) D. abstract void method
24.设有下面的一个类定义：（多选题）
class AA { static void Show( ) { System.out.println(“我喜欢Java!”); } }
class BB { void Show( ) { System.out.println(“我喜欢C++!”); } }
若已经使用AA类创建对象a和BB类创建对象b，则下面（ ）方法调用是正确的。
A. a.Show( ) ; b.Show( ) B. AA.Show( ); BB.Show( );
C. AA.Show( ); b.Show( ); D. a.Show( ); BB.Show( );
25.在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序特性称为（ ）。
A.隐藏 B.覆盖 C.重载 D.Java不支持此特性
1 B．public static void main(String args[]) 2构造方法没有返回值类型B．public A(int x){…} 3. 方法的形参（）。A．可以没有 4A．程序可以编译运行，输出结果为：“int: 8” 5 D．创建对象时 6重载 方法名相同,方法体不同,参数列表不同C．public void B(int x,int y){ a=x;b=y;c=0;} 7 B．java.lang 8C．this 9D．public class 共有类{…} 只能有一个public修饰的类 10A．public 三种类的修饰符public、abstract、final 11 B．this.x this.y 12C．形式参数的名字不同。 13 B. 命名要做到见名知意 C. 如果是由多个单词组成，每个单词首字母大写 14A. double a=fun(1,2); 15A. 编译错误 16C．只能通过new自动调用 17 D．public final int MAX_LENGTH=100 (不严谨应该加static） 18 D．protected 19C．将private int m 改为 static int m 20 A．t.f；
21A．array2 = array1 (题目出的不太好这里没有初始化会报错,但是抛开这些判断a1是一维数组,其他是二维数组.. 22A．编译错误 1.public int aMethod（）方法没有返回值,2主要原因 java是面向对象的不用像c一样,static不能写在局部变量里面 23B. public void method( ) (应该是) 24AC 25 C.重载
