面向对象—

---------------------- android培训、java培训、期待与您交流！ ----------------------

面向对象的第一部分

面向对象的思想：现在人们思考习惯的一种思想。

什么是对象：简单的理解，人就是一个对象，电脑也是一个对象，在程序中、类就是对象。（老师说的，一切开皆为对象）

面向对象的三大特征：封装，继承，多态。

描述一个事物，就两个个特征：属性、行为（方法）。

匿名对象：匿名对象只能被调用一次，是没有名字的对象。

例：

new Car().method();new 类名().方法名();

可以将匿名对象作为实例参数来传递

例：

show(new Car());

实例：

class Car(){public void method(){System.out.println(".............");}}class Main(){public static void main(String[] ages){show(new Car())}public static void show(Car c){c.method();}}

成员变量和局部变量的区别：

1，成员变量直接定义在类中。

     局部变量定义在方法中，参数上，语句中。

2，成员变量在这个类中有效。

     局部变量吸在自己所属的大括号有效，大括号结束，局部变量失去作用域。

3，成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。

     局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。

构造函数：用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。

特点：

     1，该函数的名称和所在类的名称相同。

     2，不需要定义返回值类型。    

     3，该函数没有具体的返回值。

     实例： 

class Person(){Person(){}}

记住：所有对象创建时，都需要初始化才可以使用。

注意事项：一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数，为了方便该类创建对象，完成初始化。如果在类中自定义了构造函数，那么默认的构造函数就没有了。

一个类中，可以有多个构造函数，因为它们的构造函数名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造函数，它们的存在是以重载体现的。

     实例： 

 class Person(){Person(){}Person(String str){}Person(int a){}Person(String str, int a){}}

什么时候使用构造函数：

分析事物时，发现具体事物一出现，就具备了一些特征，那就将这些特征定义到构造函数内。

构造函数和一般函数有什么区别：

1，两个函数定义格式不同。

2，构造函数是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次。一般函数，是对象创建后，需要调用才执行，可以被调用多次。

构造代码块和构造函数有什么区别：

构造代码块：是给所有的对象进行初始化，也就是说，所有的对象都会调用一个代码块。只要对象一建立，就会调用这个代码块。

构造函数：是给与之对应的对象进行初始化，它具有针对性。

构造代码块实例： 

制作帮助文档：

public class MianXiangDiuXiang_SixDay {     private MianXiangDiuXiang_SixDay() {     }     /* 返回最大值，此方法为遍历判断脚标值、得出脚标 */     /**     * 获取一个整形数组中的最大值     * @param arr 接收一个int类形的数组     * @return 会返回一个数组中的最大值     * */     public static int getMax(int[] arr) {          int max = 0;          for (int i = 1; i < arr.length; i++) {               if (arr[max] < arr[i]) {                    max = i;               }          }          return arr[max];     }     /* 返回最小值，此方法为遍历判断脚标的值、得出数值 */     /**     * 获取一个整形数组中的最小值     * @param arr 接收一个int类形的数组     * @return 会返回一个数组中的最小值     * */     public static int getMin(int[] arr) {          int min = arr[0];          for (int i = 1; i < arr.length; i++) {               if (min > arr[i]) {                    min = arr[i];               }          }          return min;     }     /* 选择排序，把最小的值放到前面 */     /**     * 用于给数组进行选择排序     * @param arr 接收一个int类形的数组     * */     public static void selectSort(int[] arr) {          for (int i = 0; i < arr.length - 1; i++) {               for (int j = i + 1; j < arr.length; j++) {                    if (arr[i] > arr[j]) {                         swap(arr, i, j);                    }               }          }     }     /* 冒泡排序，把最大的值放到后面 */     /**     * 用于给数组进行冒泡排序     * @param arr 接收一个int类形的数组     * */     public static void bubbleSort(int[] arr) {          for (int i = 0; i < arr.length - 1; i++) {               for (int j = 0; j < arr.length - i - 1; j++) {                    if (arr[j] > arr[j + 1]) {                         swap(arr, j, j + 1);                    }               }          }     }          /* 将两个值交换 */     /**     * 用于给数组中的两个值进行交换     * @param arr 接收一个int类形的数组，和两个int类型的整数     * */     private static void swap(int[] arr,int i, int j) {          int temp = arr[i];          arr[i] = arr[j];          arr[j] = temp;               }          /* 把数组打印在控制台上 */     /**     * 用于给数组进行打印,打印形式：[elemet1,elemet2,elemet3......]     * @param arr 接收一个int类形的数组     * */     public static void printArray(int[] arr) {          System.out.print("[");          for (int i = 0; i < arr.length; i++) {               if (i < arr.length - 1) {                    System.out.print(arr[i]+"..");               }else {                    System.out.println(arr[i] + "]");               }          }     }}

制作API文档：

方法1.选择工程，在菜单Project->Genarate Javadoc 

方法2.选择工程，鼠标右键菜单Export ，选择Java 下面的Javadoc ，点”next” 按钮 

方法3.选择工程，在菜单File->Export ，选择Java 下面的Javadoc ，点”next” 按钮 然后

可以选择生成到Javadoc 文档中的内容( 一般选public 或protected) ，选存放目录( 默认即可) ，next下一步 ,此页全默认即可，再next 下一步 。

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

好处：将变化隔离，便于使用，提高复用性，安全性。

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

单例设计模式：（定义单例设计建议使用饿汉式）

解决的问题：保证一个类在内存中的对象唯一性。

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读取到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

如何保证对象唯一性:

思想：1，不让其他程序创建该类对象。

          2，在本类中创建一个本类对象。

          3，对外提供方法，让其他程序获取这个对象。

步骤：

1，因为创建对象都需要构造函数初始化，只要被本类中的构造函数私有化，其他程序就无法再创建该类对象。

2，就在类中创建一个本类的对象。

3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）

代码体现：

1，私有化构造函数。

2，创建私有并静态的本类对象。

3，定义公有并静态的方法，返回该对象。

有两种方法：

第一种方法：饿汉式：（开发中使用此方法）

class Single(){     private Single(){}                                   //私有化构造函数。     private static Single s = new Single();     //创建私有并静态的本类对象。     public static Single getInstance(){          //定义公有并静态的方法，返回该对象。          return s;     }}

第二种方法：懒汉式：

class Single(){     private Single(){}                                   //私有化构造函数。     private static Single s = null;                   //创建私有并静态的空对象。     public static Single getInstance(){          //定义公有并静态的方法，返回该对象。          if(s == null)               s = new Single();                        //已创建的对象为本类对象。          return s;     }}

---------------------- android培训、java培训、期待与您交流！ ----------------------

详细请查看：http://edu.csdn.net/heima