1，继承的概述
        格式：
                class Fu{
                }

                class Zi extends Fu{
                //定义一个类 继承于 Fu 这个类
                }
       

        特点：
                子类可以使用父类中的方法，父类中的成员变量
                简单来说：子类中没有的，可以直接到父类中去拿。

       
        案例：
                class Fu{
                        public void fuMethod(){
                                System.out.println("父类的方法");
                        }
                }

                class Zi extends Fu{
                        public void ziMethod(){
                                System.out.println("子类的方法");
                        }
                }

                class Demo{
                        public static void main(String [] args){
                                Zi z = new Zi();
                                z.ziMethod();//可以的。因为此时会直接调用子类中的方法
                                z.fuMethod();//可以的。因为此时会先到本类中找，然后发现没有，再到父类中找。


                                Fu f = new Fu();
                                f.fuMethod();//可以的，因为此时会直接在本类中找。
                                f.ziMethod();//不可以的，因为在Java中永远只能向上找，不能向下找。
                        }
                }
       

        总结：
                1.创建一个类的对象，用这个对象调用方法，优先到本类中找，如果找不到就到父类中找。
                2.如果此时创建父类的对象，调用子类中特有的方法。是无法调用的，因为Java中只能向上找，不能向下找。


解释一下基础班学习的一个内容：
        String s1 = "abc";
        String s2 = new String(s1);

        System.out.println(s1.equals(s2));//就是因为String自己类中有equals方法，所以可以调用。

        StringBuilder sb1 = new StringBuilder("abc");
        StringBuilder sb2 = new StringBuilder("abc");

        System.out.println(sb1.equals(sb2));//StringBuilder里面没有equals方法，所以调用的是父类中的。
                                                                                //父类中比较的就是地址值。



2，,继承的好处和弊端
        好处：
                可以提高代码的复用性
                可以提高代码的可维护性

        简单理解：
                可以把多个子类中重复的代码写在父类里。
                此时子类中就不需要再写了。

        弊端：
                如果在父类中写了，那么子类中不得不也有这个方法了

        在以后我们写代码的过程中，不要随便写继承关系。
                一定要符合题目的业务逻辑。
               
       
3，继承中变量的访问特点
        就近原则：
                "谁离我近，我就用谁。"
                a,会先到方法的局部位置找。
                b,再到本类中成员位置找。
                c,父类的成员位置找。
                d,会到父类的父类（爷爷类）中的成员位置找
                一级一级往上找。
                如果都找不到就报错。
               

        统一的称呼：
                子类的父类，爷爷类，太爷爷类，祖爷爷类等等，统称为：父类。

                一个类的子类，孙子类，重孙子类等等，统称为：子类。


        在Java中辈分很简单：
                父类
                自己（本类）
                子类


4，super
        this:谁来调用我，我就代表谁。
                        谁来调用this所在的方法，那么this就表示调用者的地址值。

        super:谁来调用我，我就找他爸。
                        谁来调用super所在的方法，那么super直接找调用者的父类。


       
        super关键字有三种用法：
                1.调用成员变量
                2.调用构造方法
                3.调用成员方法


//调用成员变量
        总结：
                1.如果变量前面什么都没有，会触发就近原则。
                2.this.变量 先到本类的成员位置找，如果没有再到父类成员位置找
                3.super.变量 直接到父类的成员位置找。


        class Fu{
                int number = 10;
        }

        class Zi extends Fu{
                //int number = 20;


                //此时本方法的调用者其实是229行的那个z对象。
                public void method(){
                        int number = 30;
                        System.out.println(number);//30
                        System.out.println(this.number);//20  直接调用本类的成员变量。
                                                                                                  //如果找不到，就到父类中找。一级一级往上找。
                       
                        System.out.println(super.number);//10 直接到父类中找成员变量。
                }
        }


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

