（以下内容全部来自上述课程）
1.继承
1.子类到底能继承父类中的哪些内容？
- 构造方法（纯不能） 非私有：不能 private：不能
比如：把构造变量看成自己，爹就是爹，儿子就是儿子，不能混着来。 - 成员变量（纯能） 非私有：能 private：能
比如：父亲有public武功直接继承给儿子；如果是private武功就是把武功锁起来给儿子，钥匙是setget方法。 - 成员方法 （最正常） 非私有：能 private：不能
- 注意：继承不等于能调用！！！！！！
1.误区（错的）
- 父类私有的东西，子类就无法继承
- 父类中非私有的成员，就被子类继承下来了。
2.内存图
栈：方法（main）
堆：new出来的成员变量
方法区：字节码文件（类）
1.成员变量为非私有（可继承也可直接使用）
2.成员变量为私有（可继承但不能直接调用）
3.成员方法的虚方法
4.成员方法继承的内存图
2.继承中：成员变量的访问特点
就近原则：谁离我近，我就用谁
java">package a02loopextendsdemo2;
public class Test {
public static void main(String[] args) {
Zi z = new Zi();
z.ziShow();
}
}
class Fu {
String name = "Fu";
}
class Zi extends Fu {
String name = "Zi";
public void ziShow() {
String name = "ZiShow";
System.out.println(name); //ZiShow 就近原则:局部位置
System.out.println(this.name); //Zi 本类成员位置
System.out.println(super.name); //Fu super表示父类
}
}
3.继承中：成员方法的访问特点
直接调用满足就近原则：谁离我近，我就用谁
super直接调用，直接访问父类
1.方法的重写
当父类的方法不能满足子类现在的需求时，需要进行方法重写
书写格式：
在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。
@Override重写注解
- @Override是放在重写后的方法上，校验子类重写时语法是否正确。
- 加上注解后如果有红色的波浪线，表示语法错误。
- 建议重写方法都加@Override注解，代码安全，优雅！
2.方法重写的本质
3.方法重写注意事项和要求
- 重写方法的名称、形参列表必须与父类中的一致。
- 子类重写父类方法时，访问权限子类必须大于等于父类（空着不写<protected<public）
- 子类重写父类方法时，返回值类型子类必须小于等于父类
- 建议：重写的方法尽量和父类保持一致。
- 只有被添加到虚方法表中的方法才能被重写。
4.方法重写的实例
1.Dog
java">package a03loopextendsdemo3;
public class Dog {
public void eat(){
System.out.println("狗吃狗粮");
}
public void drink(){
System.out.println("狗喝水");
}
public void lookHome(){
System.out.println("狗看家");
}
}
2.Husky
java">package a03loopextendsdemo3;
public class Husky extends Dog {
//拆家
public void breakHome(){
System.out.println("哈士奇拆家");
}
}
3.SharPei
java">package a03loopextendsdemo3;
public class SharPei extends Dog{
@Override
public void eat(){
super.eat();
System.out.println("狗吃骨头");
}
}
4.ChineseDog
java">package a03loopextendsdemo3;
public class ChineseDog extends Dog{
@Override
public void eat(){
System.out.println("狗吃剩饭");
}
}
5.DogTest
java">package a03loopextendsdemo3;
public class DogTest {
public static void main(String[] args) {
//创建对象并调用方法
Husky h = new Husky();
h.eat(); //狗吃狗粮
h.drink(); //狗喝水
h.lookHome(); //狗看家
h.breakHome(); // 拆家
System.out.println("----------------");
ChineseDog c = new ChineseDog();
c.eat(); //狗吃剩饭
c.drink(); //狗喝水
c.lookHome(); //狗看家
System.out.println("----------------");
SharPei s = new SharPei();
s.eat(); //狗吃狗粮
s.drink(); //狗喝水
s.lookHome(); //狗看家
System.out.println("----------------");
Dog d = new Dog();
d.eat(); //狗吃狗粮
d.drink(); //狗喝水
d.lookHome(); //狗看家
System.out.println("----------------");
}
}
4.继承中的构造方法的访问特点
- 父类中的构造方法不会被子类继承
- 子类中所有的构造方法默认先访问父类中的无参构造，再执行自己。
为什么？
- 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
- 子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。
怎么调用父类构造方法的？
- 子类构造方法的第一行语句默认都是：super()，不写也存在，且必须在第一行。
- 如果想调用父类有参构造，必须手动写super进行调用。
1.无参
2.有参
3.总结（要看儿子得先看老子）
- 子类不能继承父类的构造方法，但是可以通过super调用。
- 子类构造方法的第一行，有一个默认的super();
- 默认先访问父类中无参的构造方法，再执行自己。
- 如果想要方法文父类有参构造，必须手动手写。
5.this、super关键字
1.this（就一局部变量）
理解为一个变量，表示当前方法调用的地址值。
2.super
代表父类存储空间。
3.this访问本类方法
表示调用本类其他构造方法
细节：虚拟机就不会再添加super();
4.实例
1.Empolyee
java">package a04loopextendsdemo4;
public class Employee {
//1.类名见名知意
//2.所有的成员变量都需要私有
//3.构造方法（空参 带全部参数的构造）
//4.get/set方法
private String id;
private String name;
private double salary;
public Employee() {
}
public Employee(String id, String name, double salary) {
this.id = id;
this.name = name;
this.salary = salary;
}
/**
* 获取
* @return id
*/
public String getId() {
return id;
}
/**
* 设置
* @param id
*/
public void setId(String id) {
this.id = id;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return salary
*/
public double getSalary() {
return salary;
}
/**
* 设置
* @param salary
*/
public void setSalary(double salary) {
this.salary = salary;
}
public String toString() {
return "Employee{id = " + id + ", name = " + name + ", salary = " + salary + "}";
}
//工作
public void work(){
System.out.println("员工在工作");
}
//吃饭
public void eat(){
System.out.println("员工在吃饭");
}
}
2.Manager
java">package a04loopextendsdemo4;
public class Manager extends Employee{
private double bonus;
//空参
public Manager() {
}
//带全部参数的构造
public Manager(String id, String name, double salary, double bonus) {
super(id, name, salary);
this.bonus = bonus;
}
//get/set方法
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("管理其他人");
}
}
3.Cook
java">package a04loopextendsdemo4;
public class Cook extends Employee{
public Cook() {
}
public Cook(String id, String name, double salary) {
super(id, name, salary);
}
@Override
public void work() {
System.out.println("炒菜");
}
}
4.Test
java">package a04loopextendsdemo4;
public class Test {
public static void main(String[] args) {
//创建对象并赋值调用
Manager m= new Manager("001","张三",10000,8000);
System.out.println(m.getId()+","+m.getName()+
","+m.getSalary()+ ","+m.getBonus());
m.work();
m.eat();
Cook c = new Cook();
c.setId("002");
c.setName("李四");
c.setSalary(20000);
System.out.println(c.getId()+","+c.getName()+
","+c.getSalary());
c.work();
c.eat();
}
}
