黑马程序员---面向对象主要特性分析

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

面向对象是一种思想，是基于面向过程而言的，就是说面向对象是将功能等通过对象来实现，

将功能封装进对象之中，让对象去实现具体的细节。比方说，我们去车站售票厅买车票，

你只需要知道卖票员这个对象有卖票这个功能就行，你只需要告诉他你要什么票（发送请求），然后

你给他钱（方法参数），他给你票就可以了（方法返回值）。至于车票是怎么弄出来的，你不需要关心。

这种思想是将数据作为第一位，

方法或者说是算法作为其次，这是对数据一种优化，操作起来更加的方便，简化了过程。

面向对象的三大特性：

1.封装（Encapsulation）

2.继承（Inheritance）

3.多态（Polymorphism）

封装：隐藏对象的属性和实现细节。仅对外提供公共的访问方法。把数据进行封装的好处是将变化

隔离，便于使用，提高安全性和复用性。进行封装的原则是：将不需要对外提供的内容进行隐藏。属性隐藏，

使用公共的方法来对外提供访问。而隐藏通过权限修饰符来实现。

private:私有,权限修饰符.用于修饰类中的成员.(成员变量,成员函数).私有只在本类中有效.

 注意:私有仅仅是封装的一种表现形式.封装之后要对外提供访问方式.

 之所以对外提供访问方式.就因为可以在访问方式中假如逻辑判断等语句.对访问的数据进行操作.提高代码的健壮性.

 this:用于区分局部变量和成员同名的情况

 this:代表其所在函数所属对象的引用。换言之：this代本类对象的引用。简单说,哪个对象在调用this所在的函数就代表哪个对象.

 this的应用当定义类中功能时,该函数内部要用到调用该对象时,这时this来表示这个对象.单反本来功能内部使用了本类对象,都用this表示

 静态：static。

用法：是一个修饰符，用于修饰成员(成员变量，成员函数).

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，

还可以直接被类名调用。类名.静态成员。

继承：继承提高了代码的复用性，是多态的前提。

多态：多态是指父类或接口的引用指向子类或具体实现类的实例。提高了程序的扩展性，但多态中

父类引用只可以访问父类中具备的方法，而不能访问子类具备的特有的方法。多态的前提是有继承或者实现。

类和对象的关系：

现实生活中的对象：张三，李四。

想要描述：提取对象中共性内容，是对具体事物的抽象。

描述时：这些的对象的共性有：姓名，年龄，性别以及学习的功能等等。

把这些事物映射到java语言中，描述就是class定义的类。

具体对象则对应堆内存中用new关键字所创建的实体。所以

类是对现实生活中事物的描述，对象则是实实在在的个体。

成员变量与局部变量

成员变量和局部变量的作用范围以及在内存中的位置都是有区别的。

成员变量作用于整个类。而局部变量只作用于函数或某个语句中。

成员变量存在堆内存中，因为对象的存在才在内存中存在。局部变量则存在栈内存中。

static 特点：

1，随着类的加载而加载。

    也就说：静态会随着类的消失而消失。说明它的生命周期最长。

2，优先于的对象存在

 明确一点：静态是先存在。对象是后存在的。

3，被所有对象所共享

4，可以直接被类名所调用。

5，主函数是静态的。

 静态有利有弊

 利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。

  可以直接被类名调用。

 弊端：生命周期过长。

    访问出现局限性。(静态虽好，只能访问静态。)

 实例变量和类变量的区别：

 1，存放位置。

  类变量随着类的加载而存在于方法区中。

  实例变量随着对象的建立而存在于堆内存中。

 2，生命周期：

  类变量生命周期最长，随着类的消失而消失。

  实例变量生命周期随着对象的消失而消失。

 静态使用注意事项：

 1，静态方法只能访问静态成员。

  非静态方法既可以访问静态也可以访问非静态。

 2，静态方法中不可以定义this，super关键字。

  因为静态优先于对象存在。所以静态方法中不可以出现this。

 3，主函数是静态的。

 静态有利有弊

 利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。

  可以直接被类名调用。

 弊端：生命周期过长。

    访问出现局限性。(静态虽好，只能访问静态。)

 静态的应用:

 每一个应用程序中都有共性的
