黑马程序员Java基础第四章-----面向对象的概念及封装

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一.面向对象

1.面向对象的概念：

          面向对象是与面向过程的相对的，以前我们编写程序：首先想到的就是怎么样去实现需要的功能，然后按照我们的设计好的执行流程，将其变成一行一行的代码。编写程序的过程中，我们的关注点完全在程序的执行流程上，程序是按照我们设计好的步骤在执行，这种思想就是面向过程。面向对象是指，在编程中我们不在关注那些细节的东西，我们直接使用那些具有我们要使用的功能的对象，通过调用这个对象的方法来完成功能。

         举个例子：就拿开冰箱门来说，面向过程的编程方式是先要考虑使用多大的力量，然后判断力量是否足够，门能转多大的角度，冰箱里面的灯打开等。而面向对象是指，我们开冰箱门，然后冰箱对象调用自己的开门方法，就把冰箱门打开了。至于到底是怎么打开的冰箱门，我们可以不用管，因为这是冰箱的内部的实现原理，只有冰箱自己知道。

         从以上例子中我们可以发现，面向对象和面向过程的区别：

         1）面向过程关注的是具体的具体的，清晰的。而面向对象关注的是抽象的，模糊的。

         2）面向过程中的功能都是离散的，没有关系的。而面向对象中的功能都是属于对象的，一个对象可能有很多的功能，不止一个功能。

         3）面向过程的功能内部实现是可见的，而面向对象的功能内部是封装的，不可见得，也更安全。

         4）面向过程一般只能用在小型的程序项目中，而面向对象可以用在大型的项目中。

2.类和对象的概念：

类的概念：类是某一类实物的描述，它只包含这类事物的共有的部分，它是这类事物的公共部分向上抽取出来的。类不代表某一个具体的事物，类是抽象的。类是不存在的，是我们头脑中的想象出来的东西。

对象的概念：对象现实世界中实实在在的事物，是看得见摸得着的，是真实存在的。只有对象的功能才能被调用。

         生活中，我们可以发现：学生张三和李四都会说话，都会走路，都会学习，都会吃饭。他们之间有很多相同的地方，或者很多地方是一样。那么我们该使用什么方式来描述这件事情呢？这个时候我们可以将他们相同的部分提取出来，这就是这一类事物之间的共性。这个共性我们可以使用类来描述，学生就是类下面的各个不同的对象，每个学生对象都有学生类描述的所有的特点，而每个学生又有不同的地方，比方说有的会玩游戏，有的会唱歌，这又是他们的特有的部分，所以每个对象间既有相同的部分又有不同的部分。

3.类的定义

1）.定义类：定义类要用到关键字class（注意class是小写的，大写的Class是类类型，是类向上抽取出来的一个类）

2） 类中的组成部分：成员函数   成员变量    构造函数

       成员函数：是用来实现这一类事物所具有的功能的，又叫成员方法。

       成员变量：是用来描述这一类事物所具有的属性的，就像人有姓名和年龄

       构造函数：用来对类进行初始化操作，初始化学生类对象张三的姓名，年龄等。

3）类的表现形式：

public  class  Student

{

       Student(){}

       privte String name;

       public void eat()

       {

            System..out.println(name);

      }

}

public：声明类的访问权限，类的访问权限有两种：

            public--->公有的权限，最大的访问权限，可以在包外访问到类。   

            默认访问权限--->不下权限就是默认的，在包外访问不到类，只能在包内访问

class：定义类的关键字，所有的类的定义都要加这个关键字（注意不要写成Class，这个类是在java反射中使用的）

Student：类名，给类取的名称。也是一个数据类型，是引用数据类型，实例化的对象在堆内存中

函数Student：构造函数，构造函数的名称和类名一样，没有返回值，可以被权限修饰符：public 公有的  不写是默认权限   protect 受保护的  private私有的（不能在类外new本类的对象，单例设计模式就是要私有化构造函数，但会提供函数来获取这个类的对象）

name：是类中的成员属性名称，权限修饰符：public公有的  private私有的  默认  protected受保护的

eat：是类中的成员方法名称，权限修饰符：public 公有的  private 私有的  默认  protected受保护的

