面向对象（1）

 

 

//面向对象的理解

         面向过程和面向对象是两个思考方式的思想，所强调的角度不一样，导致最后的思想不一样，面向过程强调的是动作，面向对象强调的是对象，将所有功能封装到一个对象上来。

         我的理解是，面对对象，是为了更长期来看，可以有更多的功能的加入和升级，而面向过程仅仅就此功能而言，没有长远的观念和前瞻性。

         拿开门来说，

         面向对象的表达方式是，门，开；门，关；而面向过程的表达就是开门，关门。

         面向对象之后，可以把很多系统性的功能联系到一起封装到一个对象中使用，而面向过程就是把功能都独立开来，没有考虑到功能之间的联系以及功能和客体之间的不同的关系，但是功能确实一样的，面向对象是针对于客体一个整体而言的，他必须要考虑所有的因素，而面向过程只考虑了这一个动作的过程。这就是我说的分与合的思想。

         就是一种分工与大局的想法。

         管理能力也是一种功能。

 

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

面向对象是一种符合人们思考习惯的思想，不需要知道和了解过程，只需要看到结果。调用了对象的某个功能去执行就可以，至于具体怎么执行不需要管，只需要管结果。

面向对象的特点：是一种思想；可以将复杂的事情简单化；将程序员从执行者转换成了指挥者。

 

//一种境界：

一切皆对象，万物皆对象。所看所想的事情或者概念都可以是一个对象，即表示万物都可以用计算机语言描述一下。

 

//面向对象落实到程序当中是怎么样的呢？

我们写程序的时候，我们不是先定义功能，而是先面向对象，我们操作的是对象，需要什么功能就先写进去，封装起来，下次要用到这个功能就先找这个对象。我们在开发的过程中，不要先去写代码，我们要先看java当中是否已经提供了相对应的对象，功能怎么实现的，跟我没关系，我只需要拿到需求的结果即可。如果没有这个对象，我们自己先造一个对象，把功能放在里面去，这样都可以用，不要去追求一个功能的过程了，而是直接面对对象并且先造对象再说。因此以后写程序的过程首先考虑的就是面向对象，有对象直接拿来，没有就造一个对象。

 

//用人开门用面向对象的方式体现一下

人开门：名称提炼法。把这句话里面的名词提炼出来封装成对象。并考虑把动作定在哪个名词里面是最合适的。

         人

         ｛

                   开门（门）

                   ｛

                            门.开（）；

                    ｝

          ｝ 

         门

         ｛

                   开（）｛操作门轴等｝

          ｝

 

//面向对象有三个特征：封装，继承，多态。

 

以后的开发其实就是在找对象使用，没有对象，就创建一个对象。

总结就是找对象，建对象，使用对象，并维护对象之间的关系。这就是面向对象的特点。

 

//以后写程序的时候要养成一个习惯，想要实现某一个功能就去先找一个对象去，没有就建立一个对象，要建立一个对象然后把功能封装在里面去，我可以用别人也可以用，提高功能的复用性，只要找到对象就可以了。对象其实就是多个功能的封装。

 

//类和对象的关系

类就是对现实生活中事物的一种描述的方式。

对象就是这类事物实实在在存在的个体。

 

现实生活中的对象，就是对象；想要描述，就要提取对象中共性内容，对具体的抽象，就是类。对象都是放在内存中用new建立的实体。

 

凡事数据很多，都要用实体进行存储，就像数组一样。凡是存储多个数据的，我们都称为实体，都放在堆内存当中。

 

//需求：描述汽车（类，图纸）

描述事物一般就描述属性和行为（功能）两部分。

可以用类来描述，class car，加一个有意义的名称。

//属性就是对应类中的变量，行为对应的就是类中的函数（方法）。

其实定义类，就是在描述事物，就是定义属性和行为。

属性和行为共同成为类中的成员（成员变量成员方法）

//需求：生产汽车（汽车，对象）

生产汽车，就是在java中通过new操作符来完成，其实就是在堆内存中产生一个实体。

就是通过上面类描述的图纸（类）产生的一个对象。

Car c =new Car（具备了上面类的特点）；

//c就是一个类类型的变量。记住类类型变量指向对象。类类型对象肯定要指向该类所产生的实体。

 

默认初始化值，显示初始化值。

字符串的默认初始化值为null空值。

 

