黑马程序员——java之面向对象总结

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

java是一种语言，是一种面向对象的语言，所谓的面向对象，是对面向过程而言的，其具有以下特点：

1.将复杂的问题简单化；

2.面向对象将以前的过程的执行者，变成了指挥者；

3.面向对象的这种思想是符合现在人们思考习惯的一种思想；

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

１.成员变量直接定义在类中，局部变量定义在方法中，参数输上；

２.成员变量在这个类中有效，局部变量只有在自己所属的区间内有效，也就是大括号运行结束，局部变量就失去作用域；

如：局部变量：String s =；      编译失败，可能尚未初始化；

对字符串而言：String s = null;      可以运行，因为定义了一个值为空的变量；

String s = "";          定义了一个有对象的值但是对象的内容为空的变量；

总结：堆内存中new 出来的对象，当其没有任何引用指向的时候，变为垃圾，但是不会被立刻释放，当垃圾回收器回收后才会被释放；

在类中定义的都称为成员：

1.成员变量：定义的是相应事物的属性；

2.成员函数：定义的是相应事物的行为；

构造函数：

１.构造函数的名称和所在类的名称相同；

２.不需要定义返回值类型；

３.构造函数没有具体的返回值；

４.构造函数的一个作用就是创建对象

如果在定义一个类时，没有定义构造函数，那么该类中会自动生成一个空参的构造函数，如果在类中定义了构造函数，那么默认空参的构造函数就没有了　

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

构造代码块：

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

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

就是将不需要对外提供的内容都隐藏起来，把属性都隐藏起来，提供公共的方法对齐访问

静态代码块、构造代码块，构造方法同时在存在时的执行顺序是：

静态代码块—>构造代码块—>构造函数

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

继承：就是将子类所共有的属性和行为向上抽取形成一个父类，子类继承父类就可以直接使用父类的成员

1.提高了代码的复用性；

2.让类与类之间产生关系，是多态的前提

java支持单继承不支持多继承，因为如果当一个类同时继承多个类时，两个父类中有相同的功能时，那么子类对象在调用该功能是不知道会运行哪一个

但是java支持多层继承关系，多重继承的出现，就有了继承体系，所以只需要查阅顶层父类的内容，创建子类对象不仅可以使用父类功能，还能使用字节的特有功能

继承关系中成员的特点：

1.成员变量：当子父类中出现相同名称的属性时，子类类型的对象，调用该属性，获取的值是子类的属性值

其访问顺序是：局部变量>成员变量>父类的成员变量>父类的父类的成员变量>......>Object类的成员变量

2.成员函数：当子父类中出现了相同的方法时，建立子类对象会运行子类中的方法，这就是所谓的方法重写

所谓的方法重写：子类继承父类，重写父类中的方法，具有相同的方法名称，返回值类型如果是基本数据类型，则必须相同

如果返回值类型是引用数据类型时，则需满足如下条件：

· 1.子类的返回值类型是父类返回值类型的子类；

2.父类返回值类型是子类返回值类型的父类；

3.构造函数：

子类的所有构造函数中的第一行，都有一个默认的super()；其表示的是父类的构造函数，并会调用父类空参的构造函数对父类中的成员进行初始化，这就是子类的实例化过程

如果父类中没有空参的构造函数，那么子类的构造函数内，必须通过super()语句指定要访问的父类的构造函数

如果子类的构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数

final关键字：

1.final是一个修饰符，可以修饰类、方法、变量

2.被final修饰的类时一个最终类，不可以被继承

3.被final修饰的方法是一个最终方法，不可以被重写

4.被final修饰的变量是一个常量，只能赋值一次

抽象类：

抽象类是被abstract修饰的类，抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类，也就是说，如果一个类中有方法被abstract所修饰，

那么该方法所在的类一定是一个抽象类，也需要被abstract所修饰

abstract关键字不能如下的关键字所共存：

1.final，因为被final所修饰的类不能被继承，所修饰的方法不能被重写，而被abstract修饰的方法必须被重写

2.static，因为被static所修饰的方法是静态方法，可以直接被类名调用，而被abstract修饰的抽象类不能创建对象，不能直接用类名调用方法

3.private，因为被private所修饰的成员属性和成员方法无法子类访问，而被abstract修饰的抽象类一定要子类访问并重写其抽象方法

接口：比抽象类更抽象的类，里面的所有的方法都是抽象方法

接口中的成员修饰符都是固定的：

成员变量：public static final...

成员函数：public abstract...

如果在定义接口的过程中没有给全其固定的修饰符，那么会默认添加补充上默认的修饰符，而不会报错

多态：

1.父类引用或接口指向了子类对象

2.提高了程序的扩展性

3.当父类引用指向子类的对象时，虽让提高了程序的扩展性，但是只能访问父类中有的方法，而不能访问子类中的特有方法

4.实现多态的前提是必须有继承或者实现的关系，即子父类关系或者接口的实现关系

总结：我理解的面向对象就是，当我们想实现某一功能的时候，可能不具备完成这项功能的能力，但是通过面向对象的思想，我们可以寻找具备我们所需要功能的对象，

而我们只需要调用具备此功能的对象来完成需求即可，这个是相对面向过程而言的，它会是复杂的问题简单化，使过程直接变成结果，符合人们正常的思维方式！！！