02面向对象

Java面向对象学习的三条主线

1. Java类及类的成员：属性、方法、构造器；代码块、内部类；

2. 面向对象的三大特征：封装性、继承性、多态性（抽象性）；

3. 关键字：this、super、static、final、abstract、interface、package、import等；

大处着眼，小处着收

二、面向过程和面型对象

1.面向过程：强调的是功能的行为，以函数为最小单位，考虑怎么做;
2.面向对象：强调具备功能的对象，以类/对象为最小单位，考虑谁来做;

3.面向对象思想的概述

- 根据问题需要，选择问题所针对的***现实世界中的实体***  
- 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了***概念是写中的类***   
- .把抽象的实体用计算机语言进行描述，***形成计算机世界中的类的定义***。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
- 将***类实例化成计算机中的对象***。对象是计算机世界中解决问题的最终工具。    

4.面向对象的两个要素：

• 类：对一类事物的描述，是抽象的、概念上的定义。
• 对象：是实际存在的该列事物的每个个体，因而也称为实例（instance）

三、设计类--类及类的成员

1、设计类，其实就是设计类的成员

1. 属性 = 成员变量 = filed = 域、字段

2. 方法 = 成员方法 = 函数 = method

3. 创建类的对象 = 类的实例化 = 实例化类

4. 类中属性的使用

   属性（成员变量） VS 局部变量   
   (1). 相同点：    
   
       - 定义变量的格式：数据类型 变量名 = 变量值   
       - 先声明，后使用。   
       - 变量都有其对应的作用域。  
   
   (2). 不同点：   
       1.在类中声明的位置不同。   
         - 属性：直接定义在类的一对{}内。   
         - 局部变量：声明在方法内、方法形参内、构造器内部、构造器形参、代码块内的变量。   
       2.关于权限修饰符的不同：   
         - 属性：可以在声明属性时，指明其权限，使用权限修饰符。   
         - 常用的权限修饰符：private、public、缺省、protected 主要体现在封装性
         - 局部变量没有权限修饰符
       			思考合理性：局部变量的作用域范围很小没有说会在类外
       3.默认初始化值的情况：   
             ① 属性：类的属性，更具其类型，都有默认初始化值：   
                - 整型：（byte、short、int、long）:0   
                - 浮点型：（float、double）：0.0   
                - 字符型：（char）：0（\u0000）   
                - 布尔型：（Boolean）：false   
   
                 - 引用数据类型（类、数组、接口）：null   
             ② 局部变量：没有初始化值。   
                - 意味着，我们在调用局部变量之前，一定要显示赋值。   
                  -特别的：形参在方法调用时，我们赋值即可。   
             ③ 在内存中加载的位置：   
                - 属性：非static加载到堆空间中（static加载在方法区随类的的加载而加载）。   
                - 局部变量：加载到栈空间。
   (3).属性赋值的先后顺序
   	①默认初始化
      	②显式初始化
       ③构造器中初始化
   	④通过"对象.属性" 或 "对象.方法"的方法，赋值;
   	以上操作的先后顺序：① - ② - ③ - ④
        
   