cf22
功能，

 可以将这些功能进行抽取，独立封装。

 以便复用。

 虽然可以通过建立ArrayTool的对象使用这些工具方法.对数组惊醒操作.

 发现了问题

  1.对象是用于封装数据的,可是ArrayTool对象中中未封装特有数据.

  2.操作数组的每一个方法都没有用到Arraytool对象中的特有数据.

 这时候结考据,让程序更加严谨,是不需要对象的,

 可以将ArrayTool中的方法都定义成static的,直接通过类名进行调用.

 将方法都静态后,可是方便与使用,单是该类还是可以被其他程序建立对象的.

 为了更加眼睛,强制让该类不能建立对象,

综合示例：

class ArrayTool
{
private ArrayTool(){};
//获取最大值
public static int getMatArr(int[] arr)
{
int max=arr[0];
for(int x=1;x<arr.length;x++)
{
if(arr[x]>max)
max=arr[x];
}
return max;
}
//获取最小值
public static int getMinArr(int[] arr)
{
int min=arr[0];
for(int x=1;x<arr.length;x++)
{
if(arr[x]<min)
min=arr[x];
}
return min;
}
//选择排序
public static void arrSort(int[] arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{
swep(arr,x,y);
}
}
}
}
//冒泡排序
public static void bubbleSrot(int[] arr)
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)
{
if(arr[y]>arr[y+1])
swep(arr,y,y+1);
}
}
}
//用第三方变量来互换位置
private static void swep(int[] arr,int a, int b)
{
int temp=arr[a];
arr[a]=arr;
arr[b]=temp;
}
//打印数组
public static void printArr(int[] arr)
{
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]);
}
}

}
class ArrayToolTest
{
public static void main(String[] args)
{
int[] arr={1,5,79,36,4,6};
//int min=ArrayTool.getMinArr(arr);
//System.out.println(min);
ArrayTool.arrSort(arr);
ArrayTool.printArr(arr);
}
}

[b]继承的特点:

 Java只支持单继承，不支持多继承。

 一个类只能有一个父类，不可以有多个父类。

 class SubDemo extends Demo{}

 class SubDemo extends Demo1,Demo2...

 Java支持多层继承(继承体系)

 class A{}

 class B extends A{}

 class C extends B{}


定义继承需要注意：

 不要仅为了获取其他类中某个功能而去继承

 类与类之间要有所属( " is a " )关系，xx1是xx2的一种。

 super关键字:

 super和this的用法相同

 this代表本类应用

 super代表父类引用

 当子父类出现同名成员时，可以用super进行区分

 子类要调用父类构造函数时，可以使用super语句。

 子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重 写或者复写。

 父类中的私有方法不可以被覆盖。

 在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

覆盖注意事项：

 覆盖时，子类方法权限一定要大于等于父类方法权限

 静态只能覆盖静态。

 覆盖的应用：

 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

子类的实例化过程:

 子类中所有的构造函数默认都会访问父类中空参数的 构造函数

 因为每一个构造函数的第一行都有一条默认的语句 super();

 子类会具备父类中的数据，所以要先明确父类是如何 对这些数据初始化的。

 当父类中没有空参数的构造函数时，子类的构造函数 必须通过this或者super语句指定要访问的构造函数。

抽象:

 抽象类的特点:

 1.抽象方法一定在抽象类中.

 2.抽象方法和抽象类都必须被absstrch关键字修饰.

 3.抽象类不可以用new创建对象.因为调用抽象方法没有意义.

 4.抽象类中的方法要背使用.必须由了子类复写起所以的抽象方法后.建立子类对象调用.

  如果子类只覆盖了部分抽象方法.那么该子类还是一个抽象类.

多态

 可以理解为事物存在的多种体现形态。

1，多态的体现

 父类的引用指向了自己的子类对象。

 父类的引用也可以接收自己的子类对象。

2，多态的前提

 必须是类与类之间有关系。要么继承，要么实现。

 通常还有一个前提：存在覆盖。

3，多态的好处

 多态的出现大大的提高程序的扩展性。

4，多态的弊端：

 虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

6，多态的出现代码中的特点(多态使用的注意事项)

在多态中成员函数的特点:

 在编译时期:残月引用型变量所属的类候总是否有调用的方法.如果有,则编译通过.如果没有.则编译失败

  在运行时期:残月对象所属的类中是否有调用的方法.

 简单的总结就是:成员函数在多态调用时,编译看左边.运行看右边.（其原理是静态绑定和动态绑定）

 

在多态中.成员变量的特点:

  无论编译和运行,都残月左边(引用型变量所属的类);

 

在多态中.静态成员函数的特点:

  无论便是和运行.都参考左边

 instanceof 是用于判断对象的类型