1、继承中成员变量的访问特点：就近原则：谁离得近就用谁
public class Fu {
String name="Fu";
}
public class Zi extends Fu{
String name="Zi";
public void ziShow(){
String name="ziShow";
System.out.println(name);//这里就近原则，所以是ziShow
System.out.println(this.name);//这里this关键字所以是本类中的Zi
System.out.println(super.name);//这里的super表示父类，所以是父类中的Fu
}
}
Idea中示范：
package a06extendsdemo3;
public class Test1 {
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);
System.out.println(this.name);
System.out.println(super.name);
}
}
运行结果：
继承中成员变量访问特点：就近原则
就近原则：先在局部位置找，本类成员位置找，父类成员位置找，逐级往上
代码示范：
package a06extendsdemo3;
public class Test2 {
public static void main(String[] args) {
Zi2 z=new Zi2();
z.show();
}
}
class Fu2{
String name="Fu";
String hobby="喝茶";
}
class Zi2 extends Fu2{
String name="Zi";
String game="吃鸡";
public void show(){
//如何打印Zi
System.out.println(name);//Zi
System.out.println(this.name);//Zi
//如何打印Fu
System.out.println(super.name);//Fu
//如何打印喝茶
System.out.println(hobby);//喝茶
System.out.println(this.hobby);//喝茶
System.out.println(super.hobby);//喝茶
//如何打印吃鸡
System.out.println(game);
System.out.println(this.game);
}
}运行结果：
如果出现了重名的成员变量：
System.out.println(name);//从局部位置开始往上找 System.out.println(this.name);//从本类成员位置开始往上找 System.out.println(super.name);//从父类成员位置开始往上找
2.继承中成员方法的访问特点：
（1）直接调用满足就近原则：谁离得近就用谁
（2）super调用：直接访问父类
代码示范：
package a06extendsdemo3;
public class Test3 {
public static void main(String[] args) {
Student s1=new Student();
s1.lunch();
OverseasStudent s=new OverseasStudent();
s.lunch();
}
}
class Person{
public void eat(){
System.out.println("吃饭，吃菜");
}
public void drink(){
System.out.println("喝水");
}
}
class OverseasStudent extends Person{
public void lunch(){
this.eat();
this.drink();
super.eat();
super.drink();
}
public void eat(){
System.out.println("吃意大利面");
}
public void drink(){
System.out.println("喝凉水");
}
}
class Student extends Person{
public void lunch(){
eat();//前面有一个隐含的this
drink();
//方法在调用时需要有调用者，上面这种情况会触发就近原则
//先在本类中查看eat和drink方法，如果有就会调用子类的，如果没有就会调用从父类中继承下来的
super.eat();
super.drink();
//此时不会查看本类，直接调用父类中的eat和drink方法
}
}
运行结果：
3.方法的重写：
当父类的方法不能满足子类现在的需求时，需要进行方法重写（上面例子中留学生吃意大利面，而父类中只有吃饭吃菜，不能满足留学生，所以需要在留学生类里进行方法重写）
书写格式：在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是 重写的方法
注意：@Override重写注解：
1.@Override是放在重写后的方法上，校验子类重写时语法是否正确
2.加上注解后，如果有红色波浪线，表示语法错误
@Override
public void eat(){
System.out.println("吃意大利面");
}
@Override
public void drink(){
System.out.println("喝凉水");
}方法重写的本质：如果发生了重写则会覆盖（图片来自哔站黑马程序员）
方法重写注意事项和要求：
1.重写方法的名称、形参列表必须与父类中的一致
2.子类重写父类方法时，访问权限子类必须大于等于父类（空着不写<protected<public）
3.子类重写父类方法时，返回值类型子类必须小于等于父类
4.建议：重写的方法尽量和父类保持一致
5.只有被添加到虚方法表中的方法才能被重写
练习：利用方法的重写设计继承结构
三种动物：哈士奇、沙皮狗、中华田园犬
暂时不考虑属性，只考虑行为，按照继承的思想特点进行继承体系的设计
三种动物的行为：哈士奇：吃饭（吃狗粮）、喝水、看家、拆家
沙皮狗：吃饭（吃狗粮，吃骨头）、喝水、看家
中华田园犬：吃饭（吃剩饭）、喝水、看家
狗：
package a07extendsdemo4;
public class Dog {
public void eat(){
System.out.println("狗吃狗粮");
}
public void drink(){
System.out.println("狗喝水");
}
public void lookHome(){
System.out.println("狗看家");
}
}
哈士奇：
package a07extendsdemo4;
public class Husky extends Dog{
//哈士奇有一个额外的方法：拆家
public void breakHome(){
System.out.println("哈士奇拆家");
}
}
沙皮狗：
package a07extendsdemo4;
public class SharPei extends Dog{
//因为沙皮狗吃狗粮和骨头
//父类中的方法不能满足需求，所以需要重写
@Override
public void eat() {
super.eat();//吃狗粮
System.out.println("狗吃骨头");
}
}
中华田园犬：
package a07extendsdemo4;
public class ChineseDog extends Dog{
//父类中的方法不能满足需求，所以需要重写
//而且中华田园犬完全用不到父类中的代码的，所以不需要通过super进行调用
@Override
public void eat(){
System.out.println("吃剩饭");
}
}
测试类：DogTest
package a07extendsdemo4;
public class DogTest {
public static void main(String[] args) {
//创建对象并调用方法
Husky h=new Husky();
h.eat();
h.drink();
h.lookHome();
h.breakHome();
ChineseDog cd=new ChineseDog();
cd.eat();
cd.drink();
cd.lookHome();
}
}
运行结果：
