面向对象3

1：复习

         1：this关键字

                   1：this表示当前对象的引用。

                   2：this访问本类中的成员变量和成员方法。也可以访问构造方法,必须放在第一条语句。

                   3：this可以作为实参来传递

         2：面向对象三大特征：封装，继承，多态。

                   2.1：封装：属性私有化，提供公共的方法供外界访问。

2：继承

         2.1：当分析一些事物时，发现他们有很多相同的地方，为了提高代码的可重用性，可以将他们相同的部分提取出来，放到一个类里。让其他的事物跟这个类建立关系，而这种关系就叫继承。用关键字extends来表示。Extends 英文是扩展的意思。（子类也称派生类）

         2.2：产生继承关系后对子类的影响

                   1：子类可以拥有父类的所有的属性或者方法(以后讲访问权限.)

         2.3：super:

                   1:表示父类的标识，也就是一个名字罢了。

                   2：作用

                            1：可以访问父类的成员   super.成员变量名。

                            2：访问父类的方法      super.方法名( )

                            3：访问父类的构造方法   .创建子类对象时，先默认调用父类的无参构造方法，再调用子类的相应构造方法。调用父类的构造方法必须是构造方法中的第一条语句。如果需要调用父类的有参构造方法，必须显式得调用。

                   3：this与super的区别

                            1：作用，this表示当前对象的引用，而super表示父类的标识。

                            2：访问。this可以访问本类的成员变量和方法，而super访问父类的成员变量和方法。

                            3：相同点。访问构造方法时，都必须放在构造方法的第一条语句。它们不会相遇。如果在子类的构造方法中显式得调用自己的构造方法，则不会调用父类的构造方法。如果没写，则隐式得会调用父类的无参得构造方法。

                            4：this可以作为实参来使用。但是super不可以。(为什么不可以？)

                                     super只是父类的一个标识，没有实质性的意义，并不牵涉到内存。而this是表示对象的引用，能够代表对象的，指向引用对象的首地址。

         2.4：方法的重写==方法的覆盖==方法的复写

                   不同的人有不同的习惯叫法，然而重写、覆盖、复写都是一个意思，还有方法和函数也是一样的东西。

                   1：什么时候子类的方法会重写父类的方法？当父类的方法的功能无法满足子类的功能时，这个时候会重写。不仅仅是代码重用！

                   2：什么是方法重写？

                            1：方法的声明相同，方法体一般情况下是不同的。

                                     访问权限   返回值类型   方法名(参数列表).

                                     访问权限可以不一样。必须符合一定的规则。后面讲访问权限的时候再说，现在就认为访问权限一样的。子类中重写父类的方法，访问权限必须大于或者等于父类的访问权限。

                                     抛出的异常也有所要求。

                   3：方法的重载跟方法重写的区别

                   重写的前提是继承extends！extend是是扩展的意思，取这样的名字都是有一定的含义的，结合名字的本意更容易理解。

                            1：方法的重载发生在同一个类里。而方法重写发生在父子类里。

                            2：方法的重载是方法名相同，参数列表不一样。而方法重写是方法名和参数列表，返回值类型都必须相同，方法声明要相同，方法体不一样。

                            3：功能上。方法的重写是为了功能的扩展。

                   4：继承的细节

                            1：java中只能单继承，可以多层继承。

                            2：java中为什么不能多继承?  容易产生冲突，假设能多继承，而继承的父类有相同的方法，那该调用那个方法呢？

                            3：什么时候会产生继承关系呢？

                            当类与类之间存在着所属关系时，才具备了继承的前提。a是b中的一种。a继承b。狼是犬科中的一种。所以判断所属关系，可以简单看，如果继承后，被继承的类中的功能，都可以被该子类所具备，那么继承成立。如果不是，不可以继承。

                            4：创建对象是建议创建最子类的对象：这样既可以用父类方法也可用子类方法

3：

         3.1：包和访问权限。

                   3.1.1：包

                            包的作用：解决类名冲突的和类的归类。相似作用的类会放在同一个包里。

                            如何定义包：package  包名;  必须放在文件中的第一条语句（不包括注释）。

                                     命名规范：都是小写。一般都是域名的反向。

                                               www.baidu.com--->com.baidu.entity: 编译以后会自动生成com文件夹，baidu文件夹，entity文件夹。baidu文件夹在com里，entity在baidu里

                            导包 ： import 包名.类名

                   3.1.2：访问权限：private:私有的。默认的(不写就是默认)。protected:受保护的。public:公共的。

                   private   :只能在本类中访问。不可以修饰类。

                   默认的: 同一个包的类可以访问

                   protected: 同一个包的类可以访问，不同包的子类可以访问。不可以修饰类。

                   public:所有的类都可以访问。

                   private < 默认的 < protected <public                              

         3.2：static.:静态

                   3.2.1：当一个类的所有对象的一个成员变量的值都是一样的时候，为了节省内存，可以将这个成员变量设置为static,那么这个变量在内存中只有一份空间，不管创建多少个对象。也可以说达到了共享的目的，所有对象共享这个数据，既然是共享的，那么值改变一次，所有的对象的这个值也就变了。

                   3.2.2：静态成员变量的访问以及加载的顺序。

                            静态成员变量可以用类去访问，也可以用对象去访问，一般的情况下都用类去访问。

                            静态成员是随着类的加载而加载的，这个时候不一定会有对象。它在内存中存在的生命周期是最长的。

                   加载顺序：先分配静态成员变量 ，静态方法 -------创建对象后，再分配非静态成员变量空间-----调用非静态方法时，非静态方法才会进栈。

                   3.2.3：静态方法(先加载)不可以访问非静态成员(后加载)，但是非静态方法可以访问静态成员。

                            当一个方法没有访问这个类的成员或者这个类的非静态成员时，可以将这个方法定义为静态方法。以方便调用。

                   3.2.4：静态代码块：扩展。

                            执行顺序：静态代码块-------构造代码块------构造方法。

                            静态代码块：只会执行一次。

                            构造代码块和构造方法：new一次就执行一次

                            静态代码块的作用？对静态成员进行初始化的。

         3.3：final

                   3.3.1： final:表示最终的。

                   3.3.2：final修饰方法，则表示子类不能重写该方法

                              final修饰成员变量，表示这个变量的值不能再改变，并且必须要显式初始化。非静态final成员可以在构造代码块或者构造方法内初始化，且只能在其一进行初始化，如果是在构造方法中初始化则可以在每个构造函数中进行赋值！静态final成员可以在静态代码块内初始化。由于它的值在后面不能修改，所以很多时候将final和static一起使用，来修饰一个常量。这个常量表示在整个类或者项目中用的比较多，而且都不会修改值，只会用这个常量的值。

                             final修饰类：表示这个类是最终类，不能被继承。

         3.4：抽象类。

         3.6：接口

         3.7：多态

         3.8：设计模式：单例模式，简单工厂模式。

         3.9：内部类。接口回调