黑马程序员-JAVA SE入门(面向对象)

来源:互联网 发布:mysql数据库编程 编辑:程序博客网 时间:2024/03/29 08:43

---------------------- <atarget="blank">ASP.Net+Android+IO开发S</a><a target="blank">.Net培训</a>、期待与您交流!----------------------

 

面向对象

1 面向对象概念

2 类与对象的关系

3 封装

4 构造函数

5 this关键字

6 static关键字

 

1.面向对象概念

        面向对象就是把多个功能封装到一个对象中,通过调用该对象获取这些功能,称为面向对象。

    面向对象和面向过程的理解:

        面向对象是相对面向过程而言。

       面向对象和面向过程都是一种思想。

       面向过程

              强调的是功能行为。

       面向对象

              将功能封装进对象,强调具备了功能的对象。

              面向对象是基于面向过程的。

       事例:人具有走,吃饭功能等等。这些功能都需要人来完成的,那么就将这些功能封装进人这个对象中,我们只要调用人这个对象,通过人就能使用这些功能。

 

       开发的过程:其实就是不断的创建对象,使用对象,指挥对象做事情。

       设计的过程:其实就是在管理和维护对象之间的关系。

 

       面向对象的特征:封装(encapsulation)、继承(inheritance)和多态(polymorphism)

 

2 .类与对象的关系

       使用计算机语言就是不断的在描述现实生活中的事物。

       java中描述事物通过类的形式体现,类是一组相同属性行为的对象的抽象。

       对象即是该类事物实实在在存在的个体。

       举例:人就是一个类(是把每一个相同属性行为的对象进行抽取)人的属性:姓名,年龄,身高,体重等,人的行为:吃饭,睡觉,说话,,跳等。

       而我们就是对象(是实实在在存在的个体),具体每个人叫什么名字,年龄多大,身高多高,体重多重等,吃饭怎么吃,睡觉怎么睡,说话怎么说等。

       描述任意一类事物就是在描述他的属性和行为。

 

       类的定义:

              生活中描述事物无非就是描述事物的属性行为。如:人有身高,体重等属性,有说话,打球等行为。

              Java中用类class来描述事物也是如此。

              属性:对应类中的成员变量。

              行为:对应类中的成员函数。

              定义类其实在定义类中的成员(成员变量和成员函数)

 

       成员变量和局部变量的区别:

       1.作用范围。

              成员变量:定义在类中,作用于整个类。

              局部变量:只在它所属的局部大括号中有效。比如函数上的参数,函数中的变量,语句中的变量。

              public void function(int x){ //x,y,z都是局部变量。

                     int y = 1;

                     for(int z=1; z<3; x++){

                     }     //当循环结束时,z在内存中释放。当function函数执行完毕,xy在内存中释放。

              }

       2.存储情况。

              成员变量:存储在堆内存中,随着对象的存在而存在。当对象变成垃圾被回收时,该该对象中的成员变量会消失。

              局部变量:存储在栈内存中,当方法被调用,或者语句被执行的时候,才存在。

              当方法运行完毕,或者语句运行完毕时,局部会被自动释放。所以成员变量也称之为实例(对象)变量.

       3.初始化情况。

              成员变量:在堆内存中有默认初始化值。

              局部变量:必须手动初始化后,才可以被使用。

 

       匿名对象:

              所谓的匿名对象,就是创建对象的时候没有给对象起名字就直接使用。

                   使用方式:

                   1)使用方式一:当对对象的方法只调用一次时,可以使用匿名对象来完成,这样写比较简化。

                   如果对一个对象进行多个成员调用,必须给这个对象起个名字

                   2)使用方式二:可以给匿名对象作为实际参数进行传递,从而可以不用在main方法中创建一个变量,提高了编程效率,减少了代码书写。

                  但是这个对象实体在方法结束后,垃圾回收机制会将其作为垃圾回收。而非匿名对象则不同,当不使用了,会在某一时刻被回收,或是随着主函数的结束而被回收。

                   匿名对象常见错误理解:

                   如:

                   1new Car().num = 8; 

                   2 new Car().color = "red";

                   3new Car().run();        //假设有run方法能调用numcolor属性

                   new三次就是三个匿名对象。3:方法打印出来的不是12所定义的属性。因为三者没有关系。属于三个对象了

 

