Random类(理解)：
        构造方法：
                Random(); 以当前时间的毫秒值作为默认种子，每次产生的随机数都是不一样的。
                Random(long seed);根据给定的值作为默认种子，每次都是按照给定的种子做出初始值产生随机数，
                                                  如果种子是固定的，产生的随机数的规律都是一样的。
        成员方法：
                nextInt(); 产生一个int范围内的随机数。
                nextInt(int n);产生一个0-n之间的随机数，包左不包右。
        注意：
                开发中，我们想使用那个类，就单独导入哪个类。
                不要写java.util.*这种方式。


继承：
        概述：把多个类中的同性内容提取出来放到一个单独的类（A）中，然后让这多个类和类A产生关系，
                 这样，这个多个类就具备了类A的功能，这种技术，就叫继承。
        格式：
                class A extends B
                {
                       
                }
        叫法：
                类A：子类，派生类
                类B：父类，基类，超类，
        注意：
                子类可以直接访问父类中的所有非私有成员。

        案例：
                父类：Person
                子类：Student
                class Person
                {       
                        public void show()
                        {
                                sop("nihao");
                        }
                }
                class Student extends Person
                {
                        public void show()
                        {
                                sop("nihaoma ?");
                        }
                }
                       
                }
                class Demo
                {
                        Student s = new Student();
                        s.show();
                        Student s1 = new Student();
                }

继承使用是需要注意 的问题是？
        子类可以直接访问父类中的所有非私有成员。
子类中如果想使用父类私有的成员变量怎么办？
        1、通过父类的公共访问方式。
        2、通过调用父类的其他带参构造(了解)。

继承的好处和特点：
        好处：
                1、提高代码的复用性。
                2、让类与类之间产生一个关系，是多态的前提。
        特点：
                1、Java支持单继承，不支持多继承。
                        为什么不支持多继承？
                                假如可以多继承的话，会出现调用不明确的情况。
                2、Java支持多层继承（继承体系）。
                        类A继承类B，类B还可以继承类C，类C还可以继承。。。。

什么时候定义继承关系呢？
        当类与类之间满足 is a 的关系的时候，就可以使用继承。
        举例：
                A is a B的一种：A是子类，B是父类。
                B is a A的一种：B是子类，A是父类。
        注意：
                不要为了获取部分功能，而去使用继承。

类的组成：
        成员变量
                使用变量，遵循一个就近原则，先在局部范围找，没有就到本类的成员位置找，如果没有就到父类的成员位置找。
                如果还没有，就报错。
                在子类中，想输出本类的局部变量，成员变量，父类的成员变量值，怎么班？
                        局部变量：直接输出。
                        成员变量：this.变量名。
                        父类的成员变量：super.变量名。
                        如果他们的变量名不同，直接输出即可。
                this和super有什么区别？
                        this：代表本类对象的引用。
                        super：代表父类的内存空间标识（可以理解为父类对象的引用）。
                this和super的用法：
                        成员变量；
                                this.成员变量：本类的成员变量
                                super.成员变量：父类的成员变量
                        构造方法：
                                this(参数)：本类的其他构造方法。
                                super(参数)：父类的构造方法。
                        成员方法：
                                this.方法名()：本类的成员方法
                                super.方法名()：父类的成员方法
        成员方法
                子父类间方法的调用问题？
                        先在子类中找，如果没有，就去父类中找。
                面试题：
                        方法重载和方法重写有什么区别？
                                方法重载：同一个类中，出现方法名相同，参数列表不同的两个或多个方法时，即构造方法重载。
                                                        方法的重载与返回值的数据类型无关。
                                方法重写：子父类间，出现一模一样的方法时，被称为方法的重写，或者复写。
                                                  注意：方法重写，要求一模一样。包括返回值的数据类型。
                方法覆盖需要注意哪些问题？
                        1、父类的私有方法不能被子类重写。
                        2、子类方法的访问权限一定要大于等于父类方法的访问权限。
                        3、静态方法只能被静态方法重写。（这个不算子类间对象的成员关系）
                方法重写的应用场景：       
                        当子类需要使用父类的某个功能，并且在这个功能的主体上需要加入自己特有内容的时候，
                        就可以考虑使用方法的重写，这样，即沿袭了父类的功能，又加入了自己的功能。

        构造方法
                子父类间构造方法的执行顺序：
                        子类的所有构造方法默认都去访问了父类的无参构造，
                        原因是，子类的所有构造方法之前有一行默认的代码：super();
                为什么要这样做呢？
                        子类默认具备了父类的非私有数据，而父类的数据的初始化是靠父类自己来完成的。
                        所以在子类的构造方法执行前，需要先执行父类的构造方法对父类数据进行初始化。
                如果父类没有无参构造怎么办？
                        1、通过super(参数)的形式来调用，父类的其他带参构造。
                        2、通过this(参数)的形式来调用本类的其他带参构造。
        一个关于代码块的面试题：
                父类的构造方法，子类的构造方法
                父类的构造代码块，子类的构造代码块
                父类的静态代码块，子类的静态代码块。
                如果子父类都有静态代码块，构造代码块，构造方法，那么他们之间的执行顺序是什么？
                        父类的静态代码块  -- 》子类的静态代码块 --》 父类的构造代码块 --》父类的构造方法
                        --》 子类的构造代码块 --》子类的构造方法
                        注意：
                                静态代码块只加载一次（.class字节码文件只加载一次的情况下）。
        子父类间的关系：

final关键字：
        概述：它是一个关键字，表示最终的意思，它可以修饰类，成员变量，成员方法。
        它修饰的类，不能被继承，但是可以继承其他类。
        它修饰的成员变量，其实是一个常量。
                常量的分类：
                        字面值常量； 123,32，"Hello"
                        自定义常量：格式跟咱们定义变量一样，加一个final即可。
                                final int A = 10;
                                被final修饰的成员变量没有赋值,那么该变量一旦被赋值
                                就是一个常量,不可被更改;   final String name;
                               
                        它修饰的成员方法，不能被子类重写。
       
               
        中午：
                思考题：
                        1、父类的私有方法能被重写吗？
                        2、子父类间，方法的权限问题。private public
                        3、父类的静态方法能被子类的非静态方法重写吗？

                        4、把上午的案例写一下。

赞！一个