5，super调用构造方法

        格式：
                如果在javabean类中想要调用构造方法。

                this();//调用本类的空参构造
                this(参数);//调用本类的带参构造

                super();//调用父类的空参构造
                super(参数);//调用父类的带参构造
               
                1.如果构造方法第一行不是this，也没有super，那么虚拟机会默认添加一个super();表示调用父类的空参构造。
                2.构造方法不能被继承，只能被调用。
                        真正能继承给子类去用的是谁？成员变量 成员方法


       
        练习：
        public class Demo {
                public static void main(String[] args) {
                        Zi z = new Zi();//子类的空参构造
                        //Zi z = new Zi(1);
                }
        }
        class Fu{
                public Fu(){
                        this(1);
                        System.out.println("111");
                }

                public Fu(int number){
                        System.out.println("222");
                }
        }

        class Zi extends Fu{
                public Zi(){
                        this(1); //调用本类的其他带参构造
                        System.out.println("333");
                }
                public Zi(int number){//第一行什么都没有，默认带一个隐藏的super();
                        System.out.println("444");
                }
        }

6，.继承中成员方法的访问特点

        1、子类中没有直接到父类中去拿
                如果子类中有，直接使用子类的。
        2、如果子类方法中有 super.方法名();才会调用父类中的方法。

        class Fu{
                public void eat(){
                        System.out.println("喝点小酒");
                }
        }

        class Son1 extends Fu{ //这个儿子30岁
                public void eat(){
                        //先抽烟，再喝酒
                        System.out.println("抽烟");
                        super.eat();
                }
        }

        class Son2 extends Fu{ //这个儿子20岁
                public void eat(){
                        //先吃点东西，再喝酒
                        System.out.println("吃点东西");
                        super.eat();
                }
        }

        class Son3 extends Fu{ //这个儿子1岁
                public void eat(){
                        //只能喝杯奶
                        System.out.println("喝奶");
                }
        }


7，super内存图//了解一下。



8，方法重写
        a.注解：都是对程序的解释说明  //是给虚拟机看的。
                @Override //就是告诉虚拟机下面的这个方法是重写的父类的。
                                        //如果语法正确，那么就不报错。
                                        //如果语法错误，那么虚拟机就报错了。

          注释：都是对程序的解释说明  //是给程序员看的。



        b.方法的重写：在子父类中，存在一模一样的方法，此时就叫做方法重写。

          方法的重载：在同一个类中。方法名相同，参数列表不同，与返回值无关。
       

9，.方法重写的注意事项//了解一下就可以了。
        绝大多数情况下，在方法重写时，子父类中的方法都会写成一模一样的。


10，继承的注意事项
        在Java中，一个子类只能有一个父类。//一个儿子只能有一个爸爸。
        但是一个父类，可以有多个子类。//一个爸爸可以有多个儿子。

        标准说法：
                Java中的继承，只能单继承，单一继承。
                不能多继承，但是可以多层继承，多重继承。


        class 爸爸1{
                public void eat(){
                        System.out.println("吃米饭");
                }
        }


        class 爸爸2{
                public void eat(){
                        System.out.println("吃面条");
                }
        }


        class Son extends 爸爸1,爸爸2{
        }


        Son s = new Son();
        s.eat();//是吃米饭还是吃面条，此时Java就懵逼了。


11.package（包）//了解一下
        1.package关键字后面的路径，是决定了当前类编译之后的class文件所在的路径。、
        2.全类名： 包名 + 类名。
                                com.itheima.demo1.Student


12,import  //掌握
        作用：告诉虚拟机我现在用的这个类在哪。
        快捷键：ctrl + alt + o （整理包）
                        //如果没有导，我就帮你导
                        //如果导了没有使用，我就帮你删掉
        什么时候需要导包？什么时候不需要导包？
                使用本包中的类不需要导包
                使用java.lang(核心包)包下的类时不需要导包
       
               
13.权限修饰符
        掌握
                1.
                        public  在所有的地方都可以访问
                        private 在本类中被访问
                2.
                        默认修饰符不是default，而是什么都不写。

                        class Student{
                                String name; //使用的就是默认修饰符
                        }
        了解：
                四种权限修饰符的范围只要了解一下就可以了。
                public （公共的）: 所有的地方都可以用
                private（私有的）：在本类中被访问

                protected: （受保护的）：
                        儿子都是受保护的，家里的儿子，外面的儿子都能使用你的东西。


                默认：好比以后的你工资。
                        默认上交给媳妇的，给家里人用，给家里的儿子用。
                        可以在本包中使用，本包中无关类，子类都可以使用。
               

