Java基础-->面向对象与类之概述

第一节   概述

一、面向对象的概述：

         java是一种面向对象的编程语言，也就是说对象是这种语言的基础，没有对象了，就没有了java。任何功能都是通过对象来实现的，就是将功能封装进对象，让对象去调用这些功能。这种思想是将数据作为第一位，而方法（功能或者说是算法）作为其次。我个人认为，这是对数据的一种优化，安全性更高，操作起数据来一更方便。

         那么将这种思想提升到一种境界就是：万物皆对象。

1、对面向对象的理解：

1）面向对象是相对面向过程而言的，且基于面向过程的。

2）面向对象是一种思想。

3）面向对象将功能封装进对象中，强调了具备功能的对象，主体是对象，将过程简化

4）在实际开发中，以对象为核心，先明确好对象，在实现具体功能，或者可是使用已有的对象。

5）面向对象的三个特征：封装性，继承性，多态性。

2、举例说明：

人是一个对象，人有吃饭，睡觉以及学习等等的行为（可称为功能），那么就是将吃饭、睡觉以及学习等功能封装进人这个的事物中，让人去执行这些功能，是人在调用这些方法，从而简化了过程。

第二节   类与对象

一、类与对象概述

1、类（class）：可以理解为是构造对象的一个蓝图或者模板，是抽象的概念；反过来说，对象是以类为模型创造的具体实例，是对类的一种具体化、形象化。

类：对生活中事物的描述

对象：对类的具体实现，是实实在在存在的实体。

2、例如：汽车的设计

类：指的是汽车的设计图纸

对象：指实际生产出来的汽车。

示例：

二、成员变量与局部变量：

在类中的不同位置定义变量，作用范围是不同的，下面简单区分一下，两种变量的不同：

1）作用范围：

   a.成员变量：作用于整个类中

   b.局部变量：作用于函数中，或者作用于语句块中。

2）在内存中的位置：

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

   b.局部变量：在栈内存中，随着函数的结束而消亡

3）初始化方式：

   a.成员变量：随着类的初始化而初始化，在堆内存中被加载，有默认值，可直接参与运算

   b.局部变量：随着方法的加载而加载进栈内存中，无初始化值，必须被初始化才能参与运算

上面汽车的例子中，a、b和c是局部变量，定义在了方法中，存在于栈内存中；而name、color、nums和speed都是成员变量，存在于堆内存中，随着类的加载而加载。

三、匿名对象

1、简述：所谓匿名对象，就是创建的对象没有名字，直接使用。

2、使用方式：

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

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

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

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

第二节  封装

一、概述

1、定义：封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

2、好处：

a.将变化隔离

b.便于使用

c.提高重用性

d.提高安全性

3、原则：

a.将不需要对外提供的内容隐藏起来

b.把属性都隐藏，提供公共方法对其访问

4、说明：

a.私有仅仅是封装的一种表现形式，如包也是一种封装形式

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

二、private 关键字

1、private是一个权限修饰符

2、用于修饰成员（成员变量和成员函数）

3、被私有化的成员只在本类中有效。

4、常用之一：将成员变量私有化，对外提供对应的set和get 方法对其进行访问，提高了对数据访问的安全性。

5、当把类中的所有构造函数私有化后，代表着该类是不能创建对象的，因为对象不能进行初始化操作的。

封装步骤：

示例：

三、成员访问权限比较

                                                                         权限大小

成员修饰符     public       protected       default(默认)       private

同一个类中       OK               OK                    OK                     OK

同一个包中       OK               OK                    OK                     NO

子类访问           OK               OK                    NO                     NO

不同包中           OK               NO                    NO                     NO

四、public类与源文件名

一个编译单元（个人理解为执行main函数所调用到的所有文件）中只能有一个public类，且这个类的文件名必须要和其类名相同，包括大小写也必须一样。

原因：

1、一个编译单元只能有一个public类的原因：

