7.12 LJY
黑的发白
day09 作业
类和对象作业
填空题
类是组成Java程序的基本要素，类体有两部分构成：一部分是变量的定义，另一部分是______方法_____ 的定义。
2.执行Person p = new Person();语句后，将在__堆内存____中给Person对象分配空间，并在栈内存中给引用变量p分配空间，存放Person对象的引用。
3.____构造方法____是一种特殊方法，它的名字必须与它所在的类的名字完全相同，并且不书写返回值类型，在创建对象实例时系统自动调用。
4.局部变量的名字与成员变量的名字相同，若想在该方法内使用成员变量，必须使用关键字 ______this______ 。
5.使用关键字 __this()_________ 来调用同类的其它构造方法，优点同样是以最大限度地代码的利用程度 ，减少程序的维护工作量。
6.用关键字 _______static___ 修饰的成员变量是类变量，类变量是指不管类创建了多少对象，系统仅在第一次调用类的时候为类变量分配内存，所有对象共享该类的类变量。
7.使用static修饰的变量称为静态变量，静态变量可以有两种访问方式，分别是类名.静态变量名和______对象名.静态变量名______________。
8.在一个类文件中的关键字package，import，class出现的可能顺序是___ _____package,import,class_____________________
9. _________package___ 关键字作为Java源文件的第一条非注释性语句，指明该源文件定义的类所有的包。
10. _____java.lang_________ 包是Java语言的核心类库，它包含了运行Java程序必不可少的系统类，使用该包下的类和接口不需要使用import导入。
选择题
1.
在Java中，以下程序编译运行后的输出结果为（ D ）。（选择一项）
public class Test {
int x, y;
Test(int x, int y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Test pt1, pt2;
pt1 = new Test(3, 3);
pt2 = new Test(4, 4);
System.out.print(pt1.x + pt2.x);
}
}
A
6
B.
34
C.
8
D.
7
2.
分析如下Java程序的代码所示，则编译运行后的输出结果是（ C ）。（选择一项）
public class Test {
int count=9;
public void count1(){
count=10;
System.out.println("count1="+count);
} 10
public void count2(){
System.out.println("count2="+count);
} 10
public static void main(String[ ] args) {
Test t=new Test();
t.count1();
t.count2();
}
}
A
count1=9;
count2=9;
B.
count1=10;
count2=9;
C.
count1=10;
count2=10;
D.
count1=9;
count2=10;
3.
以下语句中关于Java构造方法的说法错误的是（B ）。（选择一项）
A.
构造方法的作用是为创建对象进行初始化工作，比如给成员变量赋值
B.
一个Java类可以没有构造方法，也可以提供1个或多个构造方法
C.
构造方法与类同名，不能书写返回值类型
D.
构造方法的第一条语句如果是super()，则可以省略，该语句作用是调用父类无参数的构造方法
4.
在Java中关于静态方法，以下说法中正确的是（A ）。（选择两项）
A
静态方法中不能直接调用非静态方法
B.
非静态方法中不能直接调用静态方法
C.
静态方法可以用类名直接调用
D.
静态方法里可以使用this
5.
下列选项中关于Java中类方法的说法错误的是（ A,C ）。（选择二项）
A
在类方法中可用this来调用本类的类方法
B.
在类方法中调用本类的类方法时可直接调用
C.
在类方法中只能调用本类中的类方法
D.
在类方法中调用实例方法需要先创建对象
判断题
类可以看成一类对象的模板，对象可以看成该类的一个具体实例。( true)
如果没有为类中的某些成员赋初始值，Java会为类成员赋予固定的初始值，如数值变量的值为0，布尔变量的值为true，未初始化的引用为null。（false ）
Java中所有的变量，不管是成员变量还是局部变量，在使用前都必须进行初始化。（ false ）
在Java中对象可以赋值，只要使用赋值运算符即可，相当于生成了一个各属性与赋值对象相同的新对象。（ false ）
out.println(“Hello java!”)中out是System类的一个静态成员变量。（true）
构造方法用于创建对象，一般不允许有任何返回值，因此需要在构造方法返回类型处标注为void。（false ）
Java语言为所有的Java程序自动导入包“lang”，因此Java程序可以直接用“java.lang”中的类和接口。（true ）
简答题&画图
1:构造方法的作用是什么?构造方法的特点是什么?构造方法的注意事项是什么?构造方法中可不可以写return语句呢?
给对象的数据(属性)进行初始化
方法名与类名相同(大小也要与类名一致)
没有返回值类型，连void都没有
没有具体的返回值return;
:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
可以写return,但是没有返回值;
2:给成员变量赋值有几种方式?
setXxx();
构造方法;
3:一个类的成员变量初始化过程 (请参考视频并画图:7步)
Student s = new Student();
1,Student.class加载进内存
* 2,声明一个Student类型引用s
* 3,在堆内存创建对象,
* 4,给对象中属性默认初始化值
* 5,属性进行显示初始化
* 6,构造方法进栈,对对象中的属性赋值,构造方法弹栈
* 7,将对象的地址值赋值给s
4:static关键字是什么?有什么特点?什么时候用呢?
static表示静态
随着类的加载而加载
优先于对象存在
被类的所有对象共享
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
5:main方法各种修饰符及参数的解释?
public 被jvm调用，访问权限足够大。
static 被jvm调用，不用创建对象，直接类名访问
void被jvm调用，不需要给jvm返回值
main 一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args 以前用于接收键盘录入的
编码题
请定义一个交通工具(Vehicle)的类其中有: 属性：速度(speed)、 体积(size)等，方法：移动(move())、设置速度(setSpeed(int speed))、加速 speedUp()、减速 speedDown()等。最后在测试类 Vehicle 中的 main()中实例化一个交通工具对象并通过方法给它初始化 speed,size 的值并且通过打印出来。另外调用加速、减速的方法对速度进行改变。
import java.util.Scanner;
class Test_Vehicle{
public static void main(String[] args) {
System.out.println("Hello World!");
/*请定义一个交通工具(Vehicle)的类其中有: 属性：速度(speed)、
体积(size)等，方法：移动(move())、设置速度(setSpeed(int speed))、
加速 speedUp()、减速 speedDown()等。
最后在测试类 Vehicle 中的 main()中实例化一个交通工具对象并通过方法给它初始化 speed,size 的值并且通过打印出来。
另外调用加速、减速的方法对速度进行改变。*/
Vehicle v1 = new Vehicle(50,"小");
System.out.println(v1.getSize() + "-------" + v1.getSpeed());
Scanner sc = new Scanner(System.in);
System.out.println("你想要加速还是减速,加速扣1,减速扣2");
int a = sc.nextInt();
if (a == 1 ) {
System.out.println("输入加速值");
int up = sc.nextInt();
v1.speedUp(up);
}
if (a == 2) {
System.out.println("输入减速值");
int down = sc.nextInt();
v1.speedDown(down);
}
System.out.println(v1.getSize() + "-------" + v1.getSpeed());
}
}
class Vehicle {
private int speed;
private String size;
public Vehicle() {}
public Vehicle(int speed,String size ) {
this.speed = speed;
this.size = size;
}
public void setSpeed(int speed) {
this.speed = speed;
}
public int getSpeed() {
return speed;
}
public void setSize(String size) {
this.size = size;
}
public String getSize() {
return size;
}
public void move() {
System.out.println("我移动了");
}
public int speedUp(int add) {
return speed += add;
}
public int speedDown(int reduce) {
return speed -= reduce;
}
}
编写 Java 程序用于显示人的姓名和年龄。定义一个人类Person。 该类中应该有两个私有属性： 姓名 （name） 和年龄 （age） 。定义构造方法用来初始化数据成员。再定义显示（display()） 方法将姓名和年龄打印出来。在 main 方法中创建人类的实例然后将信息显示。
class Dis {
public static void main(String[] args) {
Person p1 = new Person("张大仙",999);
p1.display();
System.out.println(p1.getName() + "........." + p1.getAge());
}
/*
编写 Java 程序用于显示人的姓名和年龄。定义一个人类Person。
该类中应该有两个私有属性： 姓名 （name） 和年龄 （age） 。
定义构造方法用来初始化数据成员。再定义显示（display()） 方法将姓名和年龄打印出来。
在 main 方法中创建人类的实例然后将信息显示。*/
}
class Person {
private String name;
private int age;
public Person() {}
public Person(String name,int age) {
this.name = name;
this.age = age;
}
public void setAge(int age ) {
this.age = age;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void display() {
System.out.println(name + "..." + age);
}
}
定义一个圆类——Circle，在类的内部提供一个属性：半径(r)，同时 提供 两个 方 法 ： 计算 面积 （ getArea() ） 和 计算 周长（getPerimeter()） 。 通过两个方法计算圆的周长和面积并且对计算结果进行输出。最后定义一个测试类对 Circle 类进行使用。
import java.util.Scanner;
class Cir{
public static void main(String[] args) {
/*定义一个圆类——Circle，在类的内部提供一个属性：半径(r)，同时 提供 两个 方 法 ：
计算 面积 （ getArea() ） 和 计算 周长（getPerimeter()） 。
通过两个方法计算圆的周长和面积并且对计算结果进行输出。
最后定义一个测试类对 Circle 类进行使用。*/
Scanner sc = new Scanner(System.in);
System.out.println("请输入圆的半径");
int r = sc.nextInt();
Circle c1 = new Circle(r);
System.out.println("圆的周长为" + c1.getPerimeter() + "圆的面积为" + c1.getArea());
}
}
class Circle {
private int r ;
public Circle(){}
public Circle(int r){
this.r = r;
}
public void setR(int r) {
this.r = r;
}
public int get() {
return r;
}
public double getArea() {
double area = r * r * 3.14;
return area;
}
public double getPerimeter() {
double perimeter = 3.14 * r * 2;
return perimeter;
}
}
构造方法与重载：定义一个网络用户类，要处理的信息有用户 ID、用户密码、 email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入， 其中用户 ID 和用户密码时必须缺省时 email地址是用户 ID 加上字符串"@gameschool.com"。
class Net{
public static void main(String[] args) {
/*构造方法与重载：定义一个网络用户类，要处理的信息有用户 ID、用户密码、 email 地址。
在建立类的实例时把以上三个信息都作为构造函数的参数输入，
其中用户 ID 和用户密码时必须缺少时 email地址是用户 ID 加上字符串"@gameschool.com"。*/
Network_User n1 = new Network_User("最课程2号",123456,"zuikecheng@gameschool.com");
System.out.println(n1.getId() + n1.getPassword() + n1.getEmail());
Network_User n2 = new Network_User("最课程2号");
System.out.println(n2.getId() + n2.getPassword() + n2.getEmail());
}
}
class Network_User {
private String id;
private int password;
private String email;
public Network_User() {}
public Network_User(String id,int password, String email) {
this.id = id;
this.password = password;
this.email = email;
}
public Network_User(String id) {
this.id = id;
this.email = id + "@gameschool.com";
}
public void setPassword(int password) {
this.password = password;
}
public int getPassword() {
return password;
}
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
public void setEmail(String email) {
this.email = email;
}
public String getEmail() {
return email;
}
}
可选题
定义一个类 Calculaion， 其中包含四个方法： 加（add()） 、 减（sub()） 、乘（times()） 和除（div()） 。 创建一个具有 main()函数的类。 在 main()函数中创建一个 Calculation 的实例对象并对其中的方法进行调用。
class Test {
public static void main(String[] args) {
/*定义一个类 Calculaion， 其中包含四个方法： 加（add()） 、 减（sub()） 、乘（times()） 和除（div()） 。
创建一个具有 main()函数的类
。 在 main()函数中创建一个 Calculation 的实例对象并对其中的方法进行调用*/
Calculation c1 = new Calculation(10,6);
System.out.println("参与运算的的俩个数为" + c1.a + "..." + c1.b);
System.out.println("加减乘除运算结果" + c1.add() + "..." + c1.sub() + "..." + c1.times() + "..." + c1.div());
}
}
class Calculation {
int a;
int b;
public Calculation() {}
public Calculation(int a ,int b) {
this.a = a;
this.b = b;
}
public int add() {
int sum = a + b;
return sum;
}
public int sub() {
int result = a - b;
return result;
}
public int times() {
int riding = a * b;
return riding;
}
public int div() {
int d = a / b;
return d;
}
}
定义一个类 Draw ， 在 类 中 提供 3 个 方法：输出直角三角形（drawTrian()） 、 输出矩形（drawRec()） 及平行四边形（drawPra()） 。通过方法可以输出由“*” 组成的一个图形。 同时在类中包含两个属性：星号的个数（count） 、行数（lines） 。最后在测试类中进行调用。
class Test2 {
public static void main(String[] args) {
/*定义一个类 Draw ， 在 类 中 提供 3 个 方法：输出直角三角形（drawTrian()） 、 输出矩形（drawRec()）
及平行四边形（drawPra()） 。通过方法可以输出由“*” 组成的一个图形。
同时在类中包含两个属性：星号的个数（count） 、行数（lines） 。最后在测试类中进行调用。*/
Draw d = new Draw(5,25);
d.drawTrian();
System.out.println("_________");
d.drawRec();
System.out.println("_________");
d.drawPra();
}
}
class Draw {
int count;
int lines;
public Draw() {}
public Draw(int lines, int count) {
this.lines = lines;
this.count = count;
}
public void drawTrian() {
for (int i = 0;i < lines ; i++) {
for (int j = 0;j <= i ;j++ ) {
System.out.print("*");
}
System.out.println();
}
}
public void drawRec() {
for (int i = 0 ;i < lines ;i++ ) {
for (int j = 0;j <= count/lines ; j++) {
System.out.print("*");
}
System.out.println();
}
}
public void drawPra() {
/* *****
*****
*****
*****
***** */
for (int i = 0 ;i < lines ;i++ ) {
int a = 0;
while (i >= a) {
System.out.print(" ");
a++;
}
for (int j = 0;j <= count/lines ; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
创建一个空调，并调用制冷、制热、通风功能。空调包含的属性有品牌、匹数、温度，功能有加热、制冷、通风等功能。
class Test3 {
public static void main(String[] args) {
Air_Conditioner a1 = new Air_Conditioner("格力",1,25.5);
System.out.println(a1.getBrand() + "..." + a1.getPower() + "..." +a1.getTemperature());
a1.function1();
a1.function2();
a1.function3();
}
}
class Air_Conditioner {
//创建一个空调，并调用制冷、制热、通风功能。空调包含的属性有品牌、匹数、温度，功能有加热、制冷、通风等功能。
private String brand;
private int power;
private double temperature;
public Air_Conditioner() {}
public Air_Conditioner(String brand,int power, double temperature) {
this.brand = brand;
this.power = power;
this.temperature = temperature;
}
public void setPower( int power) {
this.power = power;
}
public int getPower() {
return power;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getBrand() {
return brand;
}
public void setTemperature( double temperature) {
this.temperature= temperature;
}
public double getTemperature() {
return temperature;
}
public void function1() {
System.out.println("加热");
}
public void function2() {
System.out.println("制冷");
}
public void function3() {
System.out.println("通风");
}
}
定义一个表示学生信息的类 Student，要求如下：
（1）类 Student 的属性如下：
sNO 表示学号； sName 表示姓名； sSex 表示性别； sAge 表示
年龄；sJava：表示 Java 课程成绩。
（2）类 Student 带参数的构造方法：
在构造方法中通过形参完成对成员变量的赋值操作。
（3）类 Student 的方法成员：
getNo（）：获得学号；
getName（）：获得姓名；
getSex（）：获得性别；
getAge（）获得年龄；
getJava（）：获得 Java 课程成绩
（4） 根据类 Student 的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生 Java 语言成绩的平均值，以及计算并输出他们 Java 语言成绩的最大值和最小值。
class Test5{
public static void main(String[] args) {
establish();
}
/*定义一个表示学生信息的类 Student，要求如下：
（1）类 Student 的属性如下：sNO 表示学号； sName 表示姓名； sSex 表示性别； sAge 表示
年龄；sJava：表示 Java 课程成绩。(2）类 Student 带参数的构造方法：
在构造方法中通过形参完成对成员变量的赋值操作。（3）类 Student 的方法成员：
getNo（）：获得学号；getName（）：获得姓名；getSex（）：获得性别；getAge（）获得年龄；
getJava（）：获得 Java 课程成绩（4） 根据类 Student 的定义，创建五个该类的对象，输出每个学生的信息，
计算并输出这五个学生 Java 语言成绩的平均值，以及计算并输出他们 Java 语言成绩的最大值和最小值。*/
public static void establish() {
int i;
int[][] arr = new int[5][1];
for ( i = 0;i < 5 ;i++ ) {
Student si = new Student("张" + i,"男",20 + i,90 + i);
arr[i][0] = si.getSJava();
System.out.println(si.getSName() + "..." + si.getSSex() + "..." + si.getSAge() + "..." + si.getSJava());
}
int max = 0;
int min = 100;
int sum = 0;
for (i=0;i < 5;i++ ) {
if (arr[i][0] > max) {
max = arr[i][0];
}
}
for (i=0;i < 5;i++ ) {
if (arr[i][0] < min) {
min = arr[i][0];
}
}
for (i=0;i < 5;i++ ) {
sum += arr[i][0];
}
int average = sum / 5;
System.out.println("max为" + max +"\t" + "min为" + min + "\t" + "average为" + average);
}
}
class Student {
private String sName;
private String sSex;
private int sAge;
private int sJava;
public Student() {}
public Student(String sName,String sSex,int sAge,int sJava) {
this.sName = sName;
this.sSex = sSex;
this.sAge = sAge;
this.sJava = sJava;
}
public void setSAge(int sAge) {
this.sAge = sAge ;
}
public int getSAge() {
return sAge;
}
public void setSSex(String sSex) {
this.sSex = sSex;
}
public String getSSex() {
return sSex;
}
public void setSJava(int sJava) {
this.sJava = sJava;
}
public int getSJava() {
return sJava;
}
public void setSName(String sName) {
this.sName = sName;
}
public String getSName() {
return sName;
}
}
