继承的关键字是extends
继承是Java中类与类之间的一种关系
使用继承的好处就是可以用父类封装所有子类的公共代码, 让子类继承, 实现代码复用
发生继承的类称为子类, 被继承的类称为父类
一个类只能继承父类, 但是一个父类可以有多个子类
如果一个类没有显示的继承父类, 则隐式继承Object类
Java不支持多继承, 只支持单继承, 但支持多级继承
在任何一个继承体系的顶层是Object类, Object类称为祖先类, 上帝类
在构造方法中的第一行处有一条隐式指令super()调用其父类的构造方法
this和super的区别
this是指向当前对象, super是指向当前父类对象
this和super的使用语法
1. 调用构造方法 (只能在构造方法中调用, 而且必须出现在第一行)
this();可以使用this()调用本类构造方法
super();可以使用super()调用父类构造方法
2. 访问成员
this.成员变量
super.成员变量
this.成员方法
super.成员方法
子类可以继承父类的非私有(非private修饰)成员
构造方法不存在继承, 但可以被子类调用, 且子类的无参构造方法中会默认调用父类的无参构造方法
能发生继承关系的类在逻辑上应该具有一种 "is a" 的关系 ，eg : 狗(子类) is a 动物(父类)
指针可以指向对象 ,
在没有继承关系之前
前提 : 指针的数据类型与对象的数据类型必须一致
在有了继承关系之后
指针的数据类型与对象的数据类型可以不一致
前提 : 存在继承关系 , 父类类型的指针可以指向子类类型的对象
Object类型的指针可以指向任意一个类型的子类
这种将子类对象赋给父类指针的语法称为"向上转型" , 隐式的(越向上转型 ,不可访问的对象越多,指针的数据类型越抽象)
继承是向上转型的前提
向上转型是多态的前提
向上转型的副作用 : 指针无法访问下级对象中的成员 (除非发生重写)
"向下转型"需要显示的强制转换 , 通常伴随之instanceof做类型判断 , 否则可能会出现类型转换一场
指针向下转型为下级类型 , 就又可以访问下级对象中的成员了
如果使用了向上转型实现了多态指针 , 再用指针操作对象的时候又不想座"向下转型" , 可以使用方法重写来实现
思考 : Animal 类型的指针为什么 不能调用show()方法 , 因为Animal类中没有show() 方法
1. 在父类Animal中添加一个show()方法
2.当子类中出现与父类中的同名方法的时候 , 就存在方法重写的关系
那么此时方使用父类类型指针调用方法的时候 , 如果当前子类中有存在满足重写会自动向下去UI奥用子类重写的方法
abstract 关键字 : 抽象
可以修饰成员方法和类
成员方法被 abstract 修时候 , 称为抽象方法/虚方法 . 没有{} 方法体
类被abstract 修时候 , 称为抽象类 , 不可以被实例化
抽象方法必须出现在抽象类中
抽象类中不一定有抽象方法
eg : Animal 类被 abstract修饰 , 成为抽象类
Animal animal =new Animal(); //报错 , 抽象类不可以被实例化 即 不可以被创建对象
抽象类天生就是父类 , 天生就是被子类继承的
子类继承抽象类的时候必须强制重写父类的抽象方法
子类继承父类的时候 , 如果父类中有抽象方法 , 子类必须要重写 , 除非把子类也变为抽象类 , 让子类的子类去重写
eg : Dog , cat pig 类集成Animal 父类
Dog dog = new Dog(); //一定正确
Cat cat = new Cat(); //一定正确
Pig pig = new Pig(); //一定正确
Animal animal1 = new Dog(); //如果有继承关系Dog extends Animal就是对的
Animal animal2 = new Cat(); //如果有继承关系Cat extends Animal就是对的
Animal animal3 = new Pig(); //如果有继承关系Pig extends Animal就是对的
多态 - 面向对象的三大特性
与多态相反的是单态
多态的指针(指针的类型是抽象的)
Animal animal
单态的指针(指针的类型是具体的)
Dog dog
Cat cat
Pig pig
面向对整理 面向过程和面向对象的区别面向过程变成思想 : 不考虑封装 , 继承 , 多态这些事情 , 直接把数据定义为静态变量 , 用静态函数操作数据 , 基于对象编程. 面向过程编程 , 代码不具有复用性和可扩展性
面向对象变成思想需要先抽象出试题结构 , 并用类进行封装 , 用成员变量表达实体的属性 , 用成员方法对封装实体属性的操作 . 提供构造方法构造对象 , 基于对象编程 ,面向过对象编程 , 代码具有复用性和可扩展性
实例 : 事先汽车租赁系统
面向过程的思想 :
定义多个静态数组 , 储存汽车各种数据 , 直接定义静态函数实现事项各种业务工程
面向对象的思想:
先抽象出汽车实体的结构 , 并使用汽车类惊醒封装. 然后创建汽车数组储存汽车实体的数据 , 在考虑业务功能的实现
面向对象的三大特征1. 封装
第一特性 : 封装
用成员变量来描述对象的属性 , 并用private 进行私有化封装 , 不对外暴露对象的属性 . 防止外部对属性误操作
成员方法用来封装对属性的操作 , 并暴露给外部调用,点想的成员方法就是 setter 和 getter 一个是提供给外部进行属性设值 , 一个是提供给外部读取属性的值
2. 继承.
第二特性 : 继承
1. 继承的关键字是extends
2. 继承是Java中类与类之间的一种关系
3. 发生继承的类称为子类, 被继承的类称为父类
4.Java不支持多继承, 只支持单继承, 但支持多级继承 . 一个类只能继承父类, 但是一个父类可以有多个子类
5.如果一个类没有显示的继承父类 , 则隐式继承Object类
6. 子类可以继承父类的非私有(非 private 修饰)成员
7.父类的构造方法子类不能继承 , 但可以使用super()调用
8. 父类的静态成员与继承无关
9. 如果父类中有抽象方法 , 子类必须要重写 , 除非 子类也是抽象类 , 让子类的子类区重写
3. 多态先有继承而后有多态 , 多天的反义词是单态
1. 指针的多态 (数组的多态 , 参数的多态 , 返回值的多态归根到底都是指针的多态)
如果指针是具体的子类类型 , 则指针是单态指针 , 只能指向具体的子类对象
如果指针是抽象的父类类型 , 则指针是多态指针 , 只能指向任意的子类对象
2. 方法的多态 ( 1 . 基于重载实现 2. 基于重写实现)
重载是编译时多态的体现
重写是运行时多态的体现
4.重载和重写的区别重载是编译时多态的体现
1. 重载是发生在同一个类中 , Java允许多个方法同名存在 , 但必须满足重载的要求
2. 方法名相同 , 但是方法的参数列表不同(可以是参数个数不同 , 或者是参数类型不同)
3. 静态方法 , 构造方法 , 成员方法都可以重载
重写是运行时多态的体现
1. 重写是发生在子类与父类之间 , 子类重写父类的方法 , 其目的是 : 当使用父类型的指针调用子类方法的时候 , 可以无需做向下转型
2. 子类方法与父类方法同名 ,
3. 访问修饰符要大于等于父类方法 ,
4. 参数的个数必须需要与父类一样 , 参数类型可以小于等于父类方法的参数类型
5. 返回值类型可以小于等于父类方法的返回值
抽象类和抽象方法的关系1. 抽象方法和抽象方法都需要使用abstract 关键字修饰
2. 抽象方法必须出现在抽象类中 , 抽象方法没有方法体 , 必须被子类重写
3. 抽象类中可以由抽象方法 , 也可以没有
普通类和抽象类的区别普通类可以实例化 , 也可以被继承
抽象类不能实例化 , 只能被继承 , 抽象类由抽象方法需要重写
向上转型和向下转型的区别向上转型
1. 将子类对象/指针赋给父类指针的语法称为"向上转型" , 隐式的
2. 继承是向上转型的前提 , 向上转型的目的是为了实现堕胎的指针
3. 向上转型的副作用 : 指针无法访问下级对象中的成员(除非发生重写)
向下转型
1. 将父类型指针赋给子类指针的语法称为"向下转型" , 需要显示的强制转换 , 通常伴随着instanceof做类型判断 , 否则可能会出现 ClassCastException(类型转换异常)
2. 指针向下转型为子类类型 , 就可以访问子类中特有成员了(非重写的成员方法)
访问权限设置符| 修饰符 | 当前类 | 同包 | 子类 | 其他包 |
| private (私有的) | 可见 √ | 不可见 X | 不可见 X | 不可见 X |
| (default) (不写) (默认的) | 可见 √ | 可见 √ | 不同包不可见 X | 不可见 X |
| protected (受保护的) | 可见 √ | 可见 √ | 可见 √ | 不可见 X |
| public (公有的) | 可见 √ | 可见 √ | 可见 √ | 可见 √ |
private 的特点 : 只有本类可见
(default)(默认的) 的特点 : 只有同包可见
protected 的特点 : 子类可见
public 的特点 : 任何地方都可见
抽象类和接口
