黑马程序员——Java面向对象

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------

自学Java第三天笔记。本人是根据毕向东老师的JavaSE视频学习的。




 Java面向对象



一.面向对象。


1,特点:
               1)、将复杂的事情简单化。
               2)、面向对象将以前的过程中的执行者,变成了指挥者。
               3)、面向对象这种思想是符合现在人们思考习惯的一种思想。

2,面向对象的三个特征:封装,继承,多态。



二.类与对象。


1.类:
         就是对现实生活中事物的描述。java中描述事物通过类的形式体现,类是具体事物的抽象。生活当中描述事物无非就是描述事物的属性和行为。如:人的身高,体重等属              性;讲话跑步等行为。

2.java则是用类class来描述对象的属性和行为。定义类其实就是在定义类中的成员(成员变量和成员函数):
                                                                                                                                                                                              属性:对应类中的成员变量。
                                                                                                                                                                                              行为:对应类中的成员函数。

3.成员变量和局部变量的区别:
                                                   1)、成员变量直接定义在类中;局部变量定义在方法中,参数上,语句中。
                                                   2)、成员变量在这个类中有效;局部变量只在自己所属的大括号内有效,大括号结束,局部变量失去作用域。
                                                   3)、成员变量存在于堆内存中,随着对象的产生而存在,消失而消失;局部变量存在于栈内存中,随着所属区域的运行而存在,结束而释放。   

4.对象:
            就是这类事物,实实在在存在的个体。对象是将函数等一些内容进行了封装。

5.匿名对象使用场景:
                                   1)、当对方法只进行一次调用的时候,可以使用匿名对象。new student().方法;
                                   2)、当对象对成员进行多次调用时,不能使用匿名对象。必须给对象起名字。例如:Student a=new Stufent();



三.封装(面向对象特征之一)。


1.含义:
           是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。

2.好处:
           1)、将变化隔离。
           2)、便于使用。
           3)、提高重用性。
           4)、提高安全性。

3.封装原则:
                   1)、将不需要对外提供的内容都隐藏起来。
                   2)、把属性都隐藏,提供公共方法对其访问。

4.private(私有,封装的表现形式之一):
                                                                       1)、private关键字:权限修饰符;用于修饰类中的成员(成员变量,成员函数);私有只在本类中有效。
                                                                       2)、常用之一:将成员变量私有化,对外提供对应的set,get方法对其进行访问。提高对数据访问的安全性。



四.构造函数。


1.特点:
           1)、函数名与类名相同。
           2)、不用定义返回值类型。
           3)、不可以写return语句。

2.作用:
            用于给对象进行初始化,是给与之对应的对象进行初始化,它具有针对性,函数中的一种。

3.注意事项:
                   1)、一个类在定义时,如果没有定义过构造函数,那么该类中会自动生成一个空参数的构造函数,为了方便该类创建对象,完成初始化。如果在类中自定义了构造                                函数,那么默认的构造函数就没有了。
                   2)、一个类中,可以有多个构造函数,因为它们的函数名称都相同,所以只能通过参数列表来区分。所以,一个类中如果出现多个构造函数。它们的存在是以重载                               体现的。

4.什么时候定义构造函数:
                                           当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中。

5.构造代码块:
                       1)、定义不同对象共性初始化。
                       2)、作用:给对象进行初始化。
                       3)、对象一建立就运行,而且优先于构造函数执行。
                       4)、和构造函数的区别:构造代码块是给所有对象进行统一初始化。而构造函数是给对应的对象初始化。



五.this关键字。


1.特点:
            this代表其所在函数所属对象的引用。简单说,哪个对象调用了this所在的函数,this就代表哪个对象。

2.this应用:
                  1)、当在函数内需要用到调用该函数的对象时,就用this。(用于区别同名变量的情况,局部变量和成员变量)。
                  2)、this还可以用于构造函数间的调用。调用格式:this(实际参数);

3.注意:
            用this调用构造函数,必须定义在构造函数的第一行。因为构造函数是用于初始化的,所以初始化动作一定要先执行。否则编译失败。



六.static关键字。


1.应用:
           1)、用于修饰成员(成员变量和成员函数)。
           2)、当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外,还可以直接被类名调用。格式:类名.静态成员。

