你的位置:首页 > Java教程

[Java教程]面向对象第三天


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:内部类。接口回调