类与类之间的三种关系
类与类之间有三种关系
is a:继承关系，例如：公共汽车is a汽车
use a:使用关系，例如：人 use a 钳子
has a：包含关系，例如：人has a 胳膊
继承的好处
- 继承的出现提高了代码的复用性，提高软件开发的效率
- 继承的出现让类与类之间产生了关系，提供了多态的前提
继承的定义格式
在程序中，如果想申明一个类继承另一个类，需要使用extends关键字
class 子类 extends 父类 {
}
使用继承
案例：公司有2个部门，人事部和研发部，各自属性如下
定义人事部类
public class PersonalDepartment {
private int ID;// 部门编号
private String name = "待定";// 部门名称
private int amount = 0;// 部门人数
private String responsibility = "待定";// 部门职责
private String manager = "无名氏";// 部门经理
private int count;//招聘人数
public PersonalDepartment() {
}
public PersonalDepartment(int ID, String name, int amount, String responsibility, String manager, int count) {
this.ID = ID;
this.name = name;
this.amount = amount;
this.responsibility = responsibility;
this.manager = manager;
this.count = count;
}
定义研发部
/**
* 研发部
*/
public class ResourceDepartment {
private int ID;// 部门编号
private String name = "待定";// 部门名称
private int amount = 0;// 部门人数
private String responsibility = "待定";// 部门职责
private String manager = "无名氏";// 部门经理
private String speciality =null;//研发方向
public ResourceDepartment() {
}
public ResourceDepartment(int ID, String name, int amount, String responsibility, String manager, String speciality) {
this.ID = ID;
this.name = name;
this.amount = amount;
this.responsibility = responsibility;
this.manager = manager;
this.speciality = speciality;
}
......
问题：两个类中的属性有相同的部分，代码冗余。解决办法是将两个部门共性的属性抽取出来，放在父类中，然后让两个部门继承父类。
定义父类:两个部门共性的属性抽取到父类中
/** 部门父类：存放所有子类共性的内容 */public class Deparment { private int ID;// 部门编号 private String name = "待定";// 部门名称 private int amount = 0;// 部门人数 private String responsibility = "待定";// 部门职责 private String manager = "无名氏";// 部门经理
子类修改如下：
- 共性的属性删除
- 共性属性的get和set方法删除
- 构造方法做调整
/**
* 人事部
*/
public class PersonalDepartment {
private int count;//招聘人数
public PersonalDepartment() {
}
public PersonalDepartment(int count) {
this.count = count;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
/**
* 研发部
*/
public class ResourceDepartment {
private String speciality =null;//研发方向
public ResourceDepartment() {
}
public ResourceDepartment(String speciality) {
this.speciality = speciality;
}
public String getSpeciality() {
return speciality;
}
public void setSpeciality(String speciality) {
this.speciality = speciality;
}
}
让人事部和研发部继承部门的父类
- 使用extends Deparment继承部门类
- 人事部
public class PersonalDepartment extends Deparment{
private int count;//招聘人数
public PersonalDepartment() {
}
public PersonalDepartment(int count) {
this.count = count;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
* 使用extends Deparment继承部门类
/**
* 研发部
*/
public class ResourceDepartment extends Deparment{
private String speciality =null;//研发方向
public ResourceDepartment() {
}
public ResourceDepartment(String speciality) {
this.speciality = speciality;
}
public String getSpeciality() {
return speciality;
}
public void setSpeciality(String speciality) {
this.speciality = speciality;
}
}
验证子类是否真的从父类继承了数据
验证方法：
- 创建人事部和研发部的对象，如果能够调用出父类的方法，证明继承了
创建一个公司类，测试一下：
/**
* 公司类
*/
public class Company {
public static void main(String[] args) {
//创建人事部对象
PersonalDepartment personalDepartment = new PersonalDepartment();
//创建研发部对象
ResourceDepartment resourceDepartment = new ResourceDepartment();
//调用父类的方法
System.out.println(personalDepartment.getName()); //getName()是父类的
System.out.println(resourceDepartment.getName()); //getName()是父类的
}
}
如上：
- 实现代码复用
- 父类可以控制子类能继承什么，通过封装控制
注意：对象的属性可以通过方法赋值
创建子类对象时的运行规则
- 第一个方面：构造函数的调用顺序问题
- new子类时，首先调用子类构造函数，但是不执行子类构造函数
- 子类构造函数被调用后立即调用父类的构造函数。
- 第二个方面：属性初始化顺序的问题
- 从Object类开始初始化
- 然后依次从父到子的顺序初始化（哪个类定义的属性，就由哪个类负责初始化）
子类通过关键字super()调用父类的构造函数
- super()必须放在子类构造函数的第一行代码
继承的注意事项
类只支持单继承，不允许多继承
class A{}
class B{}
class C extends A,B{} // C类不可以同时继承A类和B类
多个类可以继承一个父类
class A{}
class B extends A{}
class C extends A{} // 类B和类C都可以继承类A
允许多层继承
class A{}
class B extends A{} // 类B继承类A，类B是类A的子类
class C extends B{} // 类C继承类B，类C是类B的子类，同时也是类A的子类
子类和父类是一种相对概念
也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类。
继承的体系 之 Object类
Object是所有类的父类
如果一个类没有显示定义父类，那么默认继承Object类
Object类中没有定义属性，但是定义了12个方法，并且这些方法都是实例方法。因此每个对象都拥有这14个方法。
继承过程分析(父子类的实例话顺序)
当new子类时，父类也new了
执行：从父到子
调用：从子到父
哪个类定义的属性，就由哪个类赋值初始化，对于父类来说，初始化的数据是由子类通过super(数据)传入给父类的
继承后子类的成员的变化
了解了继承给我们带来的好处，提高了代码的复用性。继承让类与类或者说对象与对象之间产生了关系。那么，当继承出现后，类的成员之间产生了那些变化呢？
子类中的成员包括
- 子类自己定义的属性和方法
- 从父类继承的属性和方法
- 子类不能使用从父类继承的私有成员，因为被封装了。
this和super
继承中的this（调用子类成员）
- this可以调用子类成员
- this可以调用子类重载的构造函数，必须是子类构造函数的第一行
继承中的super（调用父类成员）
- super调用父类成员
- super调用父类构造函数，必须是子类构造函数的第一行
this和super
this代表自己，this可以调用
- 自己的属性和方法
- 在奔类的构造函数内调用其他构造函数
super代表父类，super可以调用
- 父类的属性和方法
- 在子类构造中调用父类构造
this和static
this表示实例
static表示静态
static不能调实例
对象名可以调用static，但是this确不能调用static
方法重写(override)
如果子类从父类继承的方法不能满足子类的需要，或者不适合子类的需要。
此时子类可以将从父类继承的方法重写定义成满足自己需要的方法。
重新定义称为重写。
class Pet {//宠物
public void sound(){
System.out.println("宠物叫");
}
}
class Dog extends Pet {//狗
//方法重写
@Override
public void sound() {
System.out.println("汪汪汪");
}
}
class Cat extends Pet{//猫
//方法重写
@Override
public void sound(){
System.out.println("喵喵喵");
}
}
public class PetShop{//宠物店
public static void main(String[] args) {
Dog dog = new Dog();
dog.sound();//调用狗的sound()
Cat cat = new Cat();
cat.sound();//调用猫的sound()
}
}
注意事项
- 在子类中将父类的方法再重新定义一遍
- 方法重写时，方法的发返回值类型，方法名参数列表都要与父类一样。
*子类方法覆盖父类方法，必须要保证权限大于等于父类权限
class Fu{
void show(){}
public void method(){}
}
class Zi extends Fu{
public void show(){} //扩大show的访问权限，编译运行没问题
void method(){} //缩小method的访问权限，编译错误
}
- 方法重写时，子类不能缩小父类抛出的异常。
class Pet {//宠物
public void sound() throws RuntimeException{
System.out.println("宠物叫");
}
}
class Cat extends Pet{//猫
//方法重写
public void sound() throws Exception{//错误，因为Exception 小于 RuntimeException
System.out.println("喵喵喵");
}
}
方法重载与方法重写的区别
方法重载：
1.在同一类中(包括从父类继承的）方法同名不同参与返回值无关
*方法重写：
1.方法重写存在于继承关系中
2.父子类之间的方法同名，同参，同返回
里氏替换原则(父类引用指向子类实例）
实现：设计宠物类，猫类，狗类，让猫和狗继承宠物类
在宠物类中定义sound方法，表示宠物的叫声，但是叫声不能由具体的行为。
猫和狗重写父类的sound方法，以实现具体的叫声
class Pet {//宠物
public void sound() throws RuntimeException{
}
}
class Dog extends Pet {//狗
//方法重写
@Override
public void sound() {
System.out.println("汪汪汪");
}
}
class Cat extends Pet{//猫
//方法重写
@Override
public void sound() throws RuntimeException{
System.out.println("喵喵喵");
}
}
实现：购买宠物要求宠物叫一声，以此判断是否买它代码如下：
public class PetShop{//宠物店
public static void main(String[] args) {
Pet pet= null
pet=new Dog();
pet.sound();
}
}
"运行结果：汪汪汪"
父类引用pet 赋值时 赋的是子类对象Dog的实例。就是这行代码 pet = new Dog();
我们发现
pet = new Dog();这行代码 = 的右侧 new的是子类的实例，而 = 左侧 是父类的引用。我们把这种情况称为“父类引用指向子类实例”
"父类引用指向子类对象的结论"
父类引用可以代表任何其子类对象，代码表现为
Pet pet = new Dog()或者-
父类引用指向哪个子类对象，调用的方法就是哪个子类中的方法。例如:
Pet pet = new Dog(); pet.sound(); //调用Dog的sound方法 pet = new Cat(); pet.sound(); //调用Cat的sound方法 父类引用指向子类对象其实是增强了父类的功能。
注意：
因为父类引用调用方法时，必须知道子类有哪些方法，知道的才能调用，不知道的是不能调用的。子类Cat新增的climb()方法父类并不知道，但是父类一定知道子类从父类继承的方法。所以父类引用只能调用子类与父类保持继承关系的方法。可以是重写的方法。
子类引用指向父类实例：
public static void main(String[] args) {
pet pet = null;
Dog dog = pet;//报错： 子类引用dog指向父类实例
}
- 当子类指向父类引用时，子类会丢失数据，因此不允许转换。
- 如果非要转，就要强转，认可丢失的数据。Dog dog = (Dog)pet;
里氏替换原则的调用规则：
- 当子类指向父类引用时，子类会丢失数据，因此不允许转换。
- 如果非要转，就要强转，认可丢失的数据。Dog dog = (Dog)pet;
final关键字
实现：
- 类的属性不允许修改
- 类的方法不允许覆盖
- 类不允许继承