第一、public的意思是所有类都能访问，包括包以外的类。public是作为这个编译单元的公开接口存在的。

第二、java程序的入口是main方法，所以被定为public的这个类一定是main方法的类，且这个类的名称要和文件名一直，因为虚拟机是要开始找main方法这个入口的。

第三、你可以根据需要，添加任意辅助功能的public权限的类，但是如果这个编译单元（注意是编译单元）里面有两个或以上public类的话，那么编译器就会报错。

建议：

第一、不要在一个源文件中写多个类。在标准的java代码编写时，无论代码量是多少，最好一个源文件只有一个类或接口（即使是接口也要如此），因为java是面向对象的语言，每个类都是抽象的结果，所以每个类要单独写在一个源文件里。

第二、只要要有一个是public类，虽然可以在编译单元中没有public类，即没有公开的接口，可在同一个包中访问，但是这样就将这个包都封闭了，是没意义的。如果没public，就可以随意给文件起名，可以不和类名相同。

2、被public修饰的类与文件名必须同名的原因：

第一、java是被编译执行的，它在运行时并不是将你写的所有类都先加载一遍的，而是当遇到import或使用到了其他类的时候，才会去在文件目录中找相应的class文件的。

第二、对于一个public类。上面也说了，是可以被项目中的任何一个类引用的，只需通过import导入即可。既然是作为虚拟机入口的main函数要用public修饰而成为一个公共接口，那么将类名和文件名一一对应就可以方便虚拟机在相应的路径（包名）中找到相关的信息；但是你如果不这么做，虚拟机很难去找，开销也会跟着增大的。

 

简单总结：

public作为一个公共接口（此接口非interface这个接口），修饰作为虚拟机入口的main函数，就是为了方便虚拟机找到相应的类，从而节省开销。

第三节   对象与函数

一、main函数：

我们刚开始接触java的时候就是用到了main函数，那么主函数是什么呢？在此分别对主函数的各个关键字及修饰符进行简单说明：

public static void main(String [] args){....}

1、主函数：是一个特殊的函数，作为程序的入口，可以被JVM识别并调用，它的格式是固定的。

2、主函数的定义：

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

2）static  ：代表着主函数随着类的加载就已经存在了，一边执行函数中的代码。

3）void    ：主函数没有具体的返回值，只是作为执行程序的入口。

4）main  ：不是关键字，和其他的函数名类似，只不过别定义为一个特殊的单词，可以被JVM识别。

(String [] args))：函数的参数，参数类型是一个String类数组，元素为字符串。字符串类类型是数组，args是一个变量名，是约定俗成的，早期被写成arguments；如果改写成其他名称也是可以的。

3、注意：

可以重载主函数，但是虚拟机只识别固定格式的主函数，即 public static void main(String [] args){....}。

二、构造函数

先看一个简单的小程序

其中的public Dog(String a,int b ){}就是对这个类Dog的构造函数

1、特点：

a.函数名与类名相同

b.不用定义返回类型，括号中的参数可以没有，也可以有多个。

c.不可以写return语句

d.构造函数总是伴随着new操作一起被调用。

e.细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数，即：类名(){}。但当类中自定义了构造函数后，默认的构造函数就不存在了。也就是说，每一个类中一定含有一个构造函数。

2、作用：给对象进行初始化

3、注意：

a.默认构造函数的特点

b.多个构造函数时以重载形式存在的。

3、构造函数与一般函数的区别：运行上不同

构造函数时在对象一建立就运行，是给对象初始化的。且一个对象建立后，构造函数只运行一次。

一般函数时对象调用才执行，是给对象添加对象具备的功能的。一般函数可以被该对象多次调用。

注：

     一般函数是不能调用构造函数的，因为一般函数中不能定义this，而构造函数中可能存在this。

4、何时定义构造函数：

当分析事物时，该事物存在具备一些特性或行为，那么将这些内容定义在构造函数中。也就是说，一类事物一出现就应该存在的特性，这就需要构造函数对其进行初始化。

