黑马程序员_面向对象1

1、什么是面向对象

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

如何描述？

对于事物描述通常只关注两方面，一个是属性，一个是行为。

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

对象：其实就是该类事物实实在在存在的个体。

类与对象之间的关系：

类：事物的描述；    对象：该类事物的实例。在java中通过new来创建的。

通过举例来说明，如：描述小汽车

分析：

（1），属性；轮胎数；颜色。

（2），行为；运行。

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

成员：成员变量<-->属性，成员函数<-->行为。

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

（1），

成员变量定义在类中，整个类中都可以访问。

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

（2），

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

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

（3），

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

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

（4），

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

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

2、对象的使用

当我们创建对象之后可以使用点语法来访问对象的属性和方法。例如：

Person p = new Person();

p.name = "张三"; // 访问属性(成员变量)

p.age = 20;

p.speak(); // 访问方法

3、匿名对象

 涵义：

我们可以不定义变量引用对象，使用new关键字创建对象后直接使用，这样的对象没有名字，所以叫匿名对象。

匿名对象因为没有任何引用到达，在使用一次之后即成为垃圾。

通常我们需要使用一个对象且只使用一次的时候，就可以使用匿名对象。比如将对象作为一个参数传递给另外一个函数。

简而言之，匿名对象就是没有名字的对象。

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

Car c = new Car();

c.run();

new Car().run();

当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。如下代码所示：

new Car().num = 5;

new Car().color = "green";

new Car().run();

匿名对象作为实际参数进行传递。如下代码所示：

//Car c1 = new Car();

//show(c1);

show(new Car());

4、封装

（1）什么是封装

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

（2）怎么封装

将所有属性隐藏，提供公有方法对其访问。

将不需要对外提供的方法隐藏。

（3）封装的优点

提高安全性：在访问对象的属性时候通过方法实现，在方法中可以进行校验。隐藏不必要提供的方法避免错误的调用。

简化编程：使用者无需关心对象内部具体实现细节，只要根据对象功能调用指定方法。

封装的使用：private

在一般的封装方式中，选择private作为封装的一种常用方式。

private:私有，是一个权限修饰符。用于修饰成员。

私有的内容只在本类中有效。

注意：私有仅仅是封装的一种体现而已。

如下代码体现：

class Person

{

    private /*私有*/int age;

    public void setAge(int a)//setXxx getXxx

    {

          age = a;

    }

    public int getAge()

    {

      return age;

    }

/*

    public void haha(int a)

    {

         if(a>0 && a<130)

         {

               age = a;

               speak();

         }

        else

        System.out.println("错误的数据");

     }

*/

     void speak()

     {

           System.out.println("age="+age);

      }

}

class  PersonDemo

{

       public static void main(String[] args) 

       {

             Person p = new Person();

             //p.age = -20;

             p.haha(-20);

             //p.speak();

       }

       public static void selectSort(int[] arr){}

       private static void swap(int[] arr,int a,int b){}

}

5、构造函数

（1）涵义

函数名和类名相同。

没有返回值类型。注意：没有返回值类型不等同于void，void也是一种返回值类型。不能使用return关键字返回任何值。

在使用new关键字创建对象之后自动调用。

（2）构造函数的调用

构造函数在new关键字创建对象时调用。

构造函数可以在该类其他构造函数的第一个语句使用this关键字调用。

构造函数的代码体现，如下所示：

Class Person

{

       Private String name;

       Private int age;

       //定义一个Person类的构造函数。

       Person()//构造函数，而且是空参数的。

       {

            name = "baby";

            age = 1;

            System.out.println("person run");

       }

        //如果有的孩子一出生就有名字。

       Person(String n)

       {

              name = n;

       }

       Public void setName(String n)

       {

              name = n;

       }

       Person(String n,int a)

       {

              name = n;

              age = a;

       }

       Public void speak()

       {

              System.out.println(name+":"+age);

       }

}

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

创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

一般函数：对象创建后，需要函数功能时才调用。

构造函数：对象创建时，会调用只调用一次。

一般函数：对象创建后，可以被调用多次。

什么时候定义构造函数呢？

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

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

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

细节：

(1)构造函数如果完成了set功能。set方法是否需要。

(2)一般函数不能直接调用构造函数。

