JAVA基础－面向对象之封装

1、面向对象概念

1.1、理解面向对象

（1）面向对象是相对面向过程而言的。

（2）面向对象和面向过程都是一种思想。面向对象是将功能封装进对象，强调具备了功能的对象。面向过程强调的是功能行为。

（3）面向对象是基于面向过程的。

1.2、面向对象的特点

面向对象有三个特征：封闭、继承、多态。

2、类与对象的关系

（1）类就是对现实生活中事物的描述。

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

（3）在Java中，描述就是用class关键字定义的类，具体对象就是对应Java在堆内存中用new关键字建立的实体，描述事物其实就是在描述的属性和行为，属性对应类中的变量，行为对应类中的方法，定义类就是在定义事物的属性和行为，属性和行为共同成为类中的成员。

示例：

Class  Car

{

    String  color;  //描述颜色

    void  run(){}   //描述行为

}

说明：定义了一个Car类，类中定义了color属性（成员变量）和run行为（成员方法）。

有了类，可用new关键字产生该类的一个实体：

Car  c=new  Car();

说明：c是一个Car一个实体对象，是一个类类型变量，而类类型变量指向对象。

产生对象后，可以使用对象访问对象的成员，访问格式为：对象名.对象成员，如c.color访问Car的color属性。

3、成员变量与局部变量

（1）成员变量作用于整个类中，且在内存中成员变量因为对象的存在才存在于堆内存中。

（2）局部变量作用于函数中或者语句中，存在栈内存中。

4、匿名对象

匿名对象是对象的简化形式。

匿名对象的使用方式：

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

（2）匿名对象可以将对象作为实际参数进行传递。

5、封装

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

5.1、封装的好处

（1）将变化隔离

（2）便于使用

（3）提高重用性

（4）提高安全性

5.2、封装原则

（1）将不需要对外提供的内容都隐藏起来。

（2）把属性都隐藏起来，提供公共方法对其访问。

5.3、private

private表示私有。一种权限修饰符，用于修饰类中的成员（成员变量、成员函数），私有只在本类中有效。被private修饰的成员不可以被对象直接访问，如果私有成员需要在本类以外被访问，就需要在本类中提供访问该成员的方法。

示例：

class  Person

{

         private  int  age;

         public  void  setAge(int  a) //定义set方法对私有成员age进行修改

         {

                   Age=a;

         }

}

说明：声明了一个Person类，类中age属性被私有，并提供setAge方法对属性age进行操作，当通过Person  p=new Person()声明一个对象p时，不能用p.age直接访问，只能通过p对象调用setAge方法访问age。

注意：封装不代表私有，私有仅仅是封装的一种表现形式。

5.4、构造函数

    特点：函数名与类名相同，不用定义返回值类型，不可以写return语句。

    作用：给对象进行初始化，因为对象一建立就会调用与之对应的构造函数。

注意：多个构造函数是以重载的形式存在的。当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数，这个默认的构造函数的权限与所属类一致辞。当在类中自定义了构造函数后，默认的构造函数就没有了。

格式：类名（参数列表）{}

示例：

class  Person

{

         private  String  name;

         Person(String  n) //定义构造函数

         {

                   name=n;

         }

}

说明：声明了一个Person类，类中定义了一个成员变量name和一个构造函数Person(String  n)，此时若要建立一个Person类的实例对象，只能Person  p=new Person(“n”)，而不能Person  p=new  Person()，因为此时已没有默认的不带参数列表的构造函数。

构造函数与一般函数的区别：

（1）在写法上，构造函数与一般函数有不同。

（2）在运行上，构造函数在对象一建立时就运行，给对象初始化。而一般函数是需要对象调用才执行，是给对象添加对象具备的功能。

（3）一个对象建立，构造函数中运行一次，而一般方法可以被对象调用多次。

什么时候定义构造函数：

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

5.5、构造代码块

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

和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。构造代码块中定义的是不同对象共性的初始化内容。

格式：{ 对象初始化语句 }。

示例：

class  Person

{

         private  String  name;

//定义构造代码块

         {

                   System.out.println(“Peson  code  run”);

         }

         Person(String  n)

         {

                   name=n;

         }

}

