类和对象作业
一、 填空题
1. 类是组成Java程序的基本要素，类体有两部分构成：一部分是变量的定义，另一部分是 方法 的定义。
2. 执行Person p = new Person();语句后，将在___ 堆内存________中给Person对象分配空间，并在栈内存中给引用变量p分配空间，存放Person对象的引用。
3. 构造器 是一种特殊方法，它的名字必须与它所在的类的名字完全相同，并且不书写返回值类型，在创建对象实例时由new运算符自动调用。
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);
}
public void count2(){
System.out.println("count2="+count);
}
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中关于静态方法，以下说法中正确的是（ AC ）。（选择两项）
A 静态方法中不能直接调用非静态方法
B. 非静态方法中不能直接调用静态方法
C. 静态方法可以用类名直接调用
D. 静态方法里可以使用this
5. 下列选项中关于Java中类方法的说法错误的是（ AC ）。（选择二项）
A 在类方法中可用this来调用本类的类方法
B. 在类方法中调用本类的类方法时可直接调用
C. 在类方法中只能调用本类中的类方法
D. 在类方法中调用实例方法需要先创建对象
三、 判断题
1. 类可以看成一类对象的模板，对象可以看成该类的一个具体实例。( T )
2. 如果没有为类中的某些成员赋初始值，Java会为类成员赋予固定的初始值，如数值变量的值为0，布尔变量的值为true，未初始化的引用为null。（ F ）
3. Java中所有的变量，不管是成员变量还是局部变量，在使用前都必须进行初始化。（ F ）
4. 在Java中对象可以赋值，只要使用赋值运算符即可，相当于生成了一个各属性与赋值对象相同的新对象。（ F ）
5. System.out.println(“Hello java!”)中out是System类的一个静态成员变量。（ T ）
6. 构造方法用于创建对象，一般不允许有任何返回值，因此需要在构造方法返回类型处标注为void。（ F ）
7. Java语言为所有的Java程序自动导入包“java.lang”，因此Java程序可以直接用“java.lang”中的类和接口。（ T ）
四、 简答题
1. 面向过程和面向对象的区别。（5分）
面向过程就是分析出解决问题所需的步骤，然后用函数把这些步骤一步一步的实现。
面向对象就是把构成问题事物分解成对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物在整个解决问题的步骤中的行为。
2. 类和对象的关系
类是对象的模板，对象是类的一个具体的实例。
3. 构造方法的作用和特征
作用：创建对象并对成员变量进行初始化。
特征：构造方法与类同名，不能书写返回值类型。
4. this关键字的作用和用法
作用：通过this关键字来访问自身的属性和方法。
5. 简述static关键字的作用。
提示：从static可以修饰变量，方法，代码块，内部类四个方面来回答。（5分）
static在Java语言中的使用有四种：(变量、方法、代码块、内部类)
1、static变量
按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
对于实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
2、静态方法
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！因为static方法独立于任何实例，因此static方法必须被实现
3、static代码块
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。
4.static内部类
1、用static修饰的内部类，称为静态内部类，完全属于外部类本身，不属于外部类某一个对象
2、static关键字的作用是把修饰的成员变成类相关，而不是实例相关
3、静态内部类可以包含静态成员，也可以包含非静态成员，但是在非静态内部类中不可以声明静态成员。
4、静态类内部不可以访问外部类的实例成员，只能访问外部类的类成员，即使是静态内部类的实例方法也不能访问外部类的实例成员，只能访问外部类的静态成员
5、外部类不可以定义为静态类，Java中静态类只有一种，那就是静态内部类，顶级类不能用static 修饰
6、外部类如何调用静态内部类中的属性和方法
1）外部类可以通过创建静态内部类实例的方法来调用静态内部类的非静态属性和方法
2）外部类可以直接通过“ 外部类.内部类.属性（方法）” 的方式直接调用静态内部类中的静态属性和方法
7、如何创建静态内部类实例
1）在非外部类中：外部类名.内部类名 name = new 外部类名.内部类名();
2）在外部类中：内部类名 name = new 内部类名();
五、 编码题
1. 请定义一个交通工具(Vehicle)的类其中有: 属性： 速度(speed)、 体积(size)等，方法：移动(move())、设置速度(setSpeed(int speed))、加速 speedUp()、减速 speedDown()等。最后在测试类 Vehicle 中的 main()中实例化一个交通工具对象并通过方法给它初始化 speed,size 的值并且通过打印出来。另外调用加速、减速的方法对速度进行改变。
public class Vehicle {
private int speed;
private String size;
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
System.out.println("初始速度设置为:"+speed+"Km/h");
}
public String getSize() {
return size;
}
public void setSize(String size) {
this.size = size;
System.out.println("初始体积设置为"+size+"m^3");
}
public void move(){
System.out.println("行进中....,速度为:"+speed+"KM/h");
}
public void speedUp(int speed){this.speed+=15;
System.out.println("速度加速到15后为:"+speed+"Km/h");}
public void speedDown(int speed){this.speed-=10;
System.out.println("速度减速至10后为:"+speed+"Km/h");}
}
public class TestVehicle {
public static void main(String[] args) {
Vehicle vehicle=new Vehicle();
vehicle.setSize("50");
vehicle.setSpeed(5);
vehicle.move();
vehicle.speedUp(25);
vehicle.speedDown(9);
}
}
2. 编写 Java 程序用于显示人的姓名和年龄。定义一个人类Person。 该类中应该有两个私有属性： 姓名
3. (name） 和年龄 （age） 。定义构造方法用来初始化数据成员。再定义显示（display()） 方法将姓名和年龄打印出来。在 main 方法中创建人类的实例然后将信息显示。
public class Person {
private String name;
private int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public void display(){
System.out.println("姓名:"+name+"\t"+"年龄:"+age);
}
public static void main(String[] args) {
Person person=new Person("熊三",19);
person.display();
}
}
4. 定义一个圆类——Circle，在类的内部提供一个属性：半径(r)，同时 提供 两个 方 法 ： 计算 面积 （ getArea() ） 和 计算 周长（getPerimeter()） 。 通过两个方法计算圆的周长和面积并且对计算结果进行输出。最后定义一个测试类对 Circle 类进行使用。
public class Circle {
private int radius;//设置圆的半径
public int getRadius() {
return radius;
}
public void setRadius(int radius) {
this.radius = radius;
}
double π=3.14;
public void getArea(){//获取圆的面积
double s=0;
s+=π*radius*radius;//圆的面积等于πr^2
System.out.println("这个圆的面积等于:"+s);
}
public void getPerimeter(){//获取圆的周长
double perimeter=0;
perimeter+=2*π*radius;//圆的周长等于2πr
System.out.println("这个圆的周长等于:"+perimeter);
}
}
public class TestCircle {
public static void main(String[] args) {
Circle circle=new Circle();
circle.setRadius(3);
circle.getArea();
circle.getPerimeter();
}
}
5. 构造方法与重载：定义一个网络用户类，要处理的信息有用户 ID、用户密码、 email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入， 其中用户 ID 和用户密码时必须缺省时 email地址是用户 ID 加上字符串"@gameschool.com"。
public class NetUser {
String userID;
int passWord;
String email;
public NetUser(String userID,int passWord,String email) {
this.userID = userID;
this.passWord = passWord;
this.email = email;
if (userID == null || passWord == 0) {
System.out.println("userID:" + userID + "\t" + "passWord:" + passWord + "\t" + "email:" + userID + "@gameschool.com");
return;
}
System.out.println("userID:" + userID + "\t" + "passWord:" + passWord + "\t" + "email:" +email );
}
}
public class TestNetUser {
public static void main(String[] args) {
NetUser netUser=new NetUser("熊猫",12306,"张家口");
}
}
可选题:4. 定义一个表示学生信息的类 Student，要求如下：
（1）类 Student 的属性如下：
sNO 表示学号； sName 表示姓名； sSex 表示性别； sAge 表示
年龄；sJava：表示 Java 课程成绩。
（2）类 Student 带参数的构造方法：
在构造方法中通过形参完成对成员变量的赋值操作。
（3）类 Student 的方法成员：
getNo（）：获得学号；
getName（）：获得姓名；
getSex（）：获得性别；
getAge（）获得年龄；
getJava（）：获得 Java 课程成绩
（4） 根据类 Student 的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生 Java 语言成绩的平均值，以及计算并输出他们 Java 语言成绩的最大值和最小值。
public class Student {
String sNO;
String sName;
String sSex;
int sAge;
double sJava;
public Student(String sNO,String sName,String sSex,int sAge,double sJava){
this.sNO=sNO;
this.sName=sName;
this.sSex=sSex;
this.sAge=sAge;
this.sJava=sJava;
}
public void getNo(){
System.out.println("学号:"+sNO);
}
public void getSname(){
System.out.println("姓名:"+sName);
}
public void getSsex(){
System.out.println("性别:"+sSex);
}
public void getSage(){
System.out.println("年龄:"+sAge);
}
public void getSjava(){
System.out.println("Java课程成绩:"+sJava);
}
}
import java.util.Arrays;
public class TestStudent {
public static void main(String[] args) {
Student s1=new Student("0402210608","哈拉少","男",18,83.5);
Student s2=new Student("8888666","冷少","男",19,95.8);
Student s3=new Student("333222","冷笑","男",18,85.6);
Student s4=new Student("333666","龙少","男",17,89.0);
Student s5=new Student("666999","狂刀","男",19,88);
s1.getNo();s1.getSage();s1.getSname();s1.getSsex();s1.getSjava();
s2.getNo();s2.getSage();s2.getSname();s2.getSsex();s2.getSjava();
s3.getNo();s3.getSage();s3.getSname();s3.getSsex();s3.getSjava();
s4.getNo();s4.getSage();s4.getSname();s4.getSsex();s4.getSjava();
s5.getNo();s5.getSage();s5.getSname();s5.getSsex();s5.getSjava();
System.out.println("这五名同学java语言成绩的平均值:"+(s1.sJava+s2.sJava+s3.sJava+s4.sJava+s5.sJava)/5+"分");
double[] arr={s1.sJava,s2.sJava,s3.sJava,s4.sJava,s5.sJava};
Arrays.sort(arr);//Arrays中的sort方法，进行数组自动排序，按从小到大的顺序
System.out.println("排序后的顺序:"+Arrays.toString(arr));
System.out.println("他们中java成绩的最大值:"+arr[arr.length-1]+"分");
System.out.println("他们中java成绩的最小值:"+arr[0]+"分");
}
}
封装和多态作业
一、 选择题
1. 使用权限修饰符（ B ）修饰的类的成员变量和成员方法，可以被当前包中所有类访问，也可以被它的子类（同一个包以及不同包中的子类）访问。（选择一项）
A public
B. protected
C. 默认
D. private
2. 给出如下代码，如何使成员变量m被方法fun()直接访问（ C ）。（选择一项）
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
二、 判断题
1. 使用public修饰的成员属性和方法可以被当前项目中所有包的所有类访问。( T )
2. 类的方法通常设为public，而类的实例变量一般也设为public。（ F ）
3. 与未加访问控制符的缺省情况相比，public和protected修饰符扩大了类及其属性和方法的被访问范围，private修饰符则缩小了这种范围。（ T ）
4. 访问权限是private的变量，只能在本类和与本类同一个包中的其他类使用。（ F ）
三、 简答题
1. private、默认、protected、public四个权限修饰符的作用
1) 权限修饰符用来修饰类，接口，方法，变量
2) 修饰类：public，默认（default）
3) 修饰接口：public 默认（default）
4) 修饰方法：public，protected，default，private都可以
5) 修饰变量：public，protected，default，private都可以
四、 编码题
1. 使用面向对象的思想，编写自定义描述狗的信息。设定属性包括：品种，年龄，心情，名字；方法包括：叫，跑。
要求：
1) 设置属性的私有访问权限，通过公有的get,set方法实现对属性的访问
2) 限定心情只能有“心情好”和“心情不好”两种情况，如果无效输入进行提示，默认设置“心情好”。
3) 设置构造函数实现对属性赋值
4) 叫和跑的方法，需要根据心情好坏，描述不同的行为方式。
5) 编写测试类，测试狗类的对象及相关方法（测试数据信息自定义）
public class Dog {
private String strain;
private int age;
private String mood;
private String name;
public Dog(String strain,int age,String mood,String name){
this.strain=strain;
this.age=age;
this.mood=mood;
this.name=name;
if ("心情好".equals(mood)||"心情不好".equals(mood)){
this.mood=mood;
}else {
System.out.println("您输入的信息无效，默认设置：心情好");
return;
}
System.out.println("品种："+strain+"\t"+"年龄:"+age+"\t"+"心情:"+mood+"\t"+"姓名:"+name);
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getMood() {
return mood;
}
public void setMood(String mood) {
if ("心情好".equals(mood)||"心情不好".equals(mood)){
this.mood=mood;
}else {
System.out.println("您输入的信息无效，默认设置：心情好");
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void bark(){
if ("心情好".equals(mood)){
System.out.println("心情很好，开心的汪汪汪");
}else{
System.out.println("心情不好，伤心的呜呜叫");
}
}
public void run(){
if ("心情好".equals(mood)){
System.out.println("心情很好，开心的围着主人身边转");
}else{
System.out.println("心情不好，伤心的一动不动");
}
}
}
public class TestDog {
public static void main(String[] args) {
Dog dog=new Dog("哈士奇",2,"心情不好","小白");
dog.bark();
dog.run();
}
}
2. 以面向对象的思想，编写自定义类描述IT从业者。设定属性包括：姓名，年龄，技术方向，工作年限, 工作单位和职务；方法包括：工作
要求：
1) 设置属性的私有访问权限，通过公有的get,set方法实现对属性的访问
2) 限定IT从业人员必须年满15岁，无效信息需提示，并设置默认年龄为15。
3) 限定“技术方向”是只读属性
4) 工作方法通过输入参数，接收工作单位和职务，输出个人工作信息
5) 编写测试类，测试IT从业者类的对象及相关方法（测试数据信息自定义）
public class ITWorker {
private String name;
private int age;
private String technicalDirection;//技术方向
private int workingYears;//工作年限
private String employer;//工作单位
private String jobTitle;//职务
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>=15){
this.age=age;
}else {
System.out.println("无效输入,默认年龄为15岁");
}
}
public String getTechnicalDirection() {
return technicalDirection;
}
public void setTechnicalDirection(String technicalDirection) {
this.technicalDirection = technicalDirection;
}
public int getWorkingYears() {
return workingYears;
}
public void setWorkingYears(int workingYears) {
this.workingYears = workingYears;
}
public String getEmployer() {
return employer;
}
public void setEmployer(String employer) {
this.employer = employer;
}
public String getJobTitle() {
return jobTitle;
}
public void setJobTitle(String jobTitle) {
this.jobTitle = jobTitle;
}
public void work(String employer,String jobTitle){
System.out.println("姓名:"+getName());
System.out.println("年龄:"+getAge()+"岁");
System.out.println("技术方向:"+getTechnicalDirection());
System.out.println("工作年限:"+getWorkingYears()+"年");
System.out.println("工作单位:"+employer);
System.out.println("职务:"+jobTitle);
}
}
public class TestITWorker {
public static void main(String[] args) {
ITWorker itWorker=new ITWorker();
itWorker.setName("马洪");
itWorker.setAge(23);
itWorker.setTechnicalDirection("Java开发");
itWorker.setWorkingYears(3);
itWorker.work("鼎盛科技","Java开发工程师");
}
}
五、 可选题
1. 以面向对象的思想，编写自定义类描述图书信息。设定属性包括：书名，作者，出版社名，价格；方法包括：信息介绍
要求：
1) 设置属性的私有访问权限，通过公有的get,set方法实现对属性的访问
2) 限定介格必须大于10，如果无效进行提示
3) 限定作者，书名为只读属性
4) 设计构造方法实现对属性赋值
5) 信息介绍方法描述图书所有信息
6) 编写测试类，测试图书类的对象及相关方法（测试数据信息自定）
public class Books {
private String bookName;//书名
private String author;//作者名
private String press;//出版社
private double price;//价格
public Books(String bookName, String author, String press, double price) {
this.bookName = bookName;
this.author = author;
this.press = press;
this.price = price;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public String getPress() {
return press;
}
public void setPress(String press) {
this.press = press;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public void informationIntroduce(){
if (price<=10){
System.out.println("由于价格无效，无法输出相关信息");
}else{
System.out.println("书名:"+getBookName());
System.out.println("作者:"+getAuthor());
System.out.println("出版社:"+getPress());
System.out.println("价格:"+getPrice()+"RMB");
}
}
}
public class TestBook {
public static void main(String[] args) {
Books books=new Books("鹿鼎记","金庸","人民文学出版社",125);
books.informationIntroduce();
}
}
继承作业
一、 选择题
1. 以下关于继承条件下构造方法执行过程的代码的执行结果是（ A ）。（选择一项）
class Person {
public Person() {
System.out.println("execute Person()");
}
}
class Student extends Person {
public Student() {
System.out.println("execute Student() ");
}
}
class PostGraduate extends Student {
public PostGraduate() {
System.out.println("execute PostGraduate()");
}
}
public class TestInherit {
public static void main(String[] args) {
new PostGraduate();
}
}
A. execute Person()
execute Student()
execute PostGraduate()
B. execute PostGraduate()
C. execute PostGraduate()
execute Student()
execute Person()
D. 没有结果输出
2. 以下关于this和super关键字的说法错误的是（ BD ）。（选择二项）
A. this关键字指向当前对象自身，super关键字指向当前对象的直接父类
B. 在main方法中可以存在this或super关键字，但不能同时存在。
C. this和super关键字都可以访问成员属性，成员方法和构造方法
D. 在一个类的构造方法中可以同时使用this和super来调用其他构造方法
3. 给出下面的代码段，在代码说明//assignment x=a,y=b处写入如下（ D ）个代码是正确的。（选择一项）
public class Base {
int w, x, y, z;
public Base(int a, int b) {
x = a;
y = b;
}
public Base(int a, int b, int c, int d) {
// assignment x=a,y=b
w = d;
z = c;
}
}
A Base(a,b);
B. x=a,y=b; //赋值语句不能用逗号隔开
C. this(a),this(b);
D. this(a,b)
4. 以下Java程序编译运行后的输出结果是（ A ）。（选择一项）
class HelloA {
public HelloA( ) {
System.out.println("HelloA");
}
{ System.out.println("I'm A class");
}
static {
System.out.println("static A");
}
}
public class HelloB extends HelloA {
public HelloB( ) {
System.out.println("HelloB");
}
{ System.out.println("I'm B class");
}
static {
System.out.println("static B");
}
public static void main(String[] args) {
new HelloB( );
}
}
A static A
static B
I'm A class
HelloA
I'm B class
HelloB C. static A
I'm A class
HelloA
static B
I'm B class
HelloB
B. static A
static B
I'm A class
I'm B class
HelloA
HelloB D static A
static B
HelloA
HelloB
I'm A class
I'm B class
5. 下列选项中关于Java中super关键字的说法正确的是（ AD ）。（选择二项）
A super关键字是在子类对象内部指代其父类对象的引用
B. super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C. 子类通过super关键字只能调用父类的方法，而不能调用父类的属性
D. 子类通过super关键字可以调用父类的构造方法
二、 判断题
1. 如果定义一个类时没有使用extends，则它的父类是java.lang.Object。（ T ）
2. 对子类实例化对象需要调用超类的构造函数进行初始化工作，完成对子类中的超类实例变量的初始化，则子类可以继承超类的构造函数。（ T ）
3. 在Java中任何一个子类的构造方法都必须调用其父类的构造方法（包括隐式调用），并且调用父类的构造方法的语句必须是子类构造方法的第一条语句。（F ）
4. Java中的类不允许多重继承，一个类只能有有一个直接父类。(T)
5. Object类有一个public方法是toString( )，一个对象通过调用该方法可以获得该对象的字符串表示。（ T ）
6. 父类Person中定义了一个private void show()的方法，那么子类要重写这个方法时，方法的访问修饰符可以是默认的，protected或public。（ F ）
7. 运算符“==”用于比较引用时，如果两个引用指向内存同一个对象，则返回true。（ T ）
三、 简答题
1. 方法重载和方法重写（覆盖）的区别。
方法重载的规则是方法名相同参数列表不同的方法叫做方法的重载。
方法重写的规则是方法名相同，参数列表相同， 返回类型小于等于父类的返回类型，并且被重写的方法的访问权限必须要大于等于父类的访问权限，重写方法不能比原方法抛出更多异常
被重写的方法不能是final类型，因为final修饰的方法是无法进行重写的。
被重写的方法不能是private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。
2. java.lang.Object类的六个常用方法的声明并说明其作用。
1) public boolean equals(java.lang.Object) 比较对象的地址值是否相等，如果子类重写，则比较对象的内容是否相等；
2) .public native int hashCode() 获取哈希码
3) public java.lang.String.toString() 把数据转变为字符串
4) public final native java.lang.Class.getClass() 获取类结构信息
5) protected void finalize() throws java.lang.Throwable 垃圾回收前执行的方法
6) protectednativeObjectclone()throwsjava.lang.CloneNotSupportedException 克隆
7) public final void wait() throws java.lang.InterrupredException 多线程中等待功能
8) public final native void notify() 多线程中唤醒功能
9) public final native void notifyAll() 多线程中唤醒所有等待线程的功能
3. 继承条件下子类构造方法的执行过程
1）将class文件加载到JVM
2）使用构造方法创建子类对象，调用构造方法前，使用super关键字初始化父类的构造
3) 判断父类有没有属性没有初始化，如果有初始化属性
4） 执行父类构造方法体
5） 判断子类有没有属性没有初始化，如果有初始化属性
6） 执行子类的构造方法体
7） 如果有成员方法，执行成员方法体，成员方法执行之前所有属性全部初始化完毕
4. super关键字的作用和使用
1） super关键字可以在子类构造方法中调用父类的构造方法，super()必须位于子类构造函数的第一行。
2） super关键字可以用来调用父类的成员变量和方法，当子类成员变量或方法与父类有这相同的名字就会覆盖父类的成员变量和方法，这时就需要使用super关键字来访问父类的成员变量和方法，子类方法中的super.方法名()不需要位于第一行。
5. ==和equals()的联系和区别
==对于基本数据类型的变量，则直接比较其存储的值是否相等。
==对于引用数据类型的变量，则比较的是所指向的对象的地址。
equals()方法，不能作用于基本数据类型的变量，所有类从object类中继承的equals方法，比较的是是否是同一个对象。
如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址。
如String ，Date等类对equals方法进行了重写，则比较的就是所指向的对象的内容。
四、 编码题
1. 编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。（7分）
提示:（1）编写一个圆类Circle，该类拥有：
1) 一个成员变量，radius（私有，浮点型）;//存放圆的半径；
2) 两个构造方法
Circle（） //将半径设为0
Circle（double r ） //创建Circle对象时将半径初始化为r
3) 三个成员方法
double getArea（） //获取圆的面积
double getPerimeter（） //获取圆的周长
void show（） //将圆的关径、周长、面积输出到屏幕
（2） 编写一个圆柱体类Cylinder，它继承于上面的Circle类。还拥有：
1) 一个成员变量，double hight （私有，浮点型）; //圆柱体的高；
2) 构造方法
//创建Cylinder对象时将半径初始化为r,高度初始化为h
Cylinder（double r,double h）
3) 成员方法
double getVolume（） //获取圆柱体的体积
void showVolume（） //将圆柱体的体积输出到屏幕
public class Circle {
private double radius;
public Circle(){this.radius=0;}
public Circle(double r){this.radius=r;}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius =radius;
}
public double getArea(){
double s=0;
s+=Math.PI*radius*radius;
return s;
}
public double getPerimeter(){
double perimeter=0;
perimeter+=2*Math.PI*radius;
return perimeter;
}
public void show(){
System.out.println("圆的半径:"+radius);
System.out.println("圆的面积:"+getArea());
System.out.println("圆的周长:"+getPerimeter());
}
}
public class Cylinder extends Circle{
private double high;
public Cylinder(double r,double h){
super(r);
this.high=h;
}
public double getVolume(){//获取圆柱体体积的方法，圆柱体体积=底面积乘以高(π*r^2)*h
double volume=0;
volume+=super.getArea()*high;
return volume;
}
public void showVolume(){
System.out.println("圆柱体的体积:"+getVolume());
}
public static void main(String[] args) {
Cylinder cylinder=new Cylinder(3,6);
cylinder.show();
cylinder.showVolume();
}
}
2. 请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息。
设定
1) 出租车类:
属性包括：车型，车牌，所属出租公司；方法包括：启动，停止
2) 家用轿车类：
属性包括：车型，车牌，车主姓名；方法包括：启动，停止
要求
1) 分析出租车和家用轿车的公共成员，提取出父类—汽车类
2) 利用继承机制，实现出租车类和家用轿车类
3) 编写测试类，分别测试汽车类，出租车类和家用轿车类对象的相关方法
4) 定义名为car的包存放汽车类，出租车类，家用轿车类和测试类
public class Car {
private String type;
private String No;
public Car() {
super();
}
public Car(String type, String no) {
super();
this.type = type;
this.No = no;
}
public void start(){
System.out.println("车子已经启动了");
}
public void stop(){
System.out.println("车子正在缓慢停止");
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getNo() {
return No;
}
public void setNo(String no) {
this.No = no;
}
}
public class PrivateCar extends Car {
private String name;
public PrivateCar(){super();}
public PrivateCar(String type,String no,String name){
super(type,no);
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public void start(){
System.out.println("我是"+name+"车主,新提的汽车，带你去兜风");
}
@Override
public void stop(){
System.out.println("目的地到了，我们去拍照吧");
}
}
public class Taxi extends Car {
String rentalCompany;
public Taxi(){super();}
public Taxi(String type,String No,String rentalCompany){
super(type,No);
this.rentalCompany=rentalCompany;
}
public String getRentalCompany() {
return rentalCompany;
}
public void setRentalCompany(String rentalCompany) {
this.rentalCompany = rentalCompany;
}
@Override
public void start(){
System.out.println("您好，我是"+rentalCompany+"公司，车牌号:"+super.getNo()+"您要去哪里?");
}
@Override
public void stop(){
System.out.println("目的地已到达，祝您乘车愉快，欢迎您下次乘坐");
}
}
public class TestCar {
public static void main(String[] args) {
Car car=new Car();
car.start();
car.stop();
System.out.println("-----------------------------");
Taxi taxi=new Taxi("丰田","豫A888666","胡龙顺风");
taxi.start();
taxi.stop();
System.out.println("------------------------------");
PrivateCar privateCar=new PrivateCar("BPM","豫V666999","胡三宝");
privateCar.start();
privateCar.stop();
}
}
3. 某公司要开发新游戏，请用面向对象的思想，设计游戏中的蛇怪和蜈蚣精
设定
1) 蛇怪类:
属性包括：怪物名字，生命值，攻击力
方法包括：攻击，移动（曲线移动），补血（当生命值<10时，可以补加20生命值）
2) 蜈蚣精类：
属性包括：怪物名字，生命值，攻击力
方法包括：攻击，移动（飞行移动）
要求
1) 分析蛇怪和蜈蚣精的公共成员，提取出父类—怪物类
2) 利用继承机制，实现蛇怪类和蜈蚣精类
3) 攻击方法，描述攻击状态。内容包括怪物名字，生命值，攻击力
4) 编写测试类，分别测试蛇怪和蜈蚣精的对象及相关方法
5) 定义名为mon的包存怪物类，蛇怪类，蜈蚣精类和测试类
public class Monster {
private String name;
private int bloodVolume;
private int attackPower;
public Monster(){super();}
public Monster(String name, int bloodVolume, int attackPower) {
super();
this.name = name;
this.bloodVolume = bloodVolume;
this.attackPower = attackPower;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBloodVolume() {
return bloodVolume;
}
public void setBloodVolume(int bloodVolume) {
this.bloodVolume = bloodVolume;
}
public int getAttackPower() {
return attackPower;
}
public void setAttackPower(int attackPower) {
this.attackPower = attackPower;
}
public void attack(){
System.out.println("正在发生激烈战斗");
}
public void move(){
System.out.println("正在飞快移动");
}
}
public class Basilisk extends Monster{
public Basilisk(){super();}
public Basilisk(String name,int bloodVolume,int attackPower){
super(name,bloodVolume,attackPower);
}
@Override
public void attack(){
System.out.println("攻击状态:很好\t怪物名字:"+super.getName()+"\t"+"生命值:"+super.getBloodVolume()+"\t"+"攻击力:"+super.getAttackPower());
}
@Override
public void move(){
System.out.println("我是"+super.getName()+"正在曲线移动");
}
public void addBlood(){
if (super.getBloodVolume()<10){
System.out.println("由于血量少于10点，可以补加20滴血量值,当前生命值:"+(super.getBloodVolume()+20));
}else {
System.out.println("血量目前比较健康，无需进行补血");
}
}
}
public class Centipede extends Monster {
public Centipede(){super();}
public Centipede(String name,int bloodVolume,int attackPower){
super(name,bloodVolume,attackPower);
}
@Override
public void attack(){
System.out.println("攻击状态:很好\t怪物名字:"+super.getName()+"\t"+"生命值:"+super.getBloodVolume()+"\t"+"攻击力:"+super.getAttackPower());
}
@Override
public void move(){
System.out.println("我是"+super.getName()+"正在飞行移动");
}
}
public class Test {
public static void main(String[] args) {
Monster monster=new Monster();
monster.attack();
monster.move();
System.out.println("--------------------------------");
Basilisk basilisk=new Basilisk("蛇怪",5,83);
basilisk.attack();
basilisk.move();
basilisk.addBlood();
System.out.println("----------------------------------");
Centipede centipede=new Centipede("蜈蚣",88,105);
centipede.attack();
centipede.move();
}
}
可选题：1. 请用面向对象的思想，设计自定义类描述演员和运动员的信息
设定
1) 演员类:
属性包括：姓名，年龄，性别，毕业院校，代表作
方法包括：自我介绍
2) 运动员类：
属性包括：姓名，年龄，性别，运动项目，历史最好成绩
方法包括：自我介始
要求
3) 分析演员和运动员的公共成员，提取出父类—人类
4) 利用继承机制，实现演员类和运动员类
5) 编写测试类，分别测试人类，演员类和运动员类对象及相关方法
6) 定义名为act的包存人类，演员类，运动员类和测试类
package act;
public class Person {
private String name;
private int age;
private String gender;
public Person(){super();}
public Person(String name,int age,String gender){
super();
this.name=name;
this.age=age;
this.gender=gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public void introduce(){
System.out.println("我就是个普通人");
}
}
public class Actor extends Person {
private String graduatedSchool;//毕业院校
private String masterpiece;//代表作
public Actor(){super();}
public Actor(String name,int age,String gender,String graduatedSchool,String masterpiece){
super(name,age,gender);
this.graduatedSchool=graduatedSchool;
this.masterpiece=masterpiece;
}
public String getGraduatedSchool() {
return graduatedSchool;
}
public void setGraduatedSchool(String graduatedSchool) {
this.graduatedSchool = graduatedSchool;
}
public String getMasterpiece() {
return masterpiece;
}
public void setMasterpiece(String masterpiece) {
this.masterpiece = masterpiece;
}
@Override
public void introduce(){
System.out.println("大家好！我是:"+super.getName());
System.out.println("今年"+super.getAge()+"岁");
System.out.println("性别:"+super.getGender());
System.out.println("毕业院校:"+this.graduatedSchool);
System.out.println("代表作:"+this.masterpiece);
}
}
public class Athlete extends Person {
private String sports;
private double score;
public Athlete(){super();}
public Athlete(String name,int age,String gender,String sports,double score){
super(name,age,gender);
this.sports=sports;
this.score=score;
}
public String getSports() {
return sports;
}
public void setSports(String sports) {
this.sports = sports;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public void introduce(){
System.out.println("大家好！我是:"+super.getName());
System.out.println("今年"+super.getAge()+"岁");
System.out.println("性别:"+super.getGender());
System.out.println("我擅长的运动项目:"+this.getSports());
System.out.println("历史最好成绩:"+this.getScore());
}
}
public class Test {
public static void main(String[] args) {
Person person=new Person();
person.introduce();
System.out.println("------------------------------------");
Actor actor=new Actor("杨洋",29,"男","北京电影传媒学院","《三生三世十里桃花》");
actor.introduce();
System.out.println("----------------------------------------------");
Athlete athlete=new Athlete("苏炳添",32,"男","100米短跑",9.83);
athlete.introduce();
}
}