5. 类中方法的声明和使用

   (1).方法：描述类应具有的功能。   
   (2).方法的声明：   
   	权限修饰符 返回值类型 方法名（形参列表）{   
       				方法体      
   	}
       
      **注意：static、final、abstract 来修饰的方法，后面讲**    
   (3). 说明：   
         1. 关于权限修饰符：默认方法的权限修饰符先都使用public   
            Java规定的4中修饰符：private、public、缺省、protected   
   
         2. 返回值类型：有返回值VS没有返回值   
            - 如果方法有返回值，则必须子啊方法声明时，指定返回值的类型。同时需要使用return关键字来返回指定类型的变量和常量。   
            - 如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不能使用return。但是，如果使用的话，只能"return;"表示结束此			方法的意思。   
   
         3. 方法名：属于标识符，遵循标识符的规则和规范，"见名知意"。   
         4. 形参列表：
          	(1).方法可以有多个形参。 
          	(2).可变形参的的方法 ：  
                  - jdk5.0 新增内容   
                  - 具体使用   
                      1. 可变个数形参的格式： 数据类型……变量名；   
                      2. 当调用可变个数形参的方法时，传入的参数个数可以是：0个或多个   
                      3. 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载   
                      4. 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。   
                      5. 可变个数形参在方法的形参中必须声明在末尾   
                      6. 可变个数形参在方法的形参中，最多只能声明一个可变形参; 
        5. 方法参数的值传递机制   
              - 关于变量的赋值：   
                  1. 如果是基本数据类型，此时赋值的是变量所保存的数据值   
                  2. 如果是引用数据类型，此时赋值的是变量所保存的数据的地址值
   
   (4). return关键字的使用：   
   
      - 使用范围：在方法体中   
      - 作用：   
        1. 结束方法；   
        2. 针对有返回值类型的方法，使用"return 数据"方法返回所要的数据；   
        3. 注意点：return关键字后面不可以声明执行语句；   
   
   (5). 方法使用中，可以调用当前类的属性和方法   
         - 特殊的：方法A中有调用了方法A:递归方法   
         - 方法中，不可以定义方法。  
   (6). 再谈方法   
      - 方法的重载
            (1). 定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。 
               ***"两同一不同":同一个类、相同方法名 参数列表不同、参数个数不同、参数类型不同***   
            (2). 举例   
            (3). 判断是否重载   
               跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系   
            (4). 在通过对象调用方法时，如何确定某一个指定的方法   
        		***方法名 ---->参数列表***   
      - 方法的重写（override）
            (1)重写：子类继承父类以后，对父类中同名同参的方法进行覆盖操作
            (2)应用：重写以后，当创建子类对象以后，通过子类对象调用子夫类中的同名同参的方法时，实际执行的是子类重写父类的方法
            (3)重写的规定：
                  方法的声明：
                        权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
                              //方法体
                        }
                  约定熟成：子类中的叫重写的方法，父类中的叫被重写的方法
                     1. 前提是子类必须可以访问到父类的同名方法(权限修饰符)
                     2. 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
                     3. 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符   
                        -特殊情况：子类不能重写父类中声明为private权限的方法（封装性）
                     4. 返回值类型：
                           - 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值只能是void
                           - 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值可以是A类或A类的子类
                           - 父类被重写的方法的返回值是基本数据类型(如double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须是double)
                     5. 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
                     6. 子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么声明为static的（不是重写）
                     7. @Override注解可以用来实现语法校验，看子类是否正确的重写了父类的方法
                     8. 重写只发生在方法之间属性无法构成重写(同名的属性可读性不好吗，不建议使用)
            -----------------------------------------------------------
      - 区分方法的重载与重写？
   
   

6. 构造器

   1.构造器的作用：
       (1).创建对象
       (2).初始化对象的信息
   2.说明：
       (1).如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
       (2).定义构造器的格式：权限修饰符 类名（形参列表）{}
   	(3).一个类中定义的多个构造器，彼此构成重载
       (4).一旦我们显式的定义了构造器之后，系统就不再提供默认的空参构造器
       (5).一个类中，至少会有一个构造器
   

7. JavaBena

   (1).JavaBean 是一种Java语言写出成的可重用组件;
   (2).JavaBean是指符合如下标准的Java类
       ①类是公共的
       ②有一个无参的公共构造器
       ③有属性，且有对应的get、set方法
   

8. 理解"万室万物皆对象"

   • 在Java语言范畴中，我们都将功能、结构等封装到类中，通过实例化，来调用具体的功能结构。

   • 涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象

9. 内存解析的说明

   • 引用数据类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）

10. 匿名对象的使用

• 理解：我们创建的对象，没有显式赋给一个变量。即匿名对象
• 特征：匿名对象只能调用一次