5、构造代码块：

如上面的小程序，其中打印的“我来工作了”这个语句块就是构造代码块。它和构造函数作用类似，只不过仅用一对花括号括起来即可。

1）作用：给对象进行初始化，对象一建立就运行，且优于构造函数执行，即在构造函数前加载。

2）与构造函数区别：

构造代码块是给所有对象进行统一初始化，是所有对象的共性初始化方式内容。如任何孩子出生都要哭几声。

构造函数是给对应的对象初始化，不同的对象有各自的特性，需要选择不同的构造函数初始化。

     <<<<<------------------------------------------------------------------------------------------------------------------->>>>>

      补充：

      this关键字：

      1、this：表面上，是用于区分局部变量和成员变量同名的情况。即this代表着当前对象的引用。

      2、this的用法：

      a.用于区分同名变量的情况。当局部已经定义了变量，当需要找成员中的变量，且变量名相同时，为了区分局部变量和成员变量的相同变量名，可以使用this加以区分。

      b.用于构造函数间的调用。

      3、特点：

      1）this代表了本类的对象，即代表了它所在函数所属对象的引用，也就是说，哪个对象调用这个函数，this就代表哪个对象。

      2）一般情况下，this都是被省略的，需要使用的时候才需加上。

       如上面构造函数中的this的使用。

      4、this应用：

            当定义类中的功能时，该函数内部要用到调用该函数的对象时，这时用this来表示调用这个函数的对象。

            只要本类功能内部使用了本类对象，都用this表示。

      5、在构造函数中的应用：

           this语句：用于构造函数之间的互相引用。且只能放在构造函数的第一行，否则编译失败。

       原因：初始化的动作要先执行，因为自身的特性要先具备；如果初始化中还有初始化，要限制性更细节的操作，然后再执行自己所需求的初始化。

      注意：不允许两个构造函数间相互调用this语句，否则会出现死循环。

               一般函数中不能定义this语句。

示例：

     <<<<<------------------------------------------------------------------------------------------------------------------->>>>>

三、static之静态函数

我们在学习java的最初就接触到了static这个修饰main方法的修饰符，那么static在java中有什么特点和作用呢？下面是对static的总结的几点：

一）总体来说static有这么几个特点：

  1、随着类的加载而加载，在类中生命周期最长

  2、优先于对象而存在

  3、可以被所有对象共享

  4、可以直接被类名调用

二）static的用法：

  1、修饰成员：包括成员变量和成员方法

当成员被static修饰后，就多了一种调用方式，即可以被对象和类名调用

需要注意的一点：static绝对不能修饰局部变量。为什么呢？

<strong>局部变量的作用域就是它所在的方法或代码块中，而static的变量刚是定义在类中方法体外，是作为整个类共同使用的，它从类加载开始就存在，而局部变量在它所在的方法或代码块结束后就要被回收的。所以是不能修饰局部变量的</strong>

2、静态的应用：

当每个应用程序都有共同之处，可将其封装，提高其复用性。

需要注意的是：

a.对象时用于封装数据的；

b.对数据的操作方法，若没用到方法中特有的数据，则无需创建对象而占用多余的内存。

3、静态代码块

特点：a.随着类的加载而执行，且优先于主函数；b.只执行一次，类再创建对象，则不再执行，已经存在于内存中。

4、静态是用注意事项：

1）静态方法只能访问静态成员，非静态方法既能访问静态也可以访问非静态

2）静态方法中不可定义this，super等关键字，因为静态优先于对象存在，所以静态方法中不可以出现this

3）主函数是静态的。

5、静态有利有弊：

好处：对对象的共享数据惊醒单独空间的存储，节省空进。没必要每个对象中都要存储一份，可以直接被类名调用

弊端：生命周期过长。访问出现局限性，因为静态只能访问静态。

举例：