2.特点:
           1)、随着类的加载而加载。
           2)、优先于对象存在。
           3)、被所有对象所共享。
           4)、可以直接被类名调用。

3.实例变量(成员变量)和类变量(静态成员变量)的区别:
                                                                                                       1)、存放位置。类变量随着类的加载而存在于方法区中;实例变量随着对象的建立而存在于堆内存中。
                                                                                                       2)、生命周期。类变量生命周期最长,随着类的消失而消失;实例变量生命周期随着对象的消失而消失。

4.静态使用注意事项:
                                   1)、静态方法只能访问静态成员。
                                   2)、静态方法中不可以定义this,super关键字。因为静态优先于对象存在。所以静态方法中不可以出现this。

5.静态有利有弊:
                            利处:对对象共享数据进行单独空间的存储,节省空间。没有必要每一个对象中都存储一份。可以直接被类名调用。
                            弊端:生命周期过长。访问出现局限性。(静态虽好,只能访问静态)。

6.什么时候使用静态(从两方面下手: 因为静态修饰的内容有成员变量和函数):
                                                                                                                                            1)、什么时候定义静态变量呢?
                                                                                                                                                   当对象中出现共享数据时,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于                                                                                                                                                    堆内存中。
                                                                                                                                            2)、什么时候定义静态函数呢?
                                                                                                                                                    当功能内部没有访问到非静态数据(对象的特有数据),那么该功能可以定义成静态的。

7.静态代码块:
              1)、格式:
                       static
                       {
                            静态代码块中的执行语句;
                       }
              2)、特点:随着类加载而执行,只执行一次。并且优先于主函数。用于给类进行初始化。


8.静态代码块、构造代码块、构造函数同时存在时的执行顺序:
                                                                                                             静态代码块,构造代码块,构造函数。

9.生成Java帮助文档:
                        1)、命令格式:javadoc –d 文件夹名 –auther –version *.java
                        2)、格式:
                        /** 
                        *类描述
                        *@author 作者名
                        *@version 版本号
                        */
                        /**
                        *方法描述
                        *@param  参数描述
                        *@return  返回值描述
                        */



七.对象的初始化过程:定义一个新对象都做了哪些事情?

                     1、把类名.class文件加载到内存中。
                     2、执行该类中的static代码块,如果有得话,给该类进行初始化。
                     3、在堆内存中开辟空间,分配内存地址。
                     4、在堆内存中建立对象的特有属性。并进行默认初始化。 
                     5、对属性进行显示初始化。
                     6、对对象进行构造代码块初始化。
                     7、对对象进行对应构造函数初始化。
                     8、将内存地址赋给栈内存中的对象名变量。



八.单例设计模式。


1.设计模式:解决问题最行之有效的思想。java中有23种设计模式。

2.单例设计模式:
                   1)、定义:解决一个类在内存中只存在一个对象。
                   2)、如何保证对象唯一性呢?
                    思想:
                        1,不让其他程序创建该类对象。
                        2,在本类中创建一个本类对象。
                        3,对外提供方法,让其他程序获取这个对象。


                    步骤:
                        1,因为创建对象都需要构造函数初始化,只要将本类中的构造函数私有化,其他程序就无法再创建该类对象。
                        2,就在类中创建一个本类的对象。
                        3,定义一个方法,返回该对象,让其他程序可以通过方法就得到本类对象。


                    代码体现:
                            1,私有化构造函数。
                            2,创建私有并静态的本类对象。
                            3,定义公有并静态的方法,返回该对象。


                    饿汉式:(先初始化对象)
                           class Single{
                            private Single(){} //私有化构造函数。
                                    private static Single s = new Single(); //创建私有并静态的本类对象。
                            public static Single getInstance(){ //定义公有并静态的方法,返回该对象。
                          return s;
                                      }
                              }
                    懒汉式:延迟加载方式。(对象是方法被调用时才初始化)
                           class Single2{
                            private Single2(){}
                                    private static Single2 s = null;
                            public static Single2 getInstance(){
                          if(s==null)
                      s = new Single2();
                          return s;
                              }
                              }
                    注意:建立单例,建议使用饿汉式。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值