java 面向对象——进度1

面向对象：

1，面向对象和面向过程思想。
    
    面向对象强调的是对象实例。
    面向过程强调的是动作。
    对象将动作进行封装。

    在问题领域中，我们先去找的都是涉及的对象，
    然后分析对象的属性和行为。

2，面向对象的特点。
    1，是一种常见思想。
    2，复杂变简单。
    3，执行者变指挥者。
    举例：面试的例子。

3，类与对象的关系。
    类：就是对事物的描述，其实类就是将对象共性的内容进行抽取。
    对象：就是该类事物实实在在存在个体，在java中通过new来完成创建的，
        堆内存的对象主要用于封装对象中的特有数据。

4，类中的成员：
    成员变量：事物的属性，
    成员函数：事物的行为。

    成员变量和局部变量的区别？
    答：
    
    如何使用成员，只要建立该类对象，并通过 "对象.对象成员" 就可以完成调用

5，封装。
    隐藏实现细节，并对外提供公共的访问方式。

    函数或者类都是一个封装体。

    特点：
    1，隔离的变量。
    2，便于使用。
    3，提高复用。
    4，提高安全性。

    举例：机箱的例子

    体现之一：私有。

    私有在源代码中的使用就是在本类中有效。
    
    通常会将成员变量xxx私有化，并对外提供对应的setXxx getXxx方法对其进行访问。
    其实目的就是成员变量访问进行控制。 让成员的访问具备可控性，提高了程序的健壮性。

    私有仅仅是封装的体现形式之一而已。

    自定义一个Person类。动手。

6，构造函数。
    写法特点：
    1，函数名和类名相同。
    2，不需要定义返回值类型
    3，没有具体的返回值。但是有return语句，用于结束构造函数。

    使用特点：
    1，定义类中，有默认的空参数构造函数。如果已经自定义，那么默认就没有了。
    2，构造函数在类有多个，是重载形式体现出来的。
    
    构造函数的作用：
    用于给对象进行针对性的初始化。

    构造函数和一般函数的区别？
    1，
    2，
    3，

    什么时候使用构造函数呢？
    当对象创建时就需要一些内容(数据和行为)，那么这些内容都定义在构造函数中。
        
7，this关键字.
    this：代表的是对象。哪个对象调用了this所在的函数，this就代表哪个对象。
        
    用法体现
    1，当成员变量和局部变量同名时，可以用this区别。
    2，当构造函数中调用本类其他构造函数时，可以用this完成。 this(实际参数);
        这种调用必须定义在构造函数的第一行。初始化动作先完成。

    应用：只要在定义功能时，用到了本类对象，那么就使用this来表示。

8，static关键字：
    
    特点：
    1，修饰成员。，
    2，随着类加载，随着类消失。
    3，优先于对象。
    4，用类名直接访问

    使用注意事项:
    1，静态方法只能访问静态，静态有访问局限性。
    2，静态方法中不能有this super关键字。
    3，主函数是静态的。

    静态变量和成员变量的区别？
    1，
    2，
    3，
    4，

    
    什么时候使用静态？
    1，当成员变量的数据各个对象都相同时，可以用static修饰，让多个对象共享。
    2，函数如果访问了特有数据(非静态成员变量),该函数是非静态的。
       函数如果没有访问特有数据，那么该函数就可以静态修饰。

    
    如果类中的功能都是静态的，那么该类创建对象是没有意义的，所以构造函数需要私有化。

9，代码块。
    1，局部代码快。
        对局部变量的生命周期进行控制。
    2，构造代码块。
        对所有对象进行初始化。
    3，静态代码块。
        对类进行初始化。
10，继承

　　1，成员函数

　　　　特点：覆盖存在子类和父类之间，重载存在同一个之中

　　　　1，覆盖，覆写，重写：保留父类原有功能，添加子类特有内容！

　　　　　　函数方法相同