(3)构造函数如果前面加了void就变成了一般函数。

(4)构造函数中是有return语句的。

6、this关键字

this关键字除了在构造函数中调用其他构造函数以外，还可以当做一个引用使用。其用于方法中，哪个对象调用该方法，this就引用哪个对象。例如：

方法中局部变量和成员变量重名，我们想调用成员变量时就可以使用this.变量名形式访问成员变量。

在方法中要将调用该方法的对象作为参数传递给另一个方法时，可以将this作为实参传给该方法。

在内部类中访问外部类的成员时，需要使用外部类名.this.成员名形式访问。

如下代码体现：

Class  Person

{

        String name;//成员变量，实例变量

        Static String country = "CN";//静态变量。类变量

        Public void show()

        {

              System.out.println(Person.country+":"+this.name);

        }

}

/*

static的特点：

(1)static是一个修饰符，用于修饰成员。

(2)static修饰的成员被所有的对象所共享。

(3)static优先于对象存在，因为static的成员随着类的加载就已经存在了。

(4)static修饰的成员多了一种调用方式，就可以直接被类名所调用。类名.静态成员。

(5)static修饰的数据是共享数据，对象中的存储的是特有数据。

成员变量和静态变量的区别

(1)两个变量的生命周期不同。

成员变量随着对象的创建而存在，随着对象的被回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

(2)调用方式不同。

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

(3)别名不同。

成员变量也称为实例变量。

静态变量称为类变量。

(4)数据存储位置不同。

成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.

静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

静态使用的注意事项：

(1)静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)

(2)静态方法中不可以使用this或者super关键字。

(3)主函数是静态的。*/

Class static Demo 

{

         Int num = 4;

         Public static void main(String[] args) 

         {

              //Person  p = new Person();

              //p.name = "小强";

              //p.show();

              //System.out.println(p.country);

              //System.out.println(Person.country);

              //Person.show();

                new static Demo().show();

          }

          Public void show()

          {

                System.out.println(num);

           }

}

7、练习:

建立数组工具

/**

建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数如：最值，排序等。

@author张三

@versionV1.0

*/

public  class ArrayTool

{

        Private  ArrayTool(){}//该类中的方法都是静态的，所以该类是不需要的创建对象的。为了保                                   //证不让其他成创建该类对象

                                  //可以将构造函数私有化。

/**

获取整型数组的最大值。

@paramarr 接收一个元素为int类型的数组。

@return该数组的最大的元素值

*/

        public static int getMax(int[] arr)

       {

                Int maxIndex = 0;

                for(intx=1; x<arr.length; x++)

                {

                        if(arr[x]>arr[maxIndex])

                        maxIndex = x;//

                }

                return arr[maxIndex];

        }

/**

对数组进行选择排序。

@paramarr 接收一个元素为int类型的数组。

*/

        public static void selectSort(int[] arr)

        {

               for(intx=0; x<arr.length-1; x++)

               {

                      for(inty=x+1; y<arr.length; y++)

                      {

                              if(arr[x]>arr[y])

                                 swap(arr,x,y);

                      }

                }

        }

/*

用于给数组进行元素的位置置换。

@param arr 接收一个元素为int类型的数组。

@param a

@param b

*/

        private static void swap(int[] arr,inta,intb)

        {

                 Int temp = arr[a];

                 arr[a] = arr[b];

                 arr[b] = temp;

        }

/**

获取指定的元素在指定数组中的索引.

@paramarr 接收一个元素为int类型的数组。

@paramkey 要找的元素。

@return返回该元素第一次出现的位置，如果不存在返回-1.

*/

        public static int getIndex(int[] arr,intkey)

        {

                 for(intx=0; x<arr.length; x++)

                 {

                         if(arr[x]==key)

                         returnx;

                  }

                  return-1;

        }

/**

将int数组转换成字符串。格式是：[e1,e2,...]

@paramarr 接收一个元素为int类型的数组。

@return返回该数组的字符串表现形式。

*/

        public static String arrayToString(int[] arr)

       {

               String str = "[";

               for(intx=0; x<arr.length; x++)

               {

                      if(x!=arr.length-1)

                      str = str + arr[x]+", ";

                      else

                      str = str + arr[x]+"]";

                }

                returnstr;

        }

}