如题：什么是继承？
                一个对象可以使用另一个对象里的成员变量和成员方法，就被称为继承

        继承的好处是什么？
                提高代码的复用性
                让类与类之间产生关系，是多态的前提
                既沿袭父类的特有的功能，又可以定义一些自己的功能

        继承的特点是什么？
                Java语言中只支持单继承，不可以多继承，但可以多层继承，不可以循环继承

        我们在使用继承的时候需要注意哪些问题？
                子类只能使用父类的非私有的成员变量和成员方法，不能使用私有的成员变量和成员方法

                我们怎么才能使用父类的私有私有成员变量和成员方法呢？
                我们可以在父类中写一个公共的方法，在这个方法里可以调用本类中私有成员变量和成员方法，我们在子类中可以调用
                父类中公共的方法，即可间接调用父类中私有的成员变量和成员方法，然后我们就在测试类中创建子类对象，然后调用方法

        子父类之间成员变量的关系？
                父类中有一个成员变量，子类中有一个成员变量，子类的成员方法中有一个局部变量
               
                比如三个变量的名字都不一样的情况下
                例:
                   class Fu {
                           int i = 1;
                   }

                   class Zi extends Fu {
                           int j = 2;

                           public void eat() {
                                   int k = 3;

                                   System.out.println(k);//3
                                   System.out.println(j);//2
                                   System.out.println(i);//1
                           }
                   }

                   class Demo {
                           public static void main(String[] args) {
                                   Zi zi = new Zi();
                                   zi.eat();
                           }
                   }
                 

                 比如三个变量的名字都一样的情况下
                 例:
                    class Fu {
                        int i = 1;
                    }

                    class Zi extends Fu {
                        int i = 2;

                        public void eat() {
                            int i = 3;

                            System.out.println(i);//3
                            System.out.println(i);//3
                            System.out.println(i);//3
                        }
                   }

                   class Demo {
                        public static void main(String[] args) {
                           Zi zi = new Zi();
                           zi.eat();
                        }
                   }
                   那我们怎么才能分别输出父类的成员变量，子类的成员变量，子类的局部变量呢？
                   例:
                           class Fu {
                           int i = 1;
                   }

                   class Zi extends Fu {
                           int i = 2;

                           public void eat() {
                                   int i = 3;

                                   System.out.println(i);//3
                                   System.out.println(this.i);//2
                                   System.out.println(super.i);//1
                           }
                   }

                   class Demo {
                           public static void main(String[] args) {
                                   Zi zi = new Zi();
                                   zi.eat();
                           }
                   }

        子父类之间成员方法的关系？
                父类中有一个成员方法，子类中有一个成员方法

                比如两个方法的名字都不相同的情况下
                例:
                   class Fu {
                           public void printFu() {
                                   System.out.println("Fu");
                           }
                   }

                   class Zi extends Fu {
                           public void printZi() {
                                   System.out.println("Zi");
                           }
                   }

                   class Demo {
                           public static void main(String[] args) {
                                   Zi zi = new Zi();
                                   zi.printFu();//Fu
                                   zi.printZi();//Zi
                           }
                   }

                 比如两个方法的名字都相同的情况下
                 例:
                        class Fu {
                           public void print() {
                                   System.out.println("Fu");
                           }
                   }

                   class Zi extends Fu {
                           public void print() {
                                   System.out.println("Zi");
                           }
                   }

                   class Demo {
                           public static void main(String[] args) {
                                   Zi zi = new Zi();
                                   zi.print();//Zi
                                   zi.print();//Zi
                           }
                   }
                结果是打印的两个内容都相同，都是子类中方法的内容，那这里面就引出来一个知识点，方法的重写
                什么是方法的重写？
                        子类中出现与父类的方法的声明完全一下的方法，就称为方法的重写
               
                方法的重写和方法的重载的区别？
                        方法的重写:在子父类继承关系中，子类中出现与父类的方法的声明(返回值类型，方法名，参数列表)完全一样的方法，就称为方法的重写
                        方法的重载:在同一个类中，方法的名字相同，参数列表不同（参数的个数不同，参数的类型不同，参数的对应的位置顺序不同），与返回值类型无关

                我们在使用方法重写的时候需要注意哪些问题？
                        子类不可以重写父类的私有的成员方法
                        子类方法的访问权限要大于或者等于父类要被重写的方法的访问权限
                        静态方法只能重写静态方法
                        子类不可以重写父类中被final修饰成员方法（下午学习）

        子父类之间构造方法的关系？
                子类中构造方法第一行都有默认的隐藏的语句：super()，前提是第一行没有this()的时候，构造方法的第一行要么是super()，要么是this(参数)

                子类中所有的构造方法中至少有一个构造方法里的第一行是super();

                例:
                   class Fu {
                        public Fu() {}
                   }

                   class Zi extends Fu {
                        public Zi() {
                           //隐藏的super();
                        }
                   }


                   class Fu {
                        public Fu() {}
                   }

                   class Zi extends Fu {
                        int age;
                        public Zi() {
                           this(18);
                        }

                        public Zi(int age) {
                            //隐藏了super();
                            this.age = age;
                        }
                   }

总结的挺好

恩，很用心，值得参考

总结的很仔细 值得学习