黑马程序员 Java基础——面向对象思想

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

面向对象

    是一种思想，把复杂事物简单化，把面向过程的执行者变成了指挥者。过程其实就是函数，而对象将函数和一些内容封装。把事物的属性和行为封装成对象，再把对象抽象成类。

    Java 面向对象的三个特征：封装、继承、多态

类

    是一组事物共有特征和功能的描述。是按照面向对象技术进行设计时最小的单位，也是组成项目的最基本的模块。类的概念是抽象的，类似于建筑设计中的图纸，是对于现实需要代表的具体内容的抽象。类只包含框架结构，而不包含具体的数据。

    类就是：对象是生活中事物的描述。

    对象：就是这类事物，实实在在存在个体。

    以后开发：其实就是找对象使用，没有对象，就创建一个。

    找对象，建立对象，使用对象，维护对象的关系

类的定义：

[修饰符] class  类名{

                1- n个构造方法；

                   0-n个字段；

                   0-n个方法

                    }

类的访问修饰符有public和final

类的构造方法

构造方法：用来构造类的实例（每一个类都默认有一个无参的构造方法，如果新建构造方法，默认的就消失。多个构造方法以重装方式出现）

字段：类或对象所包含的数据，对类状态的一种描述；

方法：类或对象的特征或行为。

构造方法和一般方法的区别

1. 构造方法与该类名相同，对象创建时，就会调用与之对应的构造函数，对对象进行初始化。而且在对象建立是就会进行有且只有一次的调用。而且没有return语句，使用new调用

2. 一般方法可以随意命名，对象建立后可以多次调用，可以有return语句。对象.方法（）就可以调用

构造方法和构造代码块区别

    构造代码块是给所有对象初始化，构造函数给先对应的对象初始化

成员变量和局部变量区别

    成员变量定义在类内方法外，在本类中有效，存在于堆内存

    局部变量存在于方法中、参数上、语句中，在定义时到大括号有效，存在于栈内存。

static关键字：用于修饰成员（成员变量和成员函数）。

    被修饰后的成员具备以下特点：

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

    2、优先于对象存在。

    3、被所有对象所共享。

    4、可以直接被类名调用。

注意：静态方法只能访问静态成员、但是非静态成员可以访问静态成员、静态方法中不可以使用this。

原因：静态方法和变量存在的时候，对象还不存在，非静态变量也不存在，肯定无法访问。

主方法（main）是静态的（可以利用类名去调用静态的main方法，很正常！但是会陷入死循环，导致内存溢出，jvm自动停止！）public static void main(String[] agrs){}。

静态什么时候用？

    1. 静态变量

   当分析对象中所具备的成员变量的值都是相同时，这时这个成员就可以被静态修饰。

    只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

    如果是相同的数据，对象不需要做修改只使用，不需要存储在对象中，定义成静态的。

    2. 静态函数

    函数是否用静态修饰，就参考一点，就是该函数功能是否需要访问到对象中的特有数据。

    简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静        态的。如果不需要，就可以将该功能定义成静态的。没有意义。

匿名对象

理解：一个没有名字的对象,创建了一个对象出来,没有赋给一个变量;

特点：对方法或字段只进行一次调用时；可作为实际参数进行传递；只在堆里面开辟存储区域,

注意：只能使用一次,  使用完就被销毁了;

new Person();表示匿名对象,没有名字的对象

new Person().age = 17;//使用一次之后就被销毁了

this关键字

特点：this表示当前对象，当前正在调用实例成员的对象（谁调用了方法，谁就是当前对象）。

this关键字的使用：方法间的相互调用;this.字段;

构造器中相互调用，但是此时this([参数])必须写在构造方法第一行。

注意：this不能用在static修饰的方法里和static修饰的代码块里。

面向对象---封装

封装用于隐藏对象的实现细节。仅对外提供公共访问方式。好处是将变化隔离，提高复用性，安全，便于使用。 

程序中体现形式：通常将类中的成员变量私有化(private)，通过对外提供方法（setXxx,getXxx）,可对该变量(xxx)进行访问（boolean类型的变量没有getXX,只有 isXX）。

示例代码：

class Person{    

    private String name;    

    private int age;        

    public void show(){    

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

    }    

    public Person(String name) {    

        super();    

        this.name = name;    

    }    

    public Person(String name, int age) {    

        super();    

        this.name = name;    

        this.age = age;    

    }    

}    

面向对象---继承

首先有反映一般事物特性的类,然后在此基础上反映出特殊事物的类；也就是说：继承是一种从一般到特殊的关系；

格式：[修饰符] class SubClass extends SuperClass

SuperClass类为父类或基类，SubClass为子类或派生类或拓展类；（java.lang.Object是所有类的父类）。

特点：

1、提高了代码的复用性。

2、让类与类之间产生关系，有了这个继承关系才有了多态的特性。

3、Java语言中只支持单继承。

因为多继承容易带来安全隐患（父类多了，功能相同的话，就会出现调用不确定性吗，覆写一个方法，到底覆写那个父类？）。

注意：

1、父类的私有成员子类不能继承;父类的构造方法不能被继承。

2、一个类有且只有一个直接父类;一个类没显示的继承其他的一个类的时候,默认的直接父类就是Object类;一旦一个类显示的继承了其他的一个类的时候,此时默认的直接父类Object就会被取消。

3、Java里一个类只能有一个直接父类;java.lang.Object是所有类的父类，Object要么是直接父类要么是间接父类。

4、子类对象在实例化之前必须首先调用父类中的构造方法之后再调用自身的构造方法。

9、子类访问父类和方法覆写

注意： 

1、子类不能直接访问父类的私有成员（但是子类可以调用父类中的非私有方法来间接访问父类的私有成员）。

2、方法覆写产生原因：当父类中某个方法不适合于子类时,子类出现父类一模一样的方法.

调用被覆盖的父类方法：使用super.方法名(实参);

子类方法的返回值类型比父类方法的返回值类型更小或相等

子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;

子类方法的访问权限应比父类方法更大或相等;

super关键字和调用父类构造方法

特点:表示父类对象的默认引用

如果子类要调用父类被覆盖的实例方法，可用super作为调用者调用父类被覆盖的实例方法。

使用super调用父类方法

使用super调用父类的构造方法

调用构造方法

本类中调用另一个重载构造方法用this(参数列表)

子类构造方法调用父类构造方法用super(参数列表)

注意：子类调用父类的构造方法时：super必须放在第一句；

Java在执行子类的构造方法前会先调用父类无参的构造方法，其目的是为了对继承自父类的成员做初始化操作。

子类在创建对象的时候，默认调用父类的无参构造方法，要是子类构造方法中显示指定调用父类其他构造方法，就调用指定的父类构造方法，取消调用父类无参构造方法。

面向对象---多态

概念：多态指同一个实体同时具有多种形式

编译时的类型由声明该变量时使用的类型决定,运行时的类型由实际赋给变量的对象决定。

如果编译时类型和运行时类型不同，就出现多态。

比如：Student  extends   Person:

Person p = new Person();

Student s = new Student();

Person p = new Student();//多态，引用关系:父类变量指向子类实例对象

实现多态的机制:

父类的引用变量可以指向子类的实例对象,而程序调用的方法在运行期才动态绑定，就是引用变量所指向的真正实例对象的方法,也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。 

多态的作用：

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

只修改方法的实现，不必修改方法的声明

继承是多态产生的前提条件;

分类:

编译时多态：方法重载

运行时多态：方法覆写