2021-10-30

2021-10-30

	每日100！		Java、C++继承
										特点

1：子类可以拥有父类的属性和方法
public
protectd
默认的只方法有子类与父类在一个包可以访问
当两个类中有多个相同的属性或者方法是时，抽取父类
实现代码复用
C+H列出类的继承结构
2：子类可以有自己的新方法和属性
3：子类可以重写父类的方法
方法重写 （方法覆盖）
子类方法与父类方法具有相同方法声明，不同的方法实现
子类方法与父类方法具有相同方法头，不同的方法体
注解
编译器会处理
【重写】@Overide （放到子类上面）表示此方法是重写父类的
【替代】@Deprecated 不推荐使用
4：声明父类，创建子类
多态
父类能出现的地方子类也能出现
父类能完成的子类也能完成
形参是父类，实参是子类
4.1：声明的什么类型，就只能调用声明类型的属性和方法（老爸抽烟可以调，喝酒不能调）
4.2：创建的什么类型就真正运行什么类型的方法（子类重写了父类的方法）
c++
调用真正运行子类重写的方法，必须在父类方法声明前加virtual <返回值类型> <函数名> （形参）
4.3：创建的什么类型，就可以强转为什么类型
示例
Java
Extends.java
package com.honghong;

public class Extends {
public static void main(String[] args){
Son yjh = new Son();
yjh.name = “yjh”;
yjh.lineName = “天子笑”;
yjh.qq();
yjh.wx();
yjh.driver();
int m = yjh.add(2,3);
System.out.println(m);
yjh.sayHello();
Father laoyu = new Father();
laoyu.driver();
//声明父类（声明什么类型，就只能调用声明类型的属性和方法）
Father lisi;
//创建子类（创建的什么类型就真正运行什么类型的方法）
lisi = new Son();//子类重写了父类driver的方法
lisi.driver();
//lisi.qq new （创建）

}

}
Father.java
package com.honghong;

public class Father {
public String name;
public void driver(){
System.out.println(“父类骑自行车”);
}
public int add(int a,int b){
return a + b;
}
public void sayHello(){
System.out.println(“大家好！”);
}
}
Son.java
package com.honghong;

public class Son extends Father{
public String lineName;
@Deprecated
public void wx(){
System.out.println(“我的网名是” + lineName + “子类聊wx”);
}
public void qq(){
System.out.println(“我的网名是” + lineName + “子类聊qq”);
}
@Override //方法重写（方法覆盖），子类方法与父类具有相同的方法声明（方法头），不同的方法实现（方法体）
public void driver(){
System.out.println(“子类重写父类方法，开宝马”);
}

}
C++
TestExtends.cpp
#include
#include “Son.h”
using namespace std;
int main() {
Father laoyu;
laoyu.driver();
laoyu.blw();
laoyu.chouyan();
cout << “---------------------------------------------” << endl;
Son yjh;
yjh.driver();
yjh.blw();
yjh.chouyan();
yjh.changge();
cout << “---------------------------------------------” << endl;
Father *lisi;//声明父类(声明什么类行，就只能调用什么类型的属性和方法)
lisi = new Son();//创建子类（创建什么类型就真正运行什么类型的属性和方法）
lisi->driver();
lisi->blw();
lisi->chouyan();
return 0;
}
Father.h
class Father {
public:
virtual void driver();

void blw();

void chouyan();

};
Father.cpp
#include"Father.h"
#include

using namespace std;

void Father::driver() {
cout << “父类骑自行车” << endl;
}
void Father::blw() {
cout << “父类转转转！” << endl;
}

void Father::chouyan() {
cout << “父类抽烟” << endl;
}

Son.h
#include “Father.h”
class Son: public Father{
public:
void driver();

void blw();

void changge();

};

Son.cpp
#include
#include “Son.h”
using namespace std;
void Son::driver() {
cout << “子类开宝马” << endl;
}
void Son::blw() {
cout << “子类转转转转转转转转转” << endl;
}

void Son::changge() {
cout << “子类唱歌” << endl;
}