说明：在Person中定义了一个构造代码块，当用new建立一个对象时，程序首先会调用该构造代码块，即会打印Person code  run。

5.6、this关键字

作用：当类中局部变量和成员同名时this用于区分局部变量和成员变量。this就代表本类的对象，代表它所在函数所属对象的引用，即哪个对象在调用this所在的函数，this就代表哪个对象。

格式：this.成员

示例：

class  Person

{

         private  String  name;

         Person(String  name)

         {

                   This.name=name;

         }

}

说明：在类Person中定义了私有成员变量name，定义了构造函数Person(String  name)，Person函数中有局部变量与成员变量name同名，此时为了区别构造函数中的局部变量和类中成员变量，在调用成员变量name时用this.name调用。

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

示例：

class  Person

{

         private  String  name;

         private  int  age;

         Person(String  name,int  age)

         {

                   this.name=name;

                   this.age=age;

         }

         public  boolean  compareAge(Person  p)

         {

                   retrun  this.age==p.age;

         }

}

说明：定义了一个类Person，类有定义了一个比较年龄的功能函数compareAge，当建立两个对象p1和p2，当用p1调用compareAge方法p1.compareAge(p2)时，this.age就代表p1对象的age，this就代表了p1。

this语句：只用于构造函数之间进行互相调用，因为一般函数不能直接调用构造函数。this语句只能是在构造函数中的第一个语句。因为初始化要先执行。

格式：this（函数元素，…）

示例：

class  Person

{

         private  String  name;

         private  int  age;

         Person(String  name)

         {

                   this.name=name;

         }

         Person(String  name,int  age)

         {

                   this(name);//this语句相当于调用构造函数Person(name);

                   this.age=age;

         }

}

说明：定义了一个类Person，类中定义了两个构造函数Person(String  name)和Person(String  name,int  age)，当在Person(String  name,int  age)要调用Person(String  name)时，用this语句。

5.7、static关键字

static关键字也是一种修饰符，用于修饰成员（成员变量和成员函数）。

被修饰后的成员具备以下特点：

－随着类的加载而加载。

－优先于对象存在。

－被所有对象所共享。

－可以直接被类名调用。

注意：

－静态方法只能访问静态成员。非静态即可以访问静态也可以访问非静态。

－静态方法中不可以写this，super关键字，因为静态优先于对象存在。

－主函数是静态的。

示例：

class  Person

{

         private  String  name;

         static  String  country=”CN”; //定义静态成员

         Person(String  name)

         {

                   this.name=name;

         }

}

说明：定义了一个类Person，类中定义了一个静态变量country，此时静态变量country会随着类的加载而加载，属于所有Person类对象的共享数据，且可以被类名直接调用，格式为：Person.country。

静态成员在内存中存储在方法区中，静态成员变量也被称为类变量，类变量与成员变量的区别：

（1）存放位置：类变量随着类的加载而存在于方法区中，成员变量随着对象的建立而存在于堆内存中。

（2）生命周期：类变量生命周期最长，随着类的消失而消失，成员变量生命周期随着对象的消失而消失。

静态的利弊：

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

弊：生命周期过长。访问出现局限性（只能访问静态）。

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

什么时候定义静态函数：当功能内部没有访问到非静态数据（对象的特有数据）时，那么该功能可以定义成静态的。

静态的应用：每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，形成一个工具类，当其他应用程序需要用其中的功能时，找到这个工具类就可以了，方便复用。

示例：

classArrayTool  //定义一个操作数组的工具类