对象里封装了很多东西，当定义好之后，就可以指挥对象做事情了

 

//需求：将已有车的颜色（红色）改为蓝色，就需要指挥该对象做事情，在java中的指挥方式就是：“对象.对象成员”。就是格式。

其目的就是为了操作的对象和内容都要明确才可以操作，如

c．color=“blue” 这是基本的调用关系，可以认为是重新赋值。

凡是new就是在内存中产生一个新对象。

 

多个引用指向了同一个对象，要明白。

 

汽车具体完整代码：

 

需求：描述汽车（颜色，轮胎数等）

class Car

｛

         描述颜色

         Stringcolor =”红色”；

         描述轮胎数

         intnum=4；

         运行行为

         voidrun()

         {

                   System.out.print(color+”…”+num);

         }

｝

 

需求：生产汽车

 

Class Cardemo

{

         publicstatic void main()

         {

                   生产汽车，在java中通过new操作符完成，就是再堆内存里产生一个实体

                   Carc= new Car（）；

         }

}

 

 

主函数的功能就是保证一个类的独立运行。如果一个类不需要独立运行是可以不需要写主函数的。

只要建立这个类的对象，随时都可以使用类里面的功能。

并不是多个类每个类都需要运行，我们只需要建议一个主函数就可以，在这个主函数里面建立每个类的对象，调用里面的东西就可以执行了，所以主函数只是一个入口，用于调用别人的。

 

成员变量与局部变量的特点不同在于作用的范围和在内存中的位置不一样。

成员变量作用于整个类中，而局部变量作用于函数或者语句中。

成员变量在堆内存中，因为对象的存在，才在内存中存在。

而局部变量仅存在于栈内存中。因此局部变量用完马上就完，而成员变量是不会完的，除非没有再被引用。

并且成员变量作用的范围非常的大，整个类的范围，（是图纸上的属性和功能。）

成员变量都是有初始化值的,是可以参与运算的,而局部变量必须要初始化才可以参与运算

 

 

//匿名对象：

         是对象的简化形式；有自己的应用场景和弊端。

         carc=new car（）；c.num=5;

         可以直接写成 newcar().num=5;

 

匿名对象必须只能对功能进行定义才有意义，但是对属性进行定义没有任何意义，因为匿名对象所在语句一结束，他所定义的东西就没效了。

 

匿名对象使用方式一：当对对象的方式只调用一次时，可以用匿名对象来完成，这样写比较简化，如果对一个对象进行多个成员调用，必须给这个对象起个名字。

 

凡是简化了的，肯定是有局限性的。

 

匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。

 

主函数会在栈内存的底部加载。

 

强引用，弱引用，软引用，虚引用。

 

//封装。

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

在使用对象时，我们没有必要知道对象内部是如何进行完成功能操作的，只需要指挥对象去做，知道结果就可以了。

 

函数就是java系统中最小的封装体。类也是一个封装体。还有包这个封装体。

 

框架是一个集成性相当好的工具，他可以帮你实现一些组件的开发，把框架直接拿来用就可以了，框架是由几百几千个类组成的。怎么写的，我们没有必要知道。

用框架不需要知道原理，但是作为学员学习的时候是要了解的。

 

//怎么进行封装。

privite:关键字，私有，权限修饰符；用于修饰类中的成员（成员变量，成员函数）

注意：该变量的作用范围只对本类有效。

将age私有化后，类以外即使建立了对象也不能直接访问。但是人应该有年龄，就需要在person类中提供对应访问age的方式。

 

一个变量只有两种操作方式，就是设置初始值或者获取值。

一般一个方法的属性的提供的值一般有两种方法，一个set一个get.凡是set开头的属性,一般都是没有返回值类型.

 

封装不是私有,私有仅仅值封装的一种表现形式.

私有只是最小权限,我只要权限不在你的访问权限就可以封装了.

 

之所以对外提供访问方式,就因为可以在访问方式中加入逻辑判断等语句,对访问的数据进行操作,提高代码的健壮性.

 

通常在开发程序时,就要养成习惯,通常情况下属性都要隐藏起来,隐藏的最低权限就是private.在类中隐藏.

 

//构造函数

         也是一种函数。但和之前函数是有很大不同的。首先在写法上就有很大不同。函数名和类名是一样的，其格式是固定的。void是一种返回值类型，是没有具体的返回值结果的情况。这里是不用定义返回值，和void是不一样的。是没有return语句的，而且系统也不会给你自动加的，是不可能有return语句的。

 

