1 继承
1.1概念
继承是面向对象最显著的一个特征
继承是从已有的类中派生出新的类,新类能吸收已有类的数据属性和行为,并扩展新的能力.
Java继承是会用已存在的类的定义作为基础建立新类的技术
新类的定义可以增加新的数据或者新的功能,也可以使用父类的功能,但不能选择性的继承父类(超类/基类)
这种继承使得复用以前的代码非常容易,能够大大的缩短开发的周期,降低开发费用.
1.2 特点
使用extends关键字来表示继承关系
相当于子类把父类的功能复制了一份
Java只支持单继承
继承可以传递(爷爷/儿子/孙子这样的关系)
父类的私有成员由于私有限制访问,所以子类不能使用父类的私有资源
继承多用于功能的修改,子类可以在拥有父类功能的同时,进行功能拓展
像是is a的关系
1.3 练习:继承入门案例
创建包: cn.tedu.oop2
创建类: TestExtends.java
package cn.tedu.oop2;
/*本类用于继承的入门案例*/
public class TestExtends {
public static void main(String[] args) {
//5.分别创建3个类的对象
Animal a = new Animal();
Cat c = new Cat();
MiaoMiao m = new MiaoMiao();
//6.利用对象调用方法进行测试
/*3.继承相当于是子类将父类的功能复制了一份
继承还具有传递性,爷爷的功能会传给爸爸,爸爸的功能会传给孙子*/
a.eat();//爷爷类使用自己的方法
c.eat();//爸爸类可以使用从爷爷类中继承过来的方法
m.eat();//孙子类也可以使用从爷爷类中继承过来的方法
}
}
/*1.我们通过extends关键字建立子类与父类的继承关系,格式:子类 extends 父类*/
/*2.Java只支持单继承,一个子类只能有一个父类,但是一个父类可以有多个子类*/
//1.创建小动物类--爷爷类
class Animal{
//4.添加爷爷类的普通方法
public void eat(){
System.out.println("小动物Animal吃啥都行~");
}
}
//2.创建小猫类--爸爸类
/*6.继承是is a的关系,比如小猫是小动物,MiaoMiao是一只小猫
* 继承要求子类必须是父类的一种下属类型,依赖性非常强,强耦合*/
class Cat extends Animal{
//7.定义爸爸类中的属性
int a = 10;//普通属性
private int b = 100;//私有属性
}
//3.创建MiaoMiao类--孙子类
class MiaoMiao extends Cat{
/*4.子类可以拥有自己独有的方法,实现了功能的拓展,青出于蓝而胜于蓝*/
//8.定义孙子类的方法
public void studyJava(){
System.out.println("正在学Java");
System.out.println(a);
/*5.子类继承了父类以后,可以使用父类的所有非私有资源
* 注意:这个私有资源由于被private修饰,所以没有访问权限*/
//System.out.println(b);//不可以,私有资源被限制访问
}
}
2 super
我们可以把super看作是父类的对象:Father super = new Father();
1.当父类的成员变量与子类的变量同名时,使用super指定父类的成员变量
2.使用super在子类构造方法的第一行调用父类构造方法的功能
super();–调用的是父类的无参构造
super(参数);–调用的是父类对应参数的构造方法
注意:在构造方法里,出现的调用位置必须是第一行
3 继承的用法
3.1 练习:super之继承中成员变量使用
创建包: cn.tedu.oopextends
创建类: TestExtends1.java
package cn.tedu.oop2;
/*本类用于测试继承中变量的使用*/
public class ExtendsDemo1 {
public static void main(String[] args) {
//7.创建子类的匿名对象,调用study()
new Son().study();
}
}
//1.创建父类
class Father{
//3.创建父类的成员变量
int sum = 1;
int count = 2;
}
//2.创建子类
class Son extends Father{
//4.创建子类的成员变量
int sum = 10;
//5.创建子类的普通方法
public void study(){
System.out.println("goog good study , day day up");
//6.创建子类的局部变量
int sum = 100;
//8.打印子类的局部变量sum
System.out.println(sum);//100
//9.打印子类的成员变量sum
System.out.println(this.sum);//10
//10.打印父类的成员变量sum
/*当父类的成员变量与子类的成员变量同名时,可以使用super指定父类的成员变量
* 我们可以把super看作是父类的对象:Father super = new Father();*/
System.out.println(super.sum);//1
System.out.println(count);
}
}
3.2 练习:super之继承中构造方法的使用
创建包: cn.tedu.oop2
创建类: ExtendsDemo2.java
package cn.tedu.oop2;
/*本类用于测试继承中构造方法的使用
* 1.子类在创建对象时,默认会先调用父类的构造方法
* 2.原因是子类构造函数中的第一行默认存在super();--表示调用父类的无参构造
* 3.当父类没有无参构造时,可以通过super(参数)调用父类的其他含参构造
* 子类必须调用一个父类的构造函数,不管是无参还是含参,选一个即可
* 4.构造方法不可以被继承!因为语法的原因:要求构造方法的名字必须是本类类名
* 不能在子类中出现一个父类名字的构造方法*/
public class ExtendsDemo2 {
public static void main(String[] args) {
//6.1通过父类的无参构造创建父类对象
//Father2 f = new Father2();
//6.2通过父类的含参构造创建父类对象
//Father2 f2 = new Father2("哈哈哈");
//7.创建子类对象
Son2 s = new Son2();
}
}
//1.创建父类
class Father2{
//3.创建父类的无参构造
// public Father2(){
// System.out.println("我是父类的无参构造");
// }
//4.创建父类的含参构造
public Father2(String s){
System.out.println("我是父类的含参构造"+s);
}
}
//2.创建子类
class Son2 extends Father2{
//5.创建子类的无参构造
public Son2(){
//super();//调用父类的无参构造
super("你好~");
System.out.println("我是子类的无参构造");
}
}
4 方法重写Override
继承以后,子类就拥有了父类的功能
在子类中,可以添加子类特有的功能,也可以修改父类的原有功能
子类中方法的签名与父类完全一样时,会发生覆盖/复写的现象
注意: 父类的私有方法不能被重写
重写的要求:两同两小一大
两同:方法名 参数列表 要完全一致
两小:
子类返回值类型小于等于父类的返回值类型(注意此处说的是继承关系,不是值大小)
子类抛出异常小于等于父类方法抛出异常
一大:子类方法的修饰符权限要大于等于父类被重写方法的修饰符权限
4.1 练习:继承中成员方法的使用
创建包: cn.tedu.oop2
创建类: ExtendsDemo3.java
package cn.tedu.oop2;
/*本类用于测试继承中方法的使用*/
public class ExtendsDemo3 {
public static void main(String[] args) {
//4.创建对象进行测试
Father f = new Father();
Son s = new Son();
f.eat();
s.eat();
f.play();
s.play();
}
}
//1.创建父类
class Father{
//3.定义父类中的普通方法
public void eat(){
System.out.println("爸爸爱吃肉");
}
public void play(){
System.out.println("爸爸爱放风筝");
}
}
//2.创建子类
class Son extends Father{
//5.如果子类对父类的方法不满意,可以重写父类的方法
/*重写的原则:两同 两小 一大
* 两同:子类方法的 方法名与参数列表 和父类方法的相同
* 一大:子类方法的 方法修饰符权限 >= 父类方法的
* 两小:子类方法的返回值类型 <= 父类方法的返回值类型
* 注意:这里所说的<=是指子类方法的返回值类型是父类返回值类型的子类
* 或者与父类的返回值类型一致,如果父类方法的返回值类型是void,子类保持一致即可
* */
@Override //注解,用来加在方法上,表示这是一个重写的方法
public void eat(){
System.out.println("儿子爱吃蔬菜");
}
@Override
public void play(){
System.out.println("儿子爱玩游戏");
}
}
5. 拓展
5.1 继承的好处与坏处
继承的好处
提高了代码的复用性(多个类相同的成员可以放在同一个类中)
提高了代码的维护性(如果方法的代码需要修改,只修改一处即可)
继承的坏处
继承让类与类建立了关系,类的耦合性增强
当父类发生变化时,子类实现也不得不跟着变化,削弱了子类的独立性
5.1 this与super的区别
this: 代表本类对象的引用
我们可以把this看作是Cat this = new Cat();
super:代表父类存储空间的标识,可以理解成父类对象的引用
可以把super看作是Father super = new Father();
this关键字指向调用该方法的对象
一般我们是在当前类中使用this关键字
所以我们常说this代表本类对象的引用
注意:super的使用前提是继承,没有父子类关系,就没有super
注意:this调用构造方法或者super调用构造方法,都必须出现在构造方法的第一行
注意:如果父类没有无参构造,需要手动在子类构造方法的第一行调用其他的含参构造
拓展:如果子类重写了父类的方法以后,可以使用super.方法名(参数列表)来调用
5.2 重载Overload 与重写Override的区别
重载:在一个类中的现象:同一个类中,存在方法名相同,参数列表不同的方法
重写:是指建立了继承关系以后,子类对父类的方法不满意,可以重写,遵循两同两小一大原则
重载的意义:是为了外界调用方法时方便,不管传入什么样的参数,都可以匹配到对应的同名方法
重写的意义:在不修改源码的情况下,进行功能的修改与拓展(OCP原则:面向修改关闭,面向拓展开放)