{

         //定义获取数组中最大值的方法

         public static int getMax(int[]arr) 

         {

                   int max=0;

                   for(int i=1;i<arr.length-1;i++)

                   {

                            if(arr[i]>arr[max])

                                     max=i;

                   }

                   return arr[max];

         }

          //定义获取数组中最小值的方法

         public static int getMin(int[] arr)

         {

                   int min=0;

                   for(inti=1;i<arr.length-1;i++)

                   {

                            if(arr[i]<arr[min])

                                     min=i;

                   }

                   return arr[min];

         }

          //定义将数据进行选择排序的方法

         public static void selectSort(int[]arr)

         {

                   for(inti=0;i<arr.length-1;i++)

                   {

                            for(intj=i+1;j<arr.length;j++)

                            {

                                     if(arr[i]>arr[j])

                                     {

                                               inttemp=arr[i];

                                               arr[i]=arr[j];

                                               arr[j]=temp;

                                     }

                            }

                   }

         }

          //定义将数组进行冒泡排序的方法

         public static void bubbleSort(int[]arr)

         {

                   for(inti=0;i<arr.length-1;i++)

                   {

                            for(intj=0;j<arr.length-i-1;j++)

                            {

                                     if(arr[j]>arr[j+1])

                                     {

                                               inttemp=arr[j];

                                               arr[j]=arr[j+1];

                                               arr[j+1]=temp;

                                     }

                            }

                   }

         }

          //定义打印数组中元素的方法

         public static void arrayPrint(int[]arr)

         {

                   System.out.print("[");

                   for(inti=0;i<arr.length;i++)

                   {

                            if(i!=arr.length-1)

                                     System.out.print(arr[i]+",");

                            else

                                     System.out.print(arr[i]+"]");

                           

                   }

         }

        

}

 

public classArrayDemo5

{

         public static void main(String[] args)

         {

                  

         }

}

说明：定义了一个操作数组的工具类，类中定义了对一个数组取最值、排序和打印的方法，这些方法都定义成静态的，当在其他程序中需要用到该类中的方法去操作数组时，可以直接通过这个工具类的类名去调用相应的方法，而不需要在程序中定义相应的方法，增强了代码的复用性。同时，因为该类是工具类，不需要被实例化，所以可以在该类中将其构造函数私有化，强制该类不能建立对象。

5.8、main函数

主函数是一个特殊的函数，作为程序的入口，可以被JVM调用。

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

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

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

main：不是关键字，但是是一个特殊的单词，可以被JVM识别。

（String[] args）：函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组。

主函数是固定格式的：JVM识别。格式：public  static  void  main(String[] args){}。

JVM在调用主函数时，默认传入的是new String[0]。

5.9、静态代码块

作用：随着类的加载而执行，只执行一次。用于给类进行初始化。

格式：static{静态代码块中的执行语句}。

5.10、对象初始化过程：

    （1）当用new建立一个对象时，因为new用到了相应类的class文件，所以会先找到相应的class文件并加载到内存中。

    （2）执行该类中的static代码块，如果有的话，对该进行初始华。

    （3）在堆内存中开辟空间，分配内存地址。

    （4）在堆内存中建立对象的特有属性，并进行默认初始化。

    （5）对属性进行显式初始化。

    （6）对对象进行构造代码块初始化。

    （7）对对象进行对应的构造函数初始化。

  （8）将内存地址赋给栈内存中的对象变量。

5.11、单例设计模式

单例设计模式指解决一个类在内存中只存在一个对象。

如何保证类的对象唯一：

（1）为了避免其他程序过多建立该对象，先禁止其他程序建立该对象。（将构造函数私有化）。

（2）还为了让其他程序可以访问到该类对象，只好要本类中，自定义一个对象。（在类中创建一个本类对象）。

（3）为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。（提供一个方法可以获取到该对象）。

单例设计模式的两种方式：

（1）饿汉式：先初始化对象，当类一进内存时就已经创建好了对象。

示例：

class  Single

{

                   private  static  Single  s=new  Single(); //创建本类对象并将其私有

                   private  Single(){}

                   public  static  Single  getInstance() //定义获取本类对象的方法

                   {

                            return  s;

                   }

}

（2）懒汉式：对象是在方法被调用时才初始化，也叫做对象的延时加载。即当类进内存时，对象还没有存在，只有调用了方法时才建立对象。

示例：

class  Single

{

                   private  static  Single  s=null; //创建本类对象引用并指向null

                   private  Single(){}

                   public  static  Single  getInstance()//定义获取本类实例的方法

                   {

                            if(s==null) //通过双重判断解决效率的问题

                            {

                                      synchronized(Single.class) //通过同步代码块解决同步的问题

                                      {

                                               if(s==null)

                                                        s=new Single();

                                      }

                            }

                            return  s;

                   }

}

说明：由于当多个程序在调用getInstance方法时可能会发生问题，所以需要进行双重判断，并加同步。

原则：定义单例，建议使用饿汉式。