4.对类的总结：

1）访问类权限：

        I.在包外访问另一个包中的类，另一个包中的类必须是public，包外才可以访问到。默认权限（不写修饰符）在包外访问不到类。若在访问方法，方法也必须要是public，不然也访问不到。若是在同一个包中默认权限就可以访问到类和类中的方法。

       II.一个类中的成员的访问权限：

通过上图可知：public的成员拥有最大权限，不管哪里都可以访问到。protected在包内的任何地方都可以访问到，在包外只有子类中可以访问到。默认权限就是包权限。private只能在本类中可以访问到。

2）构造函数：构造函数可以有参数，没有返回值，没有返回值类型。一个类中可以不写构造函数，不写系统会给我们一个默认的空参数的空方法体的构造函数，如：类名(){} ;如果我们定义了构造函数，系统就不会给我们提供默认的构造函数。构造函数可以重载，通常一个类中不止一个构造函数，有很多的重载的形式。

3）对象：对象是类的实例化，是一个由抽象到具体的过程。我们用new来实例化一个类，会在堆内存中开辟对象空间，并把地址赋给栈内存的引用变量。对象的实例化形式：Student s = new Student();当类中有多个构造函数时，系统会根据我们是实例化是传递的参数来判断调用哪个构造函数来实例化对象，初始化对象的成员。

4）成员的调用：在类外，调用成员函数-->对象名.方法名（参数....）  调用成员属性-->对象名.属性名，但也要满足上图中的权限。

                           在类内部，调用成员函数   方法名（参数）   调用成员属性   属性名。

3）类中的关键字

      I.this关键字和this语句：我们知道，一个类通常会有很多的对象，都有相同的属性和方法，在类内部可以直接写方法名（参数）和属性名的形式调用，能够正确的进行区分是因为每个对象内部都有一个默认的this指针，这个this指针可以省略不写，哪个对象调用这个方法或者属性，this就会代表哪个对象。如：Student s = new Student();   s.eat();    eat方法中的name实际上省略了this指针，应该是this.name，此时this代表的是对象s，相当于s.name，当然访问的是s对象的name属性。this语句：this（参数......）；构造函数中出现，只能够出现在第一行，作用是在构造对象时根据参数来调用本类的对应的其他的构造函数构造对象。

     II.super关键字和super语句：super用来调用父类的方法。代表的是父类对象。super语句：super(参数......)是在子类对象构造时会先构造父类对象，此时根据super语句的参数来调用父类对应的构造函数来构造。super语句也是只能在构造函数的第一行，也就是说this和super语句不能共存，只能有其中的一个。当我们没有写this或者super时，java会自动给我们的构造函数加上一个空参数的super语句，此时父类必须有一个空参数的构造函数，没有就会程序报错。

     III.static关键字：

              修饰成员变量，这个成员属性属于类变量，不属于任何对象独有，在类的所有的对象间被共享，一个地方改变了该变量的值，所有的对象访问都受影响。被静态static修饰后，这个变量存储在共享区中。先于对象的存在而存在，在类字节码文件加载进内存中时，该变量就有了，并且多了一种调用方式：类名.属性名，和类的声明周期一样长。可以被静态成员函数访问，也可以被分静态成员函数访问。

             修饰成员函数，这个函数属于类方法，也是先于对象的存在而存在，调用方式：类名.方法名();同时也可以通过对象来调用。静态成员函数只能访问静态成员变量，因为可能此时没有对象，一般承运变量还不存在，所以不能访问非静态成员变量。静态成员函数中没有this指针。

             修饰内部类，static可以修饰内部类，我们后面讲解。

      IV.final关键字：（最终类型）

             修饰变量：该变量是一个常量值不能改变（或者只能被赋值一次）

             修饰函数：该函数不能被覆盖（子类在继承父类时，重写父类函数的功能）

             修饰类：该类不能被继承

             匿名内部类访问局部变量：只可以访问final修饰的局部变量

      V.abstract关键字：（抽象）

             修饰类：该类是一个抽象类，不能new实例化对象      abstract   void show()；

             修饰函数：该函数是一个抽象方法，需要子类来实现该方法

             注意：抽象类中不一定都是抽象方法，可以都是抽象方法，可以部分抽象方法，也可以没有抽象方法。但是有抽象方法的类一定是抽象类，该类上一定要用abstract来声明。一般来说，抽象类的子类都要实现该抽象类的抽象方法，那么这个子类就可以new实例化对象，但是只要有一个方法没有实现，那么该子类还是一个抽象类，同样需要加abstract声明，也不能new实例化对象。实现抽象方法的最简单形式：void show(){}空实现。实现方法的权限一定要大于或者等于父类的该方法的权限，因为要发生覆盖,，小权限不能覆盖大权限的方法。

