面向对象—

---------------------- 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