04.面向对象（一）【概念】【封装】

 

1. 面向对象的概念

  面向对象，其实是相对于面向过程思想而言的。面向过程思想强调的是过程（动作），学校里学的C语言就是面向过程语言。而面向对象的思想，强调的是对象（实体），典型的语言有：C++，JAVA，C#等。

   举个例子：开汽车。

    运用面向过程思想来分析：（1）启动汽车。 （2）驾驶汽车。  （3）停止汽车。

    运用面向对象思想来分析：（1）汽车启动。（2）汽车行进。  （3）汽车停止。

 

2.面向对象的特点

  （1）面向对象是一种常见的思想，符合人们的思考习惯。

  （2）面向对象使复杂的问题简单化。

  （3）面向对象，让在过程中的执行者，变成对象中的指挥者。

 

看看下面的例子，方便理解这三个特点。

  比如说我们要买电脑。很多人是自己解决，查资料，看主板，对照参数，然后再自己砍价，最后买回家。
但是，面向对象，你可以找个专业的人去帮你买，他负责买电脑中的一切事宜，你是指挥者。

 

3.面向对象的三个特征：封装，继承，多态（后面会详细分别介绍这三个特征）。

 

4.编程时如何运用面向对象的思想？

      当解决问题时，首先关心的是涉及到哪些对象，找到能解决问题的对象。如果没有符合
  要求功能的对象，没对象就造对象。

 

 功能定义在哪个对象，有个基本规则：
    哪个对象最清楚这个功能。比如说你去开门，人和门是对象，开门这个功能，怎么开门，
  门最清楚，所以把开这个功能定义在门这个对象里。

 

5.类和对象之间的关系

 类：对事物的描述。就是java语言对现实生活中的事物进行描述时，就是通过类的形式来体现的。

     而描述事物通常关注两个方面：一是属性；二是行为。

     只要明确事物的属性和行为并且定义在类中即可。

 对象：某一类事物实实在在的个体。简单说，就是一类事物的实例。

      在java中是通过new 来创建对象的。

  如下面的例子，就是在主函数中通过new创建了一个Person类的对象。

  

public class Person {String name;int age;public Person(){}public static void main(String[] args){//新建Person对象Person p = new Person();}}

6.成员变量和局部变量的区别

  定义类其实就是在定义类中的成员。

  两者的区别：（1）成员变量定义在类中，在整个类中都有效。

                                局部变量定义在函数，语句及局部代码块中，只在所属的作用域中有效。

                      （2）成员变量存在于堆内存的对象中。

                               局部变量存在于栈内存的方法中。

                     （3）成员变量随着对象的创建而存在，随着对象的消失而消失。

                              局部变量随着所属区域的执行而存在，随着区域的结束而释放。

                     （4）成员变量都有默认初始化值。

                             局部变量没有默认初始化值。

 

 小细节：成员变量和局部变量如果同名，栈中有值的话，程序会直接打印栈中的值，而不会再跑到堆内存中查找。就近原则。

   看看下面的例子可以明白。

    

class Car{int num = 4;String color;void run(){//int num = 10;//打印结果为10。局部变量与成员变量同名，程序会优先执行局部代码的变量。System.out.println(num+"..."+color);}}

 

7.匿名对象

  匿名对象：没有名字的对象。
   

   newCar();//匿名对象。其实就是定义对象的简写格式。

   例子：
      Car c = new Car();
      c.run();

    简写格式为：
     newCar().run();
  

  匿名对象的好处： 
   1.当对象方法仅进行一次调用时，就可以简化成匿名对象。
     newCar().num = 5;//创建第一个对象，并赋值num = 5
     new Car().color = "green";//创建第二个对象，并赋值color = "green"
     new Car().run();//创建第三个对象，并调用功能，结果为0...null
   
   2.匿名对象可以作为实际参数进行传递。
    Car c1 = new Car();
    show(c1);

    简写格式为：
         show(new Car());

 

8.封装（Encapsulation）

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

 

  封装的好处：
    将变化隔离。
    便于使用。
    提高重用性。
    提高安全性。

 

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

 

9.封装-private的小知识点

   private:私有，是一个权限修饰符，用于修饰成员。
   私有的内容只在本类中有效，其他类中访问不到。

   不过可以对外提供访问的方法。

    如： private String name;

       对外提供的方法：

           public voidsetName(String name)

           {

              this.name= name;

           }

           publicString getName()

           {

              returnname;

          } 

                   

   注意：私有仅仅是封装的一种体现而已。
         私有就是封装，但是封装，并不一定私有。尽管不私有，但是可以限制本类内容不被访问。

 

10.封装-构造函数

  构造函数：构建创建对象时调用的函数。作用：给对象进行初始化。
       

   创建对象都必须通过构造函数进行初始化。
 
