java中北大学ppt总结+课后习题第四章（小宇特详解）

继承

子类与父类

继承是根据现有类创建新的类的机制，由继承而得到的新类称为子类（subclass）或派生类（derived class），被继承的类称为父类、超类(superclass)或基类（base class）。

子类可以从父类继承属性和方法。
子类比起父类成员更加丰富：
成员变量增加（扩展）。
处理成员变量的成员方法增加（扩展）。

在UML类图中，泛化关系就是用来描述继承的。

类的继承语法

类继承的语法机制

 class   父类名{//成员变量//成员方法}

class   子类名 extends 父类名{//扩展的成员变量//构造方法//扩展的成员方法}

子类的描述方法解决了：
1、描述不重复。
2、体现父子关系。

在子类中可以访问父类中的成员（变量和方法）。

class   ClsSuper{public int m_a = 20;public void show(){System.out.printf("m_a=%d\n", m_a);}
}

class   ClsSub extends ClsSuper{public int m_b = 30;public void  print(int a){//使用父类成员像自己的成员一样System.out.printf("m_a=%d,m_b=%d,参数=%d\n",m_a, m_b, a);  }
}

在其他类中，也可以通过子类对象访问父类中的成员，就像访问子类中的成员一样。

ClsSub objsub=new ClsSub();
System.out.println(objsub.m_a);//子类对象访问父类的成员变量
System.out.println(objsub.m_b);
objsub.show();
//子类对象访问父类的成员方法
objsub.print(999);

（1）继承是用来为“is-a”（是一种）关系建模的，不要仅仅为了重用代码而盲目地继承一个类，必须保证子类和它的父类之间存在“is-a”关系。
（2）在Java中不允许多重继承。一个Java类只能直接继承自一个父类。这种限制称为单一继承。
（3）通过继承机制，我们可以把多个类组成一个层次结构的系统（类等级）。在类等级中，继承具有传递性。

（4）关于子类的继承性
焦点：子类是否继承其父类的private成员？
观点一：子类不继承父类的private成员
如果子类和父类在同一个包中，则子类自然地继承了其父类中不是private修饰的成员, 继承的成员的访问权限保持不变。
如果子类和父类不在同一个包中，则子类继承了父类的不是private修饰或缺省修饰的成员, 继承的成员的访问权限保持不变。

子类继承其父类中所有可访问的成员。

关于子类的继承性
焦点：子类是否继承其父类的private成员？
观点二：子类继承其父类的所有成员
子类继承（拥有）了父类的所有属性和方法。只不过父类的私有属性和方法，子类是无法直接访问的。
私有属性可以通过public修饰的getter和setter方法访问到，但是私有方法不行。
大家可以这样理解：

子类不能从父类继承私有成员，但是子类的对象内存中确实包括了子类所不能从父类中继承的私有成员。

（5）访问限制修饰符：protected
protected是专门针对父子继承关系而提供的一种访问限制修饰符。
protected修饰的成员，在包外，只能由子类访问。

子类对象的构造过程

子类能继承父类的构造方法吗？子类能够调用父类的构造方法吗？
构造方法用于构建一个类的实例。不同于属性和普通方法，父类的构造方法不会被子类继承；
使用关键字super从子类构造方法中调用父类构造方法。

super();   // 调用父类的无参构造方法super(实参列表); // 调用父类中与实参列表匹配的有参构造方法

语句super()或super(实参列表)必须出现在子类构造方法的第一行，这是显式调用父类构造方法的唯一方式。

 class   ClsSuper {private int a = 20;public ClsSuper() {}public ClsSuper(int a){this.a = a;}  }
class   ClsSub extends ClsSuper {private int b = 30;public ClsSub(int a, int b) {super(a); //调用ClsSuper(int a) super必须在构造器的第一行。this.b = b;}public ClsSub(int b) { //调用ClsSuper()构造器，a=20//调用缺省构造器this.b = b;}
}

在任何情况下，构造一个类的实例时，将会调用沿着继承链的所有祖先类的构造方法。
当构造一个子类的对象时，子类的构造方法会在完成自己的任务之前，首先调用它的父类的构造方法。如果父类继承自其他类，那么父类的构造方法又会在完成自己的任务之前，调用它自己的父类的构造方法。…
这个过程一直持续到沿着这个继承层次结构的最后一个构造方法被调用为止。这就是构造方法链。

构造方法链代码演示 StudentLeader.java

建议：最好能为每个类提供一个无参构造方法。

结论：
子类与父类的成员变量都是由自己的构造器完成初始化。父类的构造器不能初始化子类成员变量，子类构造器不能初始化父类成员变量。
子类对象实例化的时候，首先判定是否有父类，没有父类就直接执行自己的构造器代码完成对成员变量的初始化。
如果有父类，则先调用父类构造器（默认调用父类的缺省构造器，但也可以指定调用有参构造器）完成父类成员变量的初始化，然后再执行子类构造器代码来完成子类成员变量的初始化。

super关键字

super指代父类，即这个关键字所在类的父类。
除了可调用父类构造器外，还可作为作用域使用：
当父类成员与子类成员发生命名冲突的时候，使用[super.成员]可以标识父类中成员，不加super前缀或者加this前缀表示是当前类成员。
当父类、子类成员不冲突的时候，不需要super前缀。
注意：
super用于调用父类构造器时，必须放在子类构造器的第一行。
super作为作用域使用，可以在构造器，也可以在成员方法内使用，可以放在任意行。

final关键字

final关键字可以修饰类、成员变量或成员方法。
final修饰的类：不能被继承，即不能有子类。

final  class   ClsSuper{ //class ClsSuper不能再被继承public void show() {}}

final修饰的成员变量：常量，只能赋值一次。
final修饰的成员方法：不能被子类重写。

例一

完成所描述的三个类，要求写出三个类及测试类的代码，最终在控制台输出下面的信息：

我叫张三，我今年18岁

我努力学习我的专业；软件工程

我叫黎民，我今年34岁

我是一名副教授，我在用心教书育人

public class Person {private String name;
private int age;
public Person(String name, int age) {this.name = name;
this.age = age;
}
public void speak() {System.out.println("我叫"+ name +",今年" + age + "岁；");
}
}
public class Student extends Person {private String major;
public Student(String name,int age,String major) {super(name,age);
this.major = major;
}
public void study() {System.out.println("我努力学习我的专业：" + major + ";");
}
public void speak() {super.speak();
study();
}
}
public class Teacher extends Person{private String positionalTitle;
public Teacher(String name,int age,String positionalTitle) {super(name,age);
this.positionalTitle = positionalTitle;
}
public void teach() {System.out.println("我是一名" + positionalTitle + "，我在用心教书育人;");
}
public void speak() {super.speak();
teach();
}
}
public class TestExtends {public static void main(String[] args) {Student s = new Student("张三",18,"软件工程");s.speak();Teacher t = new Teacher("黎民",34,"副教授");t.speak();
}
}

对象的上转型对象

设有父类ClsSuper,子类CLsSub，
试判断如下几条语句的合法性及操作含义：
ClsSuper sup = new ClsSuper();

ClsSub sub = new ClsSub();

ClsSuper sup = new ClsSub();

ClsSub sub = new ClsSuper();

当对象的声明类型和实际类型一致时，可以直接赋值，不需要类型转换。
当对象的声明类型和实际类型不一致时，分为两种情形：

子类对象肯定是父类类型。因此Java允许把子类类型的对象赋值给父类类型的变量，这种情形称为对象的向上转型（自动完成）。

父类对象不一定是子类类型。因此Java不允许把父类对象赋值给子类变量，这种情形称为对象的向下转型（在特定条件下可进行强制类型转换）。

ClsSuper sup=new ClsSuper();    ClsSub sub=new ClsSub();    // 对象的声明类型与实际类型一致ClsSuper sup1 = new ClsSub();// 将子类对象赋值给父类对象，合法！对象的上转型// 对象的声明类型是实际类型的父类型！sup = sub;  // 含义同上，合法！对象的上转型ClsSub sub1 = new ClsSuper();// 将父类对象赋值给子类对象，非法！对象的下转型// 对象的声明类型是实际类型的子类型！sub1 = sup;  // 含义同上，非法！对象的下转型ClsSuper sup1 = new ClsSub();ClsSub sub1 = sup1;    // 非法！ClsSub sub1 = (ClsSub)sup1;// 在确认父类对象的实际类型为子类类型时，可以通// 过类型强制转换，赋值给子类对象。对象的下转型// 但一般的使用格式如下：if(sup1  instanceof  ClsSub){ClsSub sub1 = (ClsSub)sup1;}

假设A类是B类的父类，当用子类创建一个对象，并把这个对象的引用放到父类的对象中，例如：

A a;
a = new B();
或者
A a;
B b = new B();
a = b;

称对象a是对象b的上转型对象。
上转型对象相当于子类对象的一个简化对象

覆盖与多态

方法覆盖（或重写）
子类可以继承并直接调用父类的成员方法。
根据需要，子类也可以重写父类的某个方法，称为方法覆盖或重写（method overriding）。

重写的方法必须与被重写的方法具有相同的签名，以及相同或兼容的返回类型（即重写方法的返回类型可以时被重写方法返回类型的子类型）。

@Override：注解，用于对重写方法的签名及返回类型进行语法检测，防止因拼写错误而导致没有重写。
为了防止方法被重写，可以使用修饰符final。

 class   ClsSuper{public void show(){…}}
重写后class   ClsSub extends ClsSuper{@Overridepublic void show(){  // 重写…//再确认该类中方法的实现，并调用}
}ClsSuper objsuper = new ClsSub();objsuper.show();  //先确定对象的实际类型

绑定(binding):将一个方法的调用与方法所在的类（方法主体）关联起来。
静态绑定(static binding):程序编译期间通过方法的签名匹配完成绑定。
动态绑定(dynamic binding):程序运行时根据对象的实际类型进行绑定，与对象的声明类型无关！

动态绑定工作机制如下：假设有类C1、C2、, 、Cn构成的类等级，其中：C1是C2的子类，C2是C3的子类，…,Cn-1是Cn的子类。也就是说，Cn是最通用的类，在Java中就是Object类（根父类），C1是最特殊的类。假设对象obj是类C1的实例，则它同时也是C2、, 、Cn的实例。如果对象obj调用一个方法p，那么JVM会依次在C1、C2、,、Cn中查找方法p的实现，直到找到为止。一旦找到一个实现，就停止查找，然后调用这个首先找到的实现。

class   ClsSuper{public void show(){…}public void print(){...}
}
class   ClsSub extends ClsSuper{@Overridepublic void show(){  // 重写…}public void print(String s){...}
}

方法重写(method overriding):发生在具有继承关系的不同类中，是指在子类中提供了一个对父类中某个方法的新的实现，重写的方法必须与被重写的方法具有相同的签名，以及相同或兼容的返回类型。
方法重载(method overloading):通常发生在同一个类中，是指使用相同的名字但是不同的签名来定义多个方法；这种情况也可以发生在具有继承关系的不同类中。重载的方法必须具有相同的名字但具有不同的参数列表（即不同的签名）。

程序的多态性
多态：polymorphism, 源于希腊文字，意思是多种形式）。
多态是OOP的四个基本特征之一。

多态的含义：通过子类对象的上转型对象和方法重写，可以调用不同子类重写的方法，从而体现不同的行为或功能。
多态的好处：使程序具有稳定结构，易扩展、易维护。

class   ClsSuper {public void show(){  } // 空实现}class ClsSub1 extends ClsSuper{public void show(){// 实现1}
}class ClsSub2 extends ClsSuper{public void show(){// 实现2}
}class   MainClass {public static void main(String[] args){ClsSuper obj = new ClsSub1();   // 对象obj的声明类型ClsSuper，实际类型ClsSub1obj.show();obj = new ClsSub2();obj.show();      }
}class   MainClass {public static void main(String[] args){ClsSuper obj = new ClsSub1();   call( obj );  //call内部的调用因对象不同而不同。}                     //多态：一个方法多种实现。public  static void call( ClsSuper obj ){obj.show();         }
}

例二

利用多态的知识来写

我叫张三，我今年18岁

我努力学习我的专业；软件工程

我叫黎民，我今年34岁

我是一名副教授，我在用心教书育人

public class TestPolymorphism {public static void main(String[] args) {//将学生对象向上转型Person p = new Student("张三",18,"软件工程");p.speak();//将教师对象向上转型p = new Teacher("黎民",34,"副教授");p.speak();
}
}

Object类

Java类层次结构中的根父类，所有类都默认继承自Object类。

class   ClsSuper {public void show(){   …    }}ClsSuper obj = new ClsSuper(); obj.show();System.out.println(obj.toString());

Object类
提供一个缺省构造器（Java编译器为Object类自动添加的）。
提供一组基本方法。

Object类提供的方法

protected Object clone()     //克隆
boolean equals(Object obj)  //相等判定
protected void finalize()   //析构回调
Class<?> getClass()   //返回运行时类型
int hashCode()      //返回对象的hash码
void notify()   //唤醒当前对象监视的等待线程
void notifyAll() //唤醒当前对象监视的所有的等待线程
String toString()       //把对象转换为字符串，println打印对象会自动调用
void wait()         //让当前线程等待
void wait(long timeout) //让当前线程等待timeout毫秒
void wait(long timeout, int nanos) //让当前线程等待timeout毫秒+纳秒

equals方法的继承与重写

对象相等的判定
使用只能判定两个对象是否使用同一空间，即判断两个对象是否为同一个对象，而无法判定两个不同对象的内容是否相等。
为此，Object类提供了equals方法，可以用来判定两个对象的内容是否相等。但是要注意：
equals方法默认判定的是两个对象的空间地址相等（即与的功能一样）。
为了判定两个对象的内容是否相等，继承者必须重写equals方法，在重写的方法中实现定制的相等判定规则。

class   ClsSuper{private  int score = 20;boolean equals( Object obj ) {if( obj  instanceof  ClsSuper ) {ClsSuper  o = (ClsSuper) obj;                                                                                                                                                       if(o.score == this.score) {return true; //对象的分数相等，则对象等 } else{return false; //对象的分数不等，则对象不等。}} else{return false;  //类型不同，直接返回不等}}
}

toString方法的继承与重写

在Object类中，toString方法默认返回对象的类型与地址。
格式：类名@16进制地址

一个类要想按照自己定义的某种格式输出对象的信息，则需要继承并重写Object类的toString方法。

例三

每个人都有身份证号和姓名等属性，如果身份证号相等，则一定是同一个人。
（1）请重写equals 方法判断两个对象是否相等；
（2）请重写toString方法，返回的字符串的格式为：身份证号：，姓名。

public class Person {private String id;
private String name;
public Person(String id, String name) {this.id = id;
this.name = name;
}
@Override
public String toString() {return "姓名：" + name + ";身份证号：" + id;
}
@Override
public boolean equals(Object obj) {if(obj  instanceof  Person){Person  p=(Person)obj;if(p.id.equals(this.id)){return true; //身份证号相等，则对象等。} else {return false; //身份证号不等，则对象不等。}
} else {return false;//类型不同，直接返回不等
}
}
}
测试对象是否相等
public class TestEquals {public static void main(String[] args) {Person p1 = new Person("140108198006230421", "张三");
Person p2 = new Person("140108198006230421","张三");
System.out.println(p1.toString());// 或写成：System.out.println(p1);
System.out.println(p2.toString());// 或写成：System.out.println(p2);
System.out.println(p1 == p2);
System.out.println(p1.equals(p2));
}
}

继承设计与应用

类的层次结构设计

类的继承结构可以呈现非常好的结构层次。
类的继承层次结构设计可以从如下几个角度设计：
抽象（设计父类）
从已有多个类对共性（成员变量/成员方法）抽取出父类，形成继承结构。
从一个类，把不变部分抽取出父类，形成继承结构。
对设计中涉及到通用编程的地方，考虑抽取父类，形成继承结构。
扩展（设计子类）
设计结构稳定后，新增加的设计类，如果存在明确的继承关系，尽量从已有类继承设计。
对有父子关系的类，尽量从父类扩展出不同使用情况的子类。
尽量利用JDK的类作为父类来设计新的类。

谨慎使用继承

子类和父类的关系是强耦合关系，也就是说，当父类方法的行为更改时，必然导致子类发生变化。
继承要慎用，其使用场合仅限于你确信使用该技术有效的情况。一个判断方法是，问一问自己是否需要从新类向基类进行向上转型。如果是必须的，则继承是必要的。反之则应该好好考虑是否需要继承

小结

1、继承是一种由已有的类创建新类的机制。利用继承，我们可以先创建一个共有属性的一般类，根据该一般类再创建具有特殊属性的新类。
2、所谓子类继承父类的成员变量作为自己的一个成员变量，就好像它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法操作。
3、所谓子类继承父类的方法作为子类中的一个方法，就像它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法调用。
4、多态是面向对象编程的又一重要特性。子类可以体现多态，即子类可以根据各自的需要重写父类的某个方法，子类通过方法的重写可以把父类的状态和行为改变为自身的状态和行为。

回顾

为什么要引入继承机制

Person类，Student类，Teacher类（代码有重复）
依据常识，Student类和Teacher类都是特殊的Person类，应该在语法上明确体现这种关系，而且在对Student类和Teacher类的描述中要避免重复Person类中已经描述过的内容。
继承就是这样一种机制。

1、子类与父类
利用继承，我们可以由已有的类创建新的类，即先创建一个共有属性的一般类，然后根据一般类再创建具有特殊属性的新类。
术语：子类、派生类；父类、基类、超类。
子类是对父类的继承和扩展。
子类继承了父类的属性和方法；
子类增加了自己的属性和方法，比父类的成员更为丰富。

继承语法

class   父类{//成员变量//成员方法}

class   子类 extends 父类{//扩展的成员变量//构造方法//扩展的成员方法}

说明：
（1）使用关键字extends体现父子关系，子类的描述内容不再有重复；
（2）在子类中可以直接使用父类中的成员变量，就好像它们是在子类中直接声明一样；
（3）在子类中也可以直接调用父类中的成员方法，就好像它们是在子类中直接声明一样；
（4）通过创建子类对象，可以从其他类中访问父类的成员变量和成员方法；
（5）是否可访问，还要受被访问成员的修饰符的控制。

访问权限修饰符

其中：protected是专门针对父子继承关系而提供的一种访问权限修饰符。

继承
子类的继承性（续）
子类和父类在同一个包中的继承性
子类自然地继承了其父类中的protected、public、缺省修饰成员（即非private的成员）作为自己的成员, 而且所继承的成员的访问权限保持不变。
子类和父类不在同一个包中的继承性
子类自然地继承了其父类中的protected、public成员作为自己的成员, 而且所继承的成员的访问权限保持不变
4.子类对象的构造过程
使用new运算符调用子类的构造方法来创建子类对象。
为子类对象分配内存（堆内存）；
对成员变量进行初始化（包括从父类继承的成员变量和子类自己新增的成员变量两部分）。
在子类的构造方法中：
首先调用父类的构造方法（使用super关键字）来初始化继承的那部分成员变量；
然后再初始化子类自己新增的那部分成员变量。

注意：子类与父类的成员变量都是由自己的构造方法完成初始化。

super关键字
作用一：作为构造器使用。
在子类的构造方法中，可以使用super关键字去调用父类的构造方法（无參或有参），必须处于第一行；
作用二：作为作用域使用。
当父类成员与子类成员发生命名冲突的时候，使用super关键字来标识父类中的成员，语法格式为：
super.成员
如果不加super前缀或者加this前缀表示是当前子类中的成员。
可以用在构造方法或成员方法中，而且可以放在任意行

final关键字
可以用于修饰：类、成员变量、成员方法。
如果一个类使用final修饰，则该类不能被继承（即不能有子类）；
如果一个成员变量使用final修饰，则该成员就是一个常量，只能被赋值一次，之后不能修改；
如果一个成员方法使用final修饰，则该方法不能被子类重写。

多态

操作名称的多态，通过方法重载体现。多个方法具有相同的名字，但参数必须不同，因此产生不同的行为。
与继承有关的多态：
如果在父类中声明某个方法，该方法被子类重写，那么通过子类对象的上转型对象调用该方法时，实际调用的是被子类重写的方法。
不同的子类对于父类中的方法，可以有不同的重写，从而产生不同的行为。

对象的上转型对象
可以把子类类型的对象赋值给父类类型的对象（称为子类对象的上转型对象）；
不能把父类对象赋值给子类对象。
但是，在确认父类对象的实际类型为子类类型时，可以通过类型强制转换，将父类对象（其实是子类对象的上转型对象）赋值给子类对象。也就是说：之前发生过上转型时，可以强制下转型。
上转型对象相当于子类对象的一个简化对象。

覆盖与多态
覆盖（Override）: 是指子类对父类中某个方法的重写；
Java语法规定：不管对象是什么类型，通过该对象调用的方法一定是new运算符后构造器所在类的方法，与对象的声明或表现类型无关！
覆盖（或重写）机制的好处：
使程序具有多态性：
如果在父类中声明某个方法，该方法被子类重写，那么通过子类对象的上转型对象调用该方法时，实际调用的是被子类重写的方法。
不同的子类对于父类中的方法，可以有不同的重写，从而产生不同的行为。
使程序的结构更为稳定，程序更容易扩展、维护。

课后习题

选择题

下列哪个代码（A，B，C，D）放入程序中标注的【代码】处将导致编译错误？

class A {

public float getNum() {

return 3.0f; } }

public class B extends A {

【代码】

}

A. public float getNum(){return 4.0f;}
B. public void getNum(){ }
C. public void getNum(double d){ }
D. public double getNum(float d){return 4.0d;}

正确答案: B

方法重写要求方法名，返回值类型，参数完全相同，所以A符合，B返回值类型不同，编译错误。而C和D不仅返回值类型不同，参数也不同，不属于方法重写，而是属于子类自己新增的方法。所以选B

假设C是B的子类，B是A的子类，cat是C类的一个对象，bird是B类的一个对象，下列哪个叙述是错误的？

A. cat instanceof B的值是true。
B. bird instanceof A的值是true。
C. cat instanceof A的值是true。
D. bird instanceof C的值是true。

正确答案: D

instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或其子类所创建对象时，返回true；否则，返回false。

A cat是右边B的子类C的一个对象

B bird是右边A的子类B的一个对象

C cat是右边A的子类B的子类C的一个对象

D bird是右边B的一个对象或者是A的子类B的一个对象

填空题

给出【代码】注释标注的代码的输出结果：class A {int f(int x,int y) {return x+y;}}class B extends A {int f(int x,int y) {int m = super.f(x,y)+10;return m;}}public class E {public static void main(String args[]) {A a = new B();System.out.println(a.f(2,10));   //【代码】}}
正确答案：
(1) 22这里是先创建了一个父类，成员方法是x+y，然后又创建了一个子类，调用了父类的构造方法然后又—+10接下来写了个测试类，要输入f（2,10）这里就是2+10+10=22

给出【代码】注释标注的代码的输出结果：class Animal {int m = 100;public int seeM(){return m;}public int getM(){return m;}}class Dog extends Animal{int m = 6;public int seeM(){return  m;}}public class E {public static void main(String args[]){Animal animal = null;Dog dog = new Dog();animal = dog; System.out.printf("%d:%d:%d",dog.seeM(),animal.seeM(),animal.getM()); //【代码】}}
正确答案：
(1) 6:6:100
这里进行了子类构造方法的重写，这里改变了成员变量m的值，将dog的值赋值给了animal，所以这里前两个是6，6但是这里的getM方法没有被改变，还是100

下面是一个有关几何图形类的程序，请补充完整___________________________________________；（1）public class Geometric {private String color;private boolean filled;private Date date;public Geometric() {date = new Date();}public Geometric(String color, boolean filled) {this.color = color;this.filled = filled;_________________________;  （2） //获取系统时间}public void setColor(String color) {this.color = color;}public String getColor() {return color;}public void setFilled(boolean filled) {this.filled = filled;}_____________________________{  （3） //获取是否填充的方法return filled;}public Date getDate() {return date;}public String toString() {return "颜色：" + color + "，是否填充：" + filled + "，创建时间：" + date ;}public double getArea() {return 0;}}//圆类继承图形类public class Circle ________________ （4）{ private double radius;public Circle() {}public Circle(double radius, String color, boolean filled) {_______________________________;  （5）this.radius = radius;}public double getRadius() {return radius;}public void setRadius(double radius) {this.radius = radius;}public double getArea() {return radius*radius*Math.PI;}public double getPerimeter() {return 2*radius*Math.PI;}public double getDiameter() {return 2*radius;}@_______________________（6）//判断是否是方法的重写public String toString() {return "圆形：【半径为：" + radius + "，颜色为：" + getColor() + "，是否填充" + isFilled() + "，创建时间：" + getDate();} }//长方形类继承图形类public class Rectangle ____________________ { （7）private double length;private double width;public Rectangle() {_________________________;  （8）//调用父类构造方法}public Rectangle(String color, boolean filled, double length, double width) {super(color,filled);this.length = length;this.width = width;}public double getLength() {return length;}public void setLength(double length) {this.length = length;}public double getWidth() {return width;}public void setWidth(double width) {this.width = width;}public double getArea() {___________________________;  （9）}public double getPerimeter() {return 2*（length+width）;}@Overridepublic String toString() {return "长方形【长：" + length + " 宽：" + width + super.toString() + "】";}}//测试类public class Test {public static void main(String[] args) {Geometric g = ________________________; //（10）利用上转型使父类对象指向圆类对象，使用无参构造g = _________________________;//（11）利用上转型使父类对象指向长方形对象，使用无参构造Rectangle re;if (g _______________________) {  //（12）判断g是否属于长方形类re = _____________________;    //（13）对象下转型}else {System.out.println("类型不匹配");} }}正确答案：
(1) import java.util.Date
(2) date = new Date()
(3) public boolean isFilled()
(4) extends Geometric
(5) super(color, filled)
(6) Override
(7) extends Geometric
(8) super()
(9) return length*width
(10) new Circle()
(11) new Rectangle(）
(12) instanceof Rectangle
(13) (Rectangle)g

判断题

子类继承父类的构造方法。

A. 对
B. 错

正确答案: 错

答案解析：

子类有子类的构造方法，父类有父类的构造方法，子类是不会继承父类的构造函数的，只是必须调用

子类中想使用被子类隐藏的实例成员变量或实例方法就需要使用关键字super。

A. 对
B. 错

正确答案: 对

答案解析：

根据就近原则，子类调用同名成员的时候默认会调用自己的，如果想要调用父类的成员需要用关键字super

可以用final修饰构造方法。

A. 对
B. 错

正确答案: 错

如果在子类的构造方法中，没有显示地写出super关键字来调用父类的某个构造方法，那么编译器默认地有：super();调用父类的无参数的构造方法，如果父类没有这样的构造方法，代码将出现编译错误。

A. 对
B. 错

正确答案: 对

子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量。

A. 对
B. 错

正确答案: 对

如果一个类的所有构造方法的访问权限都是private的，意味着这个类不能有子类，理由是：一个类的private方法不能在其他类中被使用，但子类的构造方法中一定会调用父类的某个构造方法）。

A. 对
B. 错

正确答案: 对

子类在方法重写时，不可以把父类的实例方法重写为类（static）方法，也不可以把父类的类（static）方法重写为实例方法。

A. 对
B. 错

正确答案: 对
= _____________________; //（13）对象下转型

}else {

System.out.println(“类型不匹配”);

}

正确答案：
(1) import java.util.Date
(2) date = new Date()
(3) public boolean isFilled()
(4) extends Geometric
(5) super(color, filled)
(6) Override
(7) extends Geometric
(8) super()
(9) return length*width
(10) new Circle()
(11) new Rectangle(）
(12) instanceof Rectangle
(13) (Rectangle)g


### 判断题子类继承父类的构造方法。- A. 对
- B. 错*正确答案:* 错*答案解析：*子类有子类的构造方法，父类有父类的构造方法，子类是不会继承父类的构造函数的，只是必须调用子类中想使用被子类隐藏的实例成员变量或实例方法就需要使用关键字super。- A. 对
- B. 错*正确答案:* 对*答案解析：*根据就近原则，子类调用同名成员的时候默认会调用自己的，如果想要调用父类的成员需要用关键字super可以用final修饰构造方法。- A. 对
- B. 错*正确答案:* 错如果在子类的构造方法中，没有显示地写出super关键字来调用父类的某个构造方法，那么编译器默认地有：super();调用父类的无参数的构造方法，如果父类没有这样的构造方法，代码将出现编译错误。- A. 对
- B. 错*正确答案:* 对子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量。- A. 对
- B. 错*正确答案:* 对如果一个类的所有构造方法的访问权限都是private的，意味着这个类不能有子类，理由是：一个类的private方法不能在其他类中被使用，但子类的构造方法中一定会调用父类的某个构造方法）。- A. 对
- B. 错*正确答案:* 对子类在方法重写时，不可以把父类的实例方法重写为类（static）方法，也不可以把父类的类（static）方法重写为实例方法。- A. 对
- B. 错*正确答案:* 对