1，继承的概述
        格式：
                class Fu{
                }

                class Zi extends Fu{
                //定义一个类 继承于 Fu 这个类
                }
       

        特点：
                子类可以使用父类中的方法，父类中的成员变量
                简单来说：子类中没有的，可以直接到父类中去拿。

       
        案例：
                class Fu{
                        public void fuMethod(){
                                System.out.println("父类的方法");
                        }
                }

                class Zi extends Fu{
                        public void ziMethod(){
                                System.out.println("子类的方法");
                        }
                }

                class Demo{
                        public static void main(String [] args){
                                Zi z = new Zi();
                                z.ziMethod();//可以的。因为此时会直接调用子类中的方法
                                z.fuMethod();//可以的。因为此时会先到本类中找，然后发现没有，再到父类中找。


                                Fu f = new Fu();
                                f.fuMethod();//可以的，因为此时会直接在本类中找。
                                f.ziMethod();//不可以的，因为在Java中永远只能向上找，不能向下找。
                        }
                }
       

        总结：
                1.创建一个类的对象，用这个对象调用方法，优先到本类中找，如果找不到就到父类中找。
                2.如果此时创建父类的对象，调用子类中特有的方法。是无法调用的，因为Java中只能向上找，不能向下找。


解释一下基础班学习的一个内容：
        String s1 = "abc";
        String s2 = new String(s1);

        System.out.println(s1.equals(s2));//就是因为String自己类中有equals方法，所以可以调用。

        StringBuilder sb1 = new StringBuilder("abc");
        StringBuilder sb2 = new StringBuilder("abc");

        System.out.println(sb1.equals(sb2));//StringBuilder里面没有equals方法，所以调用的是父类中的。
                                                                                //父类中比较的就是地址值。



2，,继承的好处和弊端
        好处：
                可以提高代码的复用性
                可以提高代码的可维护性

        简单理解：
                可以把多个子类中重复的代码写在父类里。
                此时子类中就不需要再写了。

        弊端：
                如果在父类中写了，那么子类中不得不也有这个方法了

        在以后我们写代码的过程中，不要随便写继承关系。
                一定要符合题目的业务逻辑。
               
       
3，继承中变量的访问特点
        就近原则：
                "谁离我近，我就用谁。"
                a,会先到方法的局部位置找。
                b,再到本类中成员位置找。
                c,父类的成员位置找。
                d,会到父类的父类（爷爷类）中的成员位置找
                一级一级往上找。
                如果都找不到就报错。
               

        统一的称呼：
                子类的父类，爷爷类，太爷爷类，祖爷爷类等等，统称为：父类。

                一个类的子类，孙子类，重孙子类等等，统称为：子类。


        在Java中辈分很简单：
                父类
                自己（本类）
                子类


4，super
        this:谁来调用我，我就代表谁。
                        谁来调用this所在的方法，那么this就表示调用者的地址值。

        super:谁来调用我，我就找他爸。
                        谁来调用super所在的方法，那么super直接找调用者的父类。


       
        super关键字有三种用法：
                1.调用成员变量
                2.调用构造方法
                3.调用成员方法


//调用成员变量
        总结：
                1.如果变量前面什么都没有，会触发就近原则。
                2.this.变量 先到本类的成员位置找，如果没有再到父类成员位置找
                3.super.变量 直接到父类的成员位置找。


        class Fu{
                int number = 10;
        }

        class Zi extends Fu{
                //int number = 20;


                //此时本方法的调用者其实是229行的那个z对象。
                public void method(){
                        int number = 30;
                        System.out.println(number);//30
                        System.out.println(this.number);//20  直接调用本类的成员变量。
                                                                                                  //如果找不到，就到父类中找。一级一级往上找。
                       
                        System.out.println(super.number);//10 直接到父类中找成员变量。
                }
        }


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