　　　　　　子类如覆盖父类，子类权限必须大于等于父类的权限（public>private）

　　　　　　静态方法的覆盖必须子类和父类中的方法都是静态的方法

　　　　2，重载：

　　　　　　同名方法形参的类型，个数，与返回值的类型无关

　　　　　　

　　　调用子类方法，会先检查子类空间中的方法，如没有找到会通过super在父类空间中进行查找

　　

　　2，成员变量

　　　　特点：子类持有super引用，子类不直接访问父类私有内容

　　分配内存（开辟空间）

　　

　　加载父类和子类并创建对象（分配内存）

　　

　　创建子类对象，先创建父类成员

　　

　　分别初始化父类（super）和子类（构造和赋值）

　　

　　调用子类方法访问子类变量

　　

　　打印顺序

　　

　　

　　3，构造函数

　　　　特点：

　　4，多重（多层）继承和单继承

　　　　特点：java不支持多继承，避免继承多个直接父类导致的变量调用的不确定性。

11，抽象类和接口

　　接口特点：

　　1，当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用作接口　　
　　对于接口当中常见的成员：而且这些成员都有固定的修饰符。全局常量: public  static final 抽象方法。public abstract
　　接口中的成员都是公共的权限.
　　2，接口不可以实例化。只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。否则，这个子类就是一个抽象类。
　　3，接口可以多实现，避免了单继承的局限性。

　　4，接口类型的引用用于指向接口子类的对象

　　抽象类 特点：

　　相同点：
    　　都是不断向上抽取而来的。

　　不同点：
   　　 1，抽象类需要被继承，而且只能单继承。
     　　  接口需要被实现，而且可以多实现。
    　　2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
     　　  接口中只能定义抽象方法，必须由子类去实现。
  　　  3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
     　　  接口的实现是 like a 关系，在定义体系额外功能。

12，多态

　　特点：

　　1，一个对象具有多个状态，可以为人，也可以为动物

　　2，父类或者接口的应用指向子类的对象。

　　3，多态的好处：
   　　 提高了代码的扩展性，前期定义的代码可以使用后期的内容。
　　4，多态的弊端：
    　　前期定义的内容不能使用(调用)后期子类的特有内容。
　   5，多态的前提：
   　　 1，必须有关系，继承，实现。
   　　 2，要有覆盖。

　　

　　对象类型转换：自始至终都是子对象在做类型转换

　　向上转型

　　

　　向下转型

　　

　　两者之间不具备继承关系，猫转成狗出现类型转换异常，

　　判断对象的具体类型，instanceof（）用于应用类型的判断

　　

　　内部类

　　对象初始化过程
　　
　　1，JVM会读取指定的路径下的Person.class文件，并加载进内存，
    　　并会先加载Person的父类(如果有直接的父类的情况下).
　　2，在堆内存中的开辟空间，分配地址。
　　3，并在对象空间中，对对象中的属性进行默认初始化。
　　4，调用对应的构造函数进行初始化。
　　5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。
　　6，父类初始化完毕后，在对子类的属性进行显示初始化。
　　7，在进行子类构造函数的特定初始化。
　　8，初始化完毕后，将地址值赋值给引用变量.

　　

　　

　　多态时，成员的特点：

　　1，成员变量。
  　　  编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编　　译失败。
    　　运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员　　变量。
   　　 简单说：编译和运行都参考等号的左边。哦了。

　　2，成员函数(非静态)。
    　　编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。
    　　运行时：参考的是对象所属的类中是否有调用的函数。
  　　  简单说：编译看左边，运行看右边。

   　　 因为成员函数存在覆盖特性。

　　3，静态函数。
        　　编译时：参考引用型变量所属的类中的是否有调用的静态方法。
        　　运行时：参考引用型变量所属的类中的是否有调用的静态方法。
       　　 简单说，编译和运行都看左边。

       　　 其实对于静态方法，是不需要对象的。直接用类名调用即可。