3.封装

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

       好处:将变化隔离,便于使用,提高重用性,提高安全性。

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

 

       1.private :私有,权限修饰符:用于修饰类中的成员(成员变量,成员函数)

              私有只在本类中有效。

              当成员私有后,提高了安全性。但是访问权限降低了。这时可以通过对外提供公有方法的形式对其进行访问。

              好处:可以在方法中对成员变量的访问进行控制。

              注意:私有仅仅是封装的一种体现形式而已。

              常用之一:

                     将成员变量私有化,对外提供对应的setget方法对其进行访问。提高对数据访问的安全性。

 

       2.构造函数:

              构造函数的特点:

                     1.构造方法的方法名必须与类名相同。

                     2.构造方法没有返回类型,也不能定义为void,在方法名前面不声明方法类型。不用写return语句。

                     3.构造方法不能由编程人员调用,而要系统调用。

                     4.一个类可以定义多个构造方法,也就是构造方法可以重载,以参数的个数,类型,或排列顺序区分。

                     5.构造函数细节:如果在定义类时没有定义构造方法,则编译系统会自动插入一个无参数的默认构造器,这个构造器不执行任何代码。

                     6.作用:构造方法的主要作用是完成对象的初始化工作,它能够把定义对象   时的参数传给对象的域。

 

       构造函数和一般函数的区别:

              1.从功能上的区别:

                     构造函数是给对象初始化的。

                     一般函数是因为对象需要满足某种功能定义的。

              2.从执行上的区别:

                     构造函数,是对象创建的时候被执行,不用调用。

                     一般函数是什么时候调用,就什么时候执行,不调用就永远不执行。

 

       构造代码块:

        作用:给对象进行初始化。

        对象一建立就运行,而且优先于构造函数执行。

        和构造函数的区别:

               构造代码块是给所有对象进行统一初始化,而构造函数是给对应的对象初始化。

        构造代码块中定义的是不同对象共性的初始化内容。

        下面就是构造代码块:

        {

               System.out.println("personcode run");

               cry();

        }

 

       3.局部代码块:

              public void method(){

                    int x = 4;

                    System.out.println("x="+x);

               }

              这种写法开发并不常见,但是面试可能会出现,它的作用就是可以限定变量的生命周期.

 

       4.this关键字:

              1.Java关键字this只能用于方法方法体内。

              2.当一个对象创建后,Java虚拟机(JVM)就会给这个对象分配一个引用自身的指针,这个指针的名字就是this

              3.this只能在类中的非静态方法中使用,静态方法和静态的代码块中绝对不能出现this,并且this只和特定的对象关联,而不和类关联,同一个类的不同对象有不同的this

              简言之,哪个对象调用this所在的函数,this就代表哪个对象。

 

       this关键字的应用:

              第一、函数参数或者函数中的局部变量和成员变量同名的情况下,成员变量被屏蔽,此时要访问成员变量则需要用“this.成员变量名的方式来引用成员变量。当然,在没有同名的情况下,可以直接用成员变量的名字,而不用this,用了也不为错.

              第二、在函数中,需要引用该函数所属类的当前对象时候,直接用this//比较两个人的年龄。

              第三、注意,如果我们想在一个构造函数中对另一个构造函数进行调用的时候,不能在其构造函数中直接类名(参数)这样调用,而是通过this调用。         

              另一个构造方法,用法是this(参数列表),这个仅仅在类的构造方法中,别的地方不能这么用。这叫this语句。

              其实这些用法总结都是从对“this是指向对象本身的一个指针这句话的更深入的理解而来的,死记不然容易忘记而且容易搞错,要理解!

 

       5.static关键字:

              1static关键字:static 是一个修饰符,用于修饰成员(成员变量、成员方法)。

              2、当成员被静态修饰后,就多了一种调用方式,除了可以被对象调用外,还可以直接被类名调用。格式:类名.静态成员。

              3static特点:

                     <1>随着类的加载而加载。 也就是说:静态会随着类的消失而消失,说明它生命周期最长。

                     <2>优先于对象存在  。明确一点:静态先存在对象后存在。

                     <3>被所有对象共享。

                     <4>可以被类名所调用。

              4、实例变量和类变量的区别:

                     <1>存在位置:

                             静态变量随着类的加载而存在于方法区中。

                             实例变量随着对象的建立而存在于堆内存中。

                     <2>生命周期:

                                    静态变量的生命周期最长,随着类的消失而消失。

                           实例变量的生命周期随着对象的消失而消失。

                     <3>所属不同:

                           静态变量也称之为类变量,所属于整个类,被整个类所共享。

                           实例变量是对象的特有数据,所属于对象。

              5、静态使用注意事项:

                     <1>静态方法只能访问静态成员。

                           非静态方法既可以访问静态也可以访问非静态。

                     <2>静态方法中不可以定义this,super关键字。

                                  因为静态优先于对象存在。所以静态方法中不可以出现this

                     <3>主函数是静态的。

              6、静态的利弊端:          

                     利处 <1>对对象的共享数据尽享单独空间的存储,节省空间,没有必要每一个对象都存储一份。

                                      <2>可以直接被类名调用。

                     弊端 <1>生命周期过长。

                                      <2> 访问出现局限性。(静态虽好,但只能访问静态)

 

       6.主函数:

              1、定义:是一个特殊的函数,作为程序入口,可以被jvm调用。

              2、涵义:

                     public:代表着该函数的访问权限是最大的。

                    static: 代表主函数随着类的加载就已经存在了。

                    void: 主函数没有具体的返回值。

                    main:不是关键字,但是是一个特殊的单词,可以被jvm识别。

                    (String[] args):函数的参数,参数类型是一个数组,该数组的元素是字符串。字符串类型数组。(arguments)

              3、主函数是固定格式的,被jvm识别。jvm在调用主函数时,传入的是new String[0];这里的0代表的是0个元素。

 

       什么时候使用静态?

              要从两方面下手:因为静态修饰的内容有成员变量和函数。

       什么时候定义静态变量(类变量)呢?

              当对象中出现共享数据时,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。

       什么时候定义静态函数呢?

              当功能内部没有访问到非静态数据(对象的特有数据),那么该功能可以定义成静态的。

 

       静态的应用:工具类

       文档注释:

       javadoc -d(指定文档存储的位置如果写.代表当前目录,也可以定义一个文件夹)

       -author(提取作者内容)

       -version(提取版本内容)

       javadoc -d指定的文件目录 -author -versionArrayTool.java

 

       <1>每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,以便复用。

       <2>将方法都静态后,可以方便于使用,但是该类还是可以被其他程序建立对象。

             为了更严谨,强制让该类不能建立对象,可以通过将构造函数私有化完成(private)。

 

       静态代码块:

        格式:

        static{

               静态代码块中的执行语句。

        }

        特点:随着类的加载而执行,只执行一次,并优先于主函数。用于给类进行初始化的。

 

       局部代码块,构造代码块,静态代码块:

              1、局部代码块:

                     作用:控制变量的生命周期。

                     在程序中,当我们已经使用完 x后,并且在接下来的代码中,不会再用到x,那么就没必要让x在内存中占用空间了,这用情况下,可以             使用局部代码块,将x及其所设计到的区域封装为局部代码块,他们在程序执行中顺序不变,只是在执行完成后消失。

              2、构造代码块:

                     作用:它可以给所有对象进行初始化。

                     存在于:类中。

                     当类中的构造方法以重载的形式存在时,并且有共同成员变量或共同的方法时,可以通过构造代码块对其进行初始化;这样可以减少代             码的重复!

              3、静态代码块:

                     作用:给类进行初始化。

                     当类中的方法都被静态了化,并且构造方法被private了,这是我们不能,在将这个类实例化,然而又想让类增加一些属性,就可以使用             静态代码块。

 

       静态代码块和构造代码块:

              相同点:都是在JVM加载类时且在构造方法执行之前执行,在类中都可以定义多个, 一般在代码块中对一些static变量进行赋值。

              不同点:静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。静态代码块只在第一次new执行一次,之后不再   执行,而非静态代码块在每new一次就执行一次。

非静态代码块可在普通方法中定义(不过作用不大);而静态代码块不行。

 

---------------------- <atarget="blank">ASP.Net+Android+IOS开发</a><a target="blank">.Net培训</a>、期待与您交流!----------------------