  如果一个类中没有定义初始化函数，那么该类中会有一个默认的空参数构造函数。
  如果在类中定义了指定的构造函数，那么默认的构造函数就不存在了。

 

   一般函数和构造函数有什么区别呢？
     构造函数：对象创建后，就会调用与之对应的构造函数，对对象进行初始化。
     一般函数：对象创建后，需要函数的功能时才调用。

     构造函数：对象创建时，会调用且只调用一次。
     一般函数：对象创建时，可以多次调用。

 

什么时候定义构造函数呢?
   在描述事物时，该事物一存在就具备一些内容，这些内容都定义在构造函数中。

   构造函数可以有多个，用于对不同对象进行针对性的初始化。
   

  多个构造函数在类中是以重载的形式来体现的。

  关于构造函数的细节：

   （1）set方法虽然和构造函数功能一样，都可以修改变量的值，但是这个一定要有。用于修改变量的值。

    （2）构造函数可以调用一般函数，但是一般函数不能调用初始化函数。

   （3）构造函数前不要加void等，加上之后会变成一般函数，初始化时会提示“找不到符号。”

 

11.封装-主函数

   格式为：public static voidmain(String[] args){}

 

   主函数特殊之处：
         1.格式是固定的
         2.被JVM所识别和调用。

public：权限必须是最大的。
static:不需要对象的，直接用主函数所属类名调用即可。
void：主函数没有具体的返回值。
main：函数名，不是关键字，只是一个jvm识别的固定的名字而已。
String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

 

12.封装-静态修饰符static

  (1) static的特点：
           ①static是一个修饰符，用于修饰成员。
            ②static修饰的成员被所有的对象共享。
           ③static优先于对象存在，因为static的成员随着类的加载就已经存在了。
            ④static修饰的成员多了一种调用方式，可以直接被类名所调用。类名.静态成员。
            ⑤static修饰的是共享数据，对象中存储的是特有数据。

 

  (2)静态使用的注意事项：
          ①静态方法只能访问静态成员。（非静态可以访问静态，又可以访问非静态）
           ②静态方法中不可以使用this或super关键字。
          ③主函数是静态的。

 

  (3) 成员变量与静态变量的区别：

        ①两个成员变量的生命周期不同。
            成员变量随着对象的创建而存在，随着对象被回收而释放。
            静态变量随着类的加载而存在，随着类的消失而消失。
  
        ②调用方式不同。
            成员变量只能被对象调用。
           静态变量可以被对象调用，也可以被类名调用。
  
         ③别名不同。
           成员变量也可称为实例变量。
           静态变量称为类变量。
  
       ④数据存储位置不同。
           成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
           静态变量存储在方法区（的静态区），也叫对象的共享数据。

 

   (4)静态什么时候用？
        1.静态变量
             当分析对象中所具备的成员变量的值都是相同的。
             只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
             如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中。

        2.静态函数
              函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。
             简单点说，从源代码看，该功能是否访问到非静态成员，如果需要，则该功能时非静态的。
              如果不需要，该功能就是静态的。也可以定义成非静态的，但是非静态需要被对象调用，而仅创建调用非静态的。
            没有访问特有数据的方法，该对象的创建没有意义。

  （5）静态代码块和构造代码块

      静态代码块
         随着类的加载而执行，而且只执行一次。

      作用：
          用于给类初始化。

     构造代码块
          可以给所有对象进行初始化。

 

     局部代码块，构造代码块，静态代码块的执行顺序：
         静态代码块>构造代码块（有创建对象才执行）>局部代码块。

   （6）当成员变量和局部变量重名时，可以用关键字this来区分。

        this：代表对象，代表当前对象。
         this就是所在函数所属对象的引用。
        简单的说，哪个对象调用了this所在的函数，this就代表哪个对象。

         this也可以用于在构造函数中调用其他构造函数。
      注意：只能定义在构造函数中的第一行。因为初始化动作要先执行。

     构造函数和构造函数之间如何访问？
     一个类中的成员要被执行，必须要有对象调用。
      就是使用this来调用构造函数（构造函数区分是通过参数列表来区分）。
     

   例子：

  

class Person{private String name;private int age;Person(){name = "baby";age = 1;System.out.println("person run");}Person(String name){this();this.name = name;}Person(String name,int age){this.name = name;this.age = age;}public void speak(){System.out.println(this.name+":"+this.age);}/*判断是否是同龄人。*/public boolean compare(Person p){/*if(this.age==p.age)return true;elsereturn false;*/return this.age==p.age;}}class ThisDemo {public static void main(String[] args) {Person p1 = new Person("aa",30);//Person p2 = new Person("zz",12);p2.compare(p1);//new Person();//Person p = new Person("旺财",30);//p.speak();//Person p1 = new Person("小强");//p1.speak();}}