一般情况下，有了一个类以后，想使用该类，就要创建该类对象。然后调用该类的功能，输入我们创造对象中的值就可以了。

 

在别的类中，对象一建立就会调用与之对应的构造函数。

        

构造函数，对象一建立就会调用与之对用的构造函数，

构造函数的作用，可以用于给对象进行初始化。

在堆内存产生对象时，对象就需要初始化动作。

现实生活中很多事物他一出现就具备一些基本的特性，出来一些行为（功能）。

构造函数的小细节：

当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数

函数名（）（），方便于该类进行初始化，否则对象是建立不出来的。

如果没有办法初始化，对象是无法建立出来的，这是不符合逻辑的。

当在该类中自定义了构造函数后，默认的构造函数就没有了。

在建立对象后，就一定要有初始化的动作，即必须要有对应的构造函数。因为任何新事物的出现都肯定是会有一些特定的功能和属性不管是默认的还是重新定义的，这个是必须有的。

所以就需要在一个类中把这些初始化的功能和属性有定义，如果不定义就表示是默认的初始化。这就是构造函数的意义所在。

所以从另一个角度可以认为，对象是一个程序先有的东西即对象，我们再去给他进行定义一些功能和属性。不然就没有意义了，这就是面向对象的核心所在。在有了对象之后我们可以去调用各种功能和属性了，这就是类里面的函数还有一些变量的内容了，不仅仅只有功能函数的。

 

不能进行初始化的对象是不能建立成功的。

 

一个类中可以有多个构造函数，因为有些对象在初始化时的结果可能会是不一样。

 

一个类可以产生很多对象，而这些对象都可以去对应不同的初始化方式。

 

构造函数和一般函数的特点：

1、  在写法上有不同，函数名要和类名一直。不用定义返回值类型，不可以写return语句。

2、  在运行上也有不同，构造函数是在一建立就运行，给对象初始化。而一般方法是对象调用才执行，是给对象添加具备的功能。一个对象一建立，构造函数只运行一次，而一般方法可以被该对象调用多次。

方法只有被对象调用才会执行，不调用就不执行。

 

什么时候定义构造函数呢？

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

构造函数如果需要未知内容参与运算，就定义参数，不需要就不定义。

 

//构造代码块

在开发一般不会有，但在笔试题中常有。

作用，给对象进行初始化，对象一建立，就运行，而且优先于构造函数执行。

和构造函数的区别：

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

构造代码块定义的是所有的对象共性的初始化内容。其实它也是一种抽取方式。

我们通常用抽取的方式把同样的内容拿出来进行功能化以供反复使用。

 

构造函数是是可以用private修饰的，因为private是修饰成员的，而构造函数就是成员。

 

变量名起的没有意义，阅读性非常差。

 

//this 关键字

看上去，是用于区分局部变量和成员变量同名情况。

this为什么可以解决这个问题呢？

this到底代表的是什么呢？

 

this：代表的就是本类的对象。到底代表哪一个呢？

         this代码他所在函数所属对象的引用。简单的说，哪个对象在调用this所在的函数，this就代表哪个对象。在描述时，预先给对象留一个位置。。

 

在一个类里面，成员之间互相调用时，其实都是对象在完成的。所以this是在用对象在区分，表示到底运行的是哪一个对象中的成员。在本类中通过直接调用this成员完成。

 

//this的应用，当定义类中功能时，该函数内部要用到该函数的对象时，这是用this来表示这个对象。但凡本类功能内部使用到了本类对象，都用this表示。

 

this不过是一个对象的引用。指向了某一个对象。

 

//this 一个小知识点   构造函数中的调用。

 

构造函数间不能运用一般函数的引用，而应该用this（）的格式

内部语言，this语句：用于构造函数之间进行互相调用。构造函数间只能用this，不能用被调用的构造函数名， this永远代表的是一个对象。

 

注意事项：this语句只能用于构造函数的第一行。其实他的意思就是初始化动作要先执行完，再去执行自己的初始化。不能把初始化动作放在再次赋值的下面。

 

在函数中不可以出现死循环的调用。

 

一般函数是不能调用构造函数的，因为this语句是不能用于一般函数之间的。

 

 

 

属性功能  数据。