二.类的特性之一封装

1.封装的概念：将程序的不必要向外暴露的部分私有化，只向外部提供一些公共的访问接口，而隐藏实现细节，外部只可以通过我们暴露的接口来访问内部封装的数据以及特有的方法，而无法知道具体的内部实现的细节就叫做封装。它将类的内部的实现细节隐藏起来，就像封闭装在一个箱子中一样，只能按照暴露接口的说明来使用这个功能，而无法查看其中的细节。

2.封装的好处：1）提高了程序的安全性，外部不能直接访问内部的私有化数据

                        2）将实现和使用分离开了，只要接口不变，接口的实现方法发生改变对用户来说是透明的

                       3）增强了程序的可读性，增强了数据访问的一致性

                       4）将同一类事物的不同方法封装在一起，便于对象方法的统一管理

3.如何封装：封装一般是先将数据私有化，然后对外提供公共的set和get方法来访问这些私有的数据。

实例：定义一个学生类，学生有姓名，年龄，城市属性，有学习，睡觉方法。

class Student{//成员属性，私有封装在内部，外部无法直接访问private String name ;private int age ;private String city ;//空参数的构造函数，有构造函数java不会提供默认构造函数Student(){//默认有个super()语句}//重载的构造函数Student(String name,int age){//默认有个super()语句this.name = name ;this.age = age ;}//完整参数的构造函数Student(String name , int age , String city){//this语句，调用前面一个构造函数，初始化两个参数，第3个自己初始化，有了this没有super语句this(name,age);this.city = city ;}//可以设置对象的属性public void setName(String name){this.name = name ;}//提供给外部的调用访问对象数据的接口public String getName(){return name ;}public int getAge(){return age ;}public void setAge(int age){this.age = age ;}public String getCity(){return city ;}public void setCity(String city){this.city = city ;}//成员方法  name和age都省略了thispublic void study(){System.out.println("我叫："+name+"，我"+age+"岁啦，我在学习.....");}//没有省略thispublic void sleep(){System.out.println("我在睡觉z z  z  z   z，我来自"+this.city);}}

class StudentDemo{public static void main(String[] args){/* 堆内存中的数据都要默认初始化，引用类型的默认值是null， 基本类型：           byte  short  int  char  都为0，但是这几个0的占的字节数不同     char默认是空格字符 float  double 默认是0.0，占的字节数也不同   *///根据参数的个数，调用第3个构造函数初始化，其中前两个参数是调用第二个构造函数初始化的Student s1 = new Student("张三",20,"北京");//调用第二个构造函数初始化，第3个参数为String为引用数据类型，在堆内存中，//先默认初始化，在显示初始化，因为没有显示初始化，所以值就为默认初始化值  nullStudent s2 = new Student("李四",18);//调用无参数的构造函数初始化  第一个默认值是null   第二个基本类型int为0  第3个默认为nullStudent s3 = new Student();//对象调用成员方法，在类的内部成员方法去访问私有的成员变量s1.study();s1.sleep();s2.study();s2.sleep();s3.study();s3.sleep();//设置对象的属性值s1.setAge(36);s2.setCity("深圳");s3.setName("王五");s3.setAge(12);s3.setCity("洛杉矶");//此时，再次输出时，s3属性都有值，是调用对象暴露出来的公共接口来操作类的属性，//因此，我们可以在对象产生后在初始化对象的属性s1.study();s1.sleep();s2.study();s2.sleep();s3.study();s3.sleep();}}

运行结果：