一.学习总结
1.阅读下面程序，分析是否能编译通过？如果不能，说明原因。应该如何修改？程序的运行结果是什么？为什么子类的构造方法在运行之前，必须调用父类的构造方法？能不能反过来？
class Grandparent {
public Grandparent() {
System.out.println("GrandParent Created.");
}
public Grandparent(String string) {
System.out.println("GrandParent Created.String:" + string);
}
}
class Parent extends Grandparent {
public Parent() {
System.out.println("Parent Created");
super("Hello.Grandparent.");
}
}
class Child extends Parent {
public Child() {
System.out.println("Child Created");
}
}
public class Test{
public static void main(String args[]) {
Child c = new Child();
}
}
该程序不能编译通过。原因：调用父类的构造函数必须在构造方法的第一个语句。修改的程序如下：
class Parent extends Grandparent {
public Parent() {
super("Hello.Grandparent.");
System.out.println("Parent Created");
}
}
程序运行结果如下所示：
GrandParent Created.String:Hello.Grandparent.
Parent Created
Child Created
构造函数是一种特殊的方法:主要用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数，可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载。构造函数的功能主要用于在类的对象创建时定义初始化的状态。构造一个对象，先调用其构造方法，来初始化其成员函数和成员变量。
子类拥有父的成员变量和成员方法，如果不调用，则从父类继承而来的成员变量和成员方法得不到正确的初始化。
2.阅读下面程序，分析程序中存在哪些错误，说明原因，应如何改正？正确程序的运行结果是什么？
class Animal{
void shout(){
System.out.println("动物叫!");
}
}
class Dog extends Animal{
public void shout(){
System.out.println("汪汪......!");
}
public void sleep() {
System.out.println("狗狗睡觉......");
}
}
public class Test{
public static void main(String args[]) {
Animal animal = new Dog();
animal.shout();
animal.sleep();
Dog dog = animal;
dog.sleep();
Animal animal2 = new Animal();
dog = (Dog)animal2;
dog.shout();
}
}
分析：(1) Animal animal = new Dog();是Dog的向上转型，在Dog类中没有覆写sleep()方法，所以在测试类中animal.sleep();这一语句无法调用sleep()方法，应将其转换成Dog类型：((Dog)animal).sleep(); （2） Dog dog = animal;不能从动物到狗；(3)Animal animal2 = new Animal(); animal2需先向上转型再向下转型。
改正的程序如下所示：
package test4;
class Animal{
void shout(){
System.out.println("动物叫!");
}
}
class Dog extends Animal{
public void shout(){
System.out.println("汪汪......!");
}
public void sleep() {
System.out.println("狗狗睡觉......");
}
}
public class Test{
public static void main(String args[]) {
Animal animal = new Dog();
animal.shout();
((Dog)animal).sleep();
Dog dog = (Dog)animal;
dog.sleep();
Animal animal2 = new Dog();
dog = (Dog)animal2;
dog.shout();
}
}
运行结果如下所示：
汪汪......!
狗狗睡觉......
狗狗睡觉......
汪汪......!
3.运行下列程序
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
}
public class Test{
public static void main(String args[]){
Person per = new Person("张三",20) ;
System.out.println(per);
System.out.println(per.toString()) ;
}
}
（1）程序的运行结果如下，说明什么问题？
Person@166afb3
Person@166afb3
问题：调用了toString方法，但只输出了类名地址信息。
（2）那么，程序的运行结果到底是什么呢？利用eclipse打开println(per)方法的源码，查看该方法中又调用了哪些方法,能否解释本例的运行结果？
toString方法源码
public String toString(){
return getClass().getName()+"@"+Integer.toHexSring(hashCode());
}
如果类中没有进行toSting方法的覆写，则调用getClass(),getName()一些默认输出。
（3）在Person类中增加如下方法
public String toString(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
重新运行程序，程序的执行结果是什么？说明什么问题？
姓名：张三，年龄：20
姓名：张三，年龄：20
存在的问题是：加不加toString方法结果都是一样的，对象输出的时候一定会调用Object类中的toString方法打印内容，在类中覆写toString方法，直接输出对象则是调用覆写之后的方法。(Object类：每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。在不明确给出超类的情况下，Java会自动把Object作为要定义类的超类。可以使用类型为Object类变量指向任意类型的对象。Object类有一个默认构造方法pubilc Object()，在构造子类实例时，都会先调用这个默认构造方法。)
4.汽车租赁公司，出租汽车种类有客车、货车和皮卡三种，每辆汽车除了具有编号、名称、租金三个基本属性之外，客车有载客量，货车有载货量，皮卡则同时具有载客量和载货量。用面向对象编程思想分析上述问题，将其表示成合适的类、抽象类或接口，说明设计思路。现在要创建一个可租车列表，应当如何创建？
思路：创建一个汽车的父类，然后创建三个子类（分别为客车，货车，皮卡）去继承，分别输入相应的属性；然后再创建两个接口（乘客，载货），让三个子类根据自己的需要去继承。
5.阅读下面程序，分析代码是否能编译通过，如果不能，说明原因，并进行改正。如果能，列出运行结果
interface Animal{
void breathe();
void run();
void eat();
}
class Dog implements Animal{
public void breathe(){
System.out.println("I'm breathing");
}
void eat(){
System.out.println("I'm eating");
}
}
public class Test{
public static void main(String[] args){
Dog dog = new Dog();
dog.breathe();
dog.eat();
}
}
该程序不能编译通过。原因是：(1)class Dog implements Animal{} Dog的类型必须实现继承的抽象animal方法，可通过增加Animal.run()方法。
(2)void eat(){} 因为接口定义的方法默认是public的,意思就是没有任何访问修饰符的情况下,系统给接口的方法加上了一个public的访问修饰符。
修改之后的程序如下所示：
interface Animal{
void breathe();
void run();
void eat();
}
class Dog implements Animal{
public void breathe(){
System.out.println("I'm breathing");
}
public void eat(){
System.out.println("I'm eating");
}
@Override
public void run() {
// TODO Auto-generated method stub
}
}
public class Test{
public static void main(String[] args){
Dog dog = new Dog();
dog.breathe();
dog.eat();
}
}
运行结果如下所示：
I'm breathing
I'm eating
6.个人总结
本次作业个人掌握内容：
（1）继承：类继承的格式如下所示
class 父类{} //定义父类
class 子类 extends 父类{} //使用extends关键字实现继承
注：只允许多层继承，而不能多重继承。即一个子类只能继承一个父类，在多层继承中，即一个子类可以有一个父类，一个父类还可以有一个父类。
实例化子类对象，先调用父类构造，再调用子类构造。
在子类的构造方法中隐含了一个super()的语法，调用语句须为子类构造方法的第一执行语句。
（2）方法覆写：
是指子类定义了与父类中同名的方法，在方法覆写是必须考虑权限，即被子类覆写的方法不能拥有比父类方法更加严格的访问权限。
方法的重载与覆写的区别：
重载定义：方法名称相同，参数的类型或个数不同；对权限没有要求；范围：发生在一个类中；
覆写定义：方法名称，参数的类型，返回值类型全部相同；被覆写的方法不能拥有更严格的权限；发生在继承类中。
（3）super关键字的作用：
使用super关键字可以从子类中调用父类中的构造方法，普通方法和属性；与this调用构造方法的要求一样，语句必须放在子类构造方法的首行。
this与super的区别：
this属性访问：访问本类中的属性，如果本类中没有此属性，则从父类中继续查找；方法：访问本类中的属性，如果本类中没有此方法，则从父类中继续查找；调用构造：调用本类构造，必须放在构造方法的首行；特殊：表示当前对象。
super属性访问：访问父类中的属性；方法：直接访问父类中的方法；调用构造：调用父类构造，必须放在子类构造方法的首行。
（4）final关键字：
可以使用final关键字声明类，属性，方法。
注意：不能有子类；不能被子类覆写；声明的变量即成为常量，不可以修改。
（5）抽象类：格式如下所示
abstract 抽象类名称{
属性；
访问权限 返回值类型 方法名称（参数）{
return 返回值；
}
访问权限 abstract 返回值类型 方法名称（参数）；
//在抽象方法中没有方法体
}
包含一个抽象方法的类必须是抽象类；抽象类和抽象方法都要使用abstract关键字声明；抽象方法只需声明不需要实现；抽象类必须要被子继承，子类必须要覆写抽象类中的全部抽象方法。
注：抽象方法不要使用private声明。因为抽象方法必须被子类覆写。
（6）接口：定义格式如下
interface 接口名称{
全局常量；
抽象方法；
}
注：接口中的方法永远是public访问权限。
实现接口：
class 子类 implements 接口A{
}
继承抽象类实现接口：
class 子类 extends 抽象类 implements 接口A{
}
（7）对象的多态性：
向上转型：子类对象——>父类对象；
向下转型：父类对象——>子类对象。
对象转型：
对象向上转型：父类 父类对象 =子类实例；
对象向下转型：子类 子类对象=（子类）父类实例；
对象向下转型的要求：在进行对象的向下转型前，必须先发生对象的向上转型，否则将出现对象转换异常。
（8）instanceof关键字：格式如下所示
对象 instanceof 类 ——>返回Boolean类型
使用instanceof关键字来判断一个对象到底是哪个类的实例。
（9）抽象类和接口的关系：
抽象类定义：包含一个抽象方法的类；组成：构造方法，抽象方法，普通方法，常量变量；使用：子类继承抽象类；关系：抽象类可以实现多个接口；有单继承的局限；
接口定义：抽象方法和全局变量的集合；组成：常量，抽象方法；使用：子类实现接口；关系：接口不能继承抽象类，但允许继承多个接口。
（10）object类
Java中所有的类都有一个公共的父类object，一个类只要没有明显的继承一个类，则是object类的子类。
以下程序实现相同：
class Person extends Object{}
class Person{}
暂时总结这些，需要多看书，熟记知识点，程序多看，多写，记住易错点。
（二）实验总结
本次实验包括实验四和实验五两次的内容：
4-1：银行新用户现金业务办理；
基本思路：定义Bank类，输入属性；使用静态方法welcome（）方法，借助输出语句将“欢迎来到建设银行”及基本操作“1.开户；2.存款；3.取款；4.退出；请选择您需要的服务选项”。然后通过构造方法实现。
个人需要注意的点：是在Public class Yinhang 中的方法使用语句，调用。
4-2：基本思路：定义员工类，具有姓名、年龄、性别属性，并具有构造方法和显示数据方法。定义管理层类，继承员工类，有自己的属性职务和年薪。定义职员类，继承员工类，并有自己的属性所属部门和月薪。定义一个测试类，进行测试。
个人需注意的点：在员工类中属性的声明及get()set()方法的实现；抽象方法输入信息；实现继承。
4-3（1）设计一个平面图形抽象类(提供求该类对象周长和面积的方法）和一个立体图形抽象类（提供求该类对象表面积和体积的方法）
（2）设计球类、圆柱类，圆锥类、矩形类、三角形类、圆类，分别继承平面图形抽象类和立体图形抽象类。
（3）设计一个测试类，随机产生球，圆柱、圆锥体、矩形、三角形、圆的尺寸，模拟考试，要求用户回答它们的体积和表面积（或者周长和面积），并判断用户的回答是否正确。
该程序需完善，
4-4动物园饲养问题；
基本思路：分别定义声明Lion，Monkey，Pigeon，Feeder类，实现无参有参方法；定义eat()方法实现；在Animal类中实例化。
注意：读懂题目，将思路放清，一步步解析，会比较有时效。
5-1宠物商店；
基本思路：在Pet类中，实现接口，声明宠物基本属性信息；创建Cat类和Dog类，并完成get()，set()方法；在Shop类中实现以下功能，然后测试（1）展示所有宠物；（2）购买宠物；（3）展示购买清单：显示购买的宠物品种，数量，价格合计及购买宠物的总价钱。
写的时候，可能单个类写的话会比较好写，如Cat类和Dog类，所有要求实现即可；在shop类和测试类中可能会存在一些问题，需改善。
5-2设计一个动物声音“模拟器”
设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声。
基本操作：（1）接口Animal：有2个抽象方法cry()和getAnimaName()，要求实现该接口的各种具体动物类给出自己的叫声和种类名称；（2）模拟器类Simulator：有一个playSound(Animal animal)方法。即参数animal可以调用实现Animal接口类重写的cry()方法播放具体动物的声音、调用重写的getAnimalName()方法显示动物种类的名称；（3）实现Animal接口的Dog类和Cat类；（4）测试类：main方法中至少包含如下代码：
Simulator simulator = new Simulator();
simulator.playSound(new Dog());
simulator.playSound(new Cat());
第五次实验第三题暂时没有完成，需要时间整理思路再写，可能会以后再补上，能力有限。
实验总结：这次实验作业整体都看了，并基本完成了写代码任务。实验四的四道题，都清楚，4-3暂时存在些小问题，待改善。4-1银行账户，4-2员工类，4-4动物园饲养问题，5-1宠物商店，5-2模拟器，其实读出要求，就基本差不多了，然后就建类，声明属性，接口实现，继承问题，构造方法等等。需要多写代码，多写代码。第三次作业，端正态度，好好做，会有所提高的。
（三）代码托管
https://gitee.com/hebau_java_cs16/bestiisjava201803.git