5，super调用构造方法

        格式：
                如果在javabean类中想要调用构造方法。

                this();//调用本类的空参构造
                this(参数);//调用本类的带参构造

                super();//调用父类的空参构造
                super(参数);//调用父类的带参构造
               
                1.如果构造方法第一行不是this，也没有super，那么虚拟机会默认添加一个super();表示调用父类的空参构造。
                2.构造方法不能被继承，只能被调用。
                        真正能继承给子类去用的是谁？成员变量 成员方法


       
        练习：
        public class Demo {
                public static void main(String[] args) {
                        Zi z = new Zi();//子类的空参构造
                        //Zi z = new Zi(1);
                }
        }
        class Fu{
                public Fu(){
                        this(1);
                        System.out.println("111");
                }

                public Fu(int number){
                        System.out.println("222");
                }
        }

        class Zi extends Fu{
                public Zi(){
                        this(1); //调用本类的其他带参构造
                        System.out.println("333");
                }
                public Zi(int number){//第一行什么都没有，默认带一个隐藏的super();
                        System.out.println("444");
                }
        }

6，.继承中成员方法的访问特点

        1、子类中没有直接到父类中去拿
                如果子类中有，直接使用子类的。
        2、如果子类方法中有 super.方法名();才会调用父类中的方法。

        class Fu{
                public void eat(){
                        System.out.println("喝点小酒");
                }
        }

        class Son1 extends Fu{ //这个儿子30岁
                public void eat(){
                        //先抽烟，再喝酒
                        System.out.println("抽烟");
                        super.eat();
                }
        }

        class Son2 extends Fu{ //这个儿子20岁
                public void eat(){
                        //先吃点东西，再喝酒
                        System.out.println("吃点东西");
                        super.eat();
                }
        }

        class Son3 extends Fu{ //这个儿子1岁
                public void eat(){
                        //只能喝杯奶
                        System.out.println("喝奶");
                }
        }


7，super内存图//了解一下。



8，方法重写
        a.注解：都是对程序的解释说明  //是给虚拟机看的。
                @Override //就是告诉虚拟机下面的这个方法是重写的父类的。
                                        //如果语法正确，那么就不报错。
                                        //如果语法错误，那么虚拟机就报错了。

          注释：都是对程序的解释说明  //是给程序员看的。



        b.方法的重写：在子父类中，存在一模一样的方法，此时就叫做方法重写。

          方法的重载：在同一个类中。方法名相同，参数列表不同，与返回值无关。
       

9，.方法重写的注意事项//了解一下就可以了。
        绝大多数情况下，在方法重写时，子父类中的方法都会写成一模一样的。


10，继承的注意事项
        在Java中，一个子类只能有一个父类。//一个儿子只能有一个爸爸。
        但是一个父类，可以有多个子类。//一个爸爸可以有多个儿子。

        标准说法：
                Java中的继承，只能单继承，单一继承。
                不能多继承，但是可以多层继承，多重继承。


        class 爸爸1{
                public void eat(){
                        System.out.println("吃米饭");
                }
        }


        class 爸爸2{
                public void eat(){
                        System.out.println("吃面条");
                }
        }


        class Son extends 爸爸1,爸爸2{
        }


        Son s = new Son();
        s.eat();//是吃米饭还是吃面条，此时Java就懵逼了。


11.package（包）//了解一下
        1.package关键字后面的路径，是决定了当前类编译之后的class文件所在的路径。、
        2.全类名： 包名 + 类名。
                                com.itheima.demo1.Student


12,import  //掌握
        作用：告诉虚拟机我现在用的这个类在哪。
        快捷键：ctrl + alt + o （整理包）
                        //如果没有导，我就帮你导
                        //如果导了没有使用，我就帮你删掉
        什么时候需要导包？什么时候不需要导包？
                使用本包中的类不需要导包
                使用java.lang(核心包)包下的类时不需要导包
       
               
13.权限修饰符
        掌握
                1.
                        public  在所有的地方都可以访问
                        private 在本类中被访问
                2.
                        默认修饰符不是default，而是什么都不写。

                        class Student{
                                String name; //使用的就是默认修饰符
                        }
        了解：
                四种权限修饰符的范围只要了解一下就可以了。
                public （公共的）: 所有的地方都可以用
                private（私有的）：在本类中被访问

                protected: （受保护的）：
                        儿子都是受保护的，家里的儿子，外面的儿子都能使用你的东西。


                默认：好比以后的你工资。
                        默认上交给媳妇的，给家里人用，给家里的儿子用。
                        可以在本包中使用，本包中无关类，子类都可以使用。