11. 面向对象的特征之一：封装和继承
    封装：

    (1). 问题的引入：   
       当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值，加入额外的限制条件。这个条件就不能在属性声明是体现，我们只能通过方法进行限制条件的添加，同时，我们需要避免用户在使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有（private）   
       此时，针对属性就是封装性        
    
    (2). 封装性的体现：   
           我们将类的属性私有化（private），同时，提供公共的（public）方法来获取和设置比属性的值；      
    
       拓展：封装性的体现：   
           - 如上  
           - 不对外暴露的私有方法   
           - 单例模式    
    
    (3).封装性的体现需要权限修饰符来配合。  
    
       - Java规定的4中权限（从小到大排列）：private、缺省、protected、public   
       - 4种权限修饰符可以用来修饰类及类的内部结构：属性、方法、构造器、内部类   
       - 具体的，4种权限修饰符都可以用来修饰类的内部结构：属性、方法、构造器、内部类   
         修饰类的话：只能使用缺省、public   
    (4)权限修饰符：
                      权限修饰符的使用:  public > protected > 缺省 > private
                      public   protected    缺省    private
             本类         √         √          √        √
             包内         √         √          √        ×
             子类         √         √          ×        ×
             包外无关类    √         ×          ×        ×
    
             权限修饰符的访问范围:
                private权限最小，只能在本类里访问;缺省能在本包内访问
                protected可以在子类里访问;public全都可以访问
    
             权限修饰符的使用范围:
                局部变量不能使用任何的权限修饰符，只能使用缺省权限修饰符;
                成员变量和方法 可以使用四种全部的权限修饰符
                普通类只能使用 public 或者 缺省权限修饰符
    

    ！[image.png]
    (4)总结封装性：Java提供4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构内部被调用时的可见性的大小

    继承：

    (1)继承性的好处：
          - 减少代码的冗余，提高代码的复用性
          - 便于功能的扩展
          - 为之后多态性的使用，提供了前提
    (2)继承性
       - 格式：class A extends B{}
          A:子类、派生类、subclsaa
          B:父类、超类、基类、superclass
       - 基本概念：
             继承描述的是类和类之间的关系
             使用关键字 extends 来建立继承关系
             将多个类ABC共有的特征和行为再次抽象成为一个新的类D,称D为父类，超类，基类，ABC称为子类，派生类
       - 体现：
          一旦子类继承了父类以后，子类中就获取了父类中声明的所有属性和方法。
          特别的：
             父类中声明的private的属性和方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响 ，使得子类不能直接调用父类的结构而已
       	  子类继承父类以后，还可以声明自己特有的属性和方法；实现功能的拓展。
          子类和父类的关系不同于子集和集合的关系
    (3)Java中关于继承的规定
       - 一个类可以被多个子类继承
       - Java中的类的单继承性；一个类只能由一个父类
       - 子夫类是相对的概念
       - 子类直接继承的福利，称为：直接父类。间接继承的父类称为间接父类
       - 子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
       - 子类对象在创建实例对象时，会先调用父类的构造方法初始化父类空间
    (4)
       - 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.object类
       - 所有的Java类（除了java.lang.object类之外）都直接或间接继承于java.lang.object类
       - 意味着，所有的Java类具有java.lang.object类声明的功能。
    

    注意：在继承了父类后实例化子类会将父类加载到子类的内存中这个内存是不是独立的不会影响到原来父类

2、类和对象的使用（面向对象思想落地的实现）

1.创建类、设计类的成员。
2.创建类的对象。
3.通过对象.属性 或 对象.方法调用对象的结构。

3、如果创建了一个类的多个对象，则每一个对象都独立的拥有一套类的属性。（非static的）意味着：如果我们修改一个对象a的属性，则不影响另一个对象的a属性

4、对象的内存解析

5、关键字(穿插着讲)

1. this关键字的使用：
   (1).this可以用来修饰：属性、方法、构造器
   (2).this修饰属性和方法：
   this理解为：当前对象

   • 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式。但是通常情况下，我们都选择省略"this.".特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
   • 只能调用非static的方法和属性 ，static定义的属性和方法都定义在方法区，无需实例化对象就可以使用

   (3).this调用构造器

   • 我们在类的构造器中，可以显式的使用"this（形参列表）"方式，调用本类中指定的其他构造器
   • 构造器中不能通过"this(形参列表)"方式调用自己
   • 如果一个类有n个构造器，则最多有n-1构造器中使用"this(形参列表)"
   • 规定："this(形参列表)"必须声明在当前构造器的首行
   • 构造器内部，最多只能声明一个"this(形参列表)",用来调用其他构造器

2. package、import的使用

   1. package的使用：
      (1).为了更好的实现项目中类的管理，提供包的概念   
      (2).使用package声明类或接口所属的包，声明在源文件的首行   
      (3).包，属于标识符，遵循标识符的命明规范（xxyyzz）、"见名知意"   
      (4).每"."一次，就代表一层文件目录   
   
      (5)补充：同一包下，不能命名同名的接口、类   
              不同包下，可以命名同名的接口、类;
   
   2. import关键字的使用：
      (1).在源文件中显式的使用import结构导入指定包下的类、接口   
      (2).声明在包的声明和类的声明之间   
      (3).如果导入多个结构，则并列写出即可
      (4).可以使用"xxx.*"  的方式，表示可以导入"xxx"包下的所有结构
      (5).如果使用的类或接口时本包下定义的，则可以省略import结构
      (6).如果使用的类或接口是本包下定义的，则可以省略import结构
      (7).如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
      (8).使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要
      (9).import static:导入指定类或接口中的静态结构:属性或方法。 
      (10).只有被public修饰的类才能被 import导入 跨包使用
      (11).可以导入指定的属性、方法、类
   

3. super关键字的使用

   (1) super 理解为：父类的
   (2) super 可以用来调用：属性、方法、构造器
   (3) super 的使用：
            - 我们在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super"
            - 特殊情况：当子类和父类中定义了同名方法属性时，我们想在子类中调用父类中声明的属性，则必须显式使用"super.属性"的方式，表示调用的时父类中声明的属性
             - 特殊情况：当子类重写了父类中定义方法以后，我们想在子类中调用父类中被重写的方法时，则必须显式使用"super.属性"的方式，表示调用的时父类中别重写的方法