类与对象

1-面向对象学习的三条主线

  1. Java类及类的成员：属性、方法、构造器；代码块、内部快
  2. 面向对象的三大特征：封装性、继承性、多态性、（抽象性）

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

    2-面向对象与面向过程（理解）

  4. 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。

  5. 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

3-完成一个项目（或功能）的思想

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

4-面向对象中两个重要分概念

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

  • 面向对象程序设计的重点是类的设计
  • 设计类，就是设计类的成员

两者的关系：
对象，是由类new出来的，派生出来的。

5-面向对象思想落地实现的规则

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

补充：

  • 属性 = 成员变量 = field = 域、字段
  • 方法 = 成员方法 = 函数 = method
  • 创建类的对象 = 类的实例化 = 实例化类

6-对象的创建与对象的内存解析

  1. Person p1 = new Person();
  2. Person p2 = new Person();
  3. Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。

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

内存解析：
image.png

image.png

7-匿名对象

概念：我们创建的对象，没有显式的赋给一个变量名，即为匿名对象
特点：匿名对象只能调用一次

举例：

  1. new Phone().sendEmail();
  2. new Phone().playGame();
  4. new Phone().price = 1999;
  5. new Phone().showPrice();//0.0

应用场景：

  1. PhoneMall mall = new PhoneMall();
  3. //匿名对象的使用
  4. mall.show(new Phone());
  5. 其中，
  6. class PhoneMall{
  7.     public void show(Phone phone){
  8.         phone.sendEmail();
  9.         phone.playGame();
  10.     }
  11. }

8-理解“万事万物皆对象”

  1. 在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
  • Scanner，String等
  • 文件：File
  • 网络资源：URL
  1. 涉及到Java语言与前端Html、后端数据库的交互式，前后端的结构在Java层面交互时，都体现为类、对象

JVM内存结构

编译完源程序以后，生成一个或多个字节码文件。
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。
意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。
image.png
虚拟机栈，即为平时提到的栈结构。
我们将局部变量存储在栈结构中，将new出来的结构（如数组、对象）加载到堆空间中。
补充：对象的属性（非static）加载在对空间中
方法区：类的加载信息、常量池、静态域

类的结构之一：属性

属性与局部变量的对比

  1. 相同点
  • 定义变量的格式：数据类型 变量名 = 变量值
  • 先声明，后使用
  • 变量都有其对应的作用域
  1. 不同点
  • 在类中声明的位置的不同

属性：直接定义在类的一对{ }内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

  • 关于权限修饰符

属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected —->封装性
局部变量：不可以使用权限修饰符

  • 默认初始化值得情况：

    • 属性：类的属性，根据其类型，都能默认初始化值。

      • 整形（byte、short、int、long：0）
      • 浮点型（float、double：0.0）
      • 字符型（char：0或 ‘\u0000’）

      • 布尔型（boolean: false）

      • 引用数据类型（类、数组、接口：null）

    • 局部变量：没有默认初始化值

因此在调用局部变量之前，一定要显式赋值
特别的，形参在调用时赋值即可

  • 在内存中加载的位置：
    • 属性：加载到堆空间中（非static）
    • 局部变量：加载到栈空间

补充：变量的分类

  1. 按数据类型

image.png

  1. 按变量在类中声明的位置

image.png

类的结构之二：方法

1-方法的概念

方法：描述类应该具有的功能。
比如：Math类：sqrt()\random() ...
Scanner类：nextXxx() …
Arrays类：sort() \ binarySearch() \ toString() \ equals() \ …

  1. 举例：

    1. public void eat(){}
    2. public void sleep(int hour){}
    3. public String getName(){}
    4. public String getNation(String nation){}

  2. 方法的声明：

    1. 权限修饰符  返回值类型  方法名(形参列表){
    2.  方法体
    3. }

  3. 说明：

  • Java规定的4中权限修饰符：private、public、缺省、protected —> 封装性
  • 返回值类型：有返回值 / 无返回值
    • 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。
    • 如果没有返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要使用return，但是，也可以使用“return；”表示结束此方法。
  • 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
  • 形参列表：方法可以声明0个，1个，或多个形参。
  1. 方法的使用中，可以调用当前类的属性或方法
  • 特殊的，方法A中也可以调用方法A（递归）
  • 方法中，不可以定义方法

2-关键字：return

  1. 使用范围：使用在方法体中
  2. 作用：

① 结束方法
② 针对于返回值类型的方法，使用”return 数据”方法返回所要的数据。

  1. 注意点：return关键字后面不可以声明执行语句。

    3-方法的重载

  2. 定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

总结：“两同一不同”：同一个类，相同方法名；参数列表不同（参数个数不同，参数类型不同）

  1. 举例： ```java // 如下的4个方法构成了重载 public void getSum(int i,int j){

    1.  System.out.println("1");

    }

    public void getSum(double d1,double d2){

    1.  System.out.println("2");

    }

    public void getSum(String s ,int i){

    1.  System.out.println("3");

    }

    public void getSum(int i,String s){

    1.  System.out.println("4");

    }

// 不构成重载的举例： // 如下的3个方法不能与上述4个方法构成重载 // public int getSum(int i,int j){ // return 0; // }

// public void getSum(int m,int n){ //
// }

// private void getSum(int i,int j){ //
// }

  2. 3. 如何确定类中某一个方法的调用：
  4. 方法名---> 参数列表
  6. 4. 思考：方法的重载与重写的区别
  8. <a name="EBplL"></a>
  9. ## 4-可变个数形参的方法
  11. 说明：
  13. - jdk5.0新增的内容
  14. - 具体使用
  15.    - 可变个数形参的格式：数据类型 ... 变量名
  16.    - 当调用可变个数形参的方法时，传入的参数个数可以是0个，1个，2个等
  17.    - 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载，含不定参数的重载方法是最后被选中的。
  18.    - 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
  19.    - 可变个数形参在方法的形参中，必须声明在末尾。
  20.    - 最多只能声明一个可变形参。
  21.    - 可变参数是兼容数组类参数的，但是数组类参数却无法兼容可变参数。
  23. 举例说明：
  24. ```java
  25. public class TestVarArgus {
  26.     public static void dealArray(int... intArray) {
  27.         for (int i : intArray)
  28.             System.out.print(i + " ");
  30.         System.out.println();
  31.     }
  33.     public static void main(String args[]) {
  34.         int[] intArray = { 1, 2, 3 };
  36.         dealArray(intArray);// 通过编译，正常运行
  37.     }
  38. }

5-java的值传递机制

  1. 针对于方法内变量的赋值举例： ```java System.out.println(“*基本数据类型：**“); int m = 10; int n = m;

System.out.println(“m = “ + m + “, n = “ + n);

n = 20;

System.out.println(“m = “ + m + “, n = “ + n);

System.out.println(“*引用数据类型：**“);

Order o1 = new Order(); o1.orderId = 1001;

Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。

System.out.println(“o1.orderId = “ + o1.orderId + “,o2.orderId = “ +o2.orderId);

o2.orderId = 1002;

System.out.println(“o1.orderId = “ + o1.orderId + “,o2.orderId = “ +o2.orderId);

  1. 规则：<br />如果变量是基本数据类型，此时赋值的是变量所保存的数据值。<br />如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
  3. 2. 针对于方法的参数概念
  4. - 形参：方法定义时，声明的小括号内的参数
  5. - 实参：方法调用时，实际传递给形参的数据
  7. 3. java中参数传递机制：值传递
  9. 规则：
  11. - 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
  12. - 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
  14. 推广：
  16. - 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
  17. - 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
  19. 4. 典型例题与内存解析：
  21. 【例题1】<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/21650681/1632391681744-0ab4f98b-4312-4611-b394-6fdacfd4b86e.png#clientId=u25be0df6-6272-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=290&id=ub817d118&margin=%5Bobject%20Object%5D&name=image.png&originHeight=386&originWidth=462&originalType=binary&ratio=1&rotation=0&showTitle=false&size=17720&status=done&style=none&taskId=u4026994f-2b65-4ccb-b2e2-e3410b08529&title=&width=347)<br />【例题2】<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/21650681/1632391687561-ec301c7d-7b9e-4c7f-a6d4-4451961f9336.png#clientId=u25be0df6-6272-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=287&id=ufc7c86d6&margin=%5Bobject%20Object%5D&name=image.png&originHeight=382&originWidth=764&originalType=binary&ratio=1&rotation=0&showTitle=false&size=32828&status=done&style=none&taskId=ud60fea9c-9935-40d9-abaa-a1c043464ea&title=&width=573)
  23. <a name="okhgT"></a>
  24. # 面向对象的特征之一：封装性
  26. <a name="qjUxA"></a>
  27. ### 1-为什么要引入封装性
  29. - 我们程序设计追求“高内聚，低耦合”。
  30.    - 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
  31.    - 低耦合：仅对外暴露少量的方法用于使用。
  32. - 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
  34. <a name="dkEMe"></a>
  35. ### 2-问题引入
  36.  <br />当我们创建一个类的对象以后，我们可以通过“对象 . 属性”的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他的制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。同时，我们需要避免用户再使用“对象 . 属性”的方式对属性进行复制。则需要将属性声明为私有的（private）
  38. <a name="xLkSz"></a>
  39. ### 3-封装性思想的具体代码体现
  40. ```java
  41. 体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
  42. private double radius;
  43. public void setRadius(double radius){
  44.     this.radius = radius;
  45. }
  46. public double getRadius(){
  47.     return radius;
  48. }
  49. 体现二：不对外暴露的私有的方法
  50. 体现三：单例模式（将构造器私有化）
  51. 体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

4-Java规定的四种权限修饰符

  1. 权限从小到大的顺序为：private < 缺省 < protected < public

  2. 具体的修饰范围 | 修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程 | | —- | —- | —- | —- | —- | | private | Yes | | | | | （缺省） | Yes | Yes | | | | protected | Yes | Yes | Yes | | | public | Yes | Yes | Yes | Yes |

  3. 权限修饰符可用来修饰的权限说明：

4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能用：缺省、public

类的结构之三：构造器

1-属性赋值顺序

属性赋值的先后顺序

  • 默认初始化
  • 显式初始化
  • 构造器中初始化
  • 通过“对象 . 方法”或“对象 . 属性”的方式，赋值

2-JavaBean的概念

JavaBean是一种用Java语言写成的可重用组件。

  • 类是公共的
  • 一个无参的公共的构造器
  • 属性与对应的get、set方法

    关键字：this

    1-可以调用的结构

    属性、方法、构造器

2-this调用属性、方法

this理解为：当前对象 或 当前正在创建的对象

  • 在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略this。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明此变量是属性，而非形参。
  • 在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式，调用当前正在创建的对象属性或方法。但是通常情况下都选择省略this。特殊情况下，如果构造器的形参和类的属性同名时，必须显式的使用this表明此变量是属性，而非形参。

3-this调用构造器：

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

关键字：package/import

package的使用

  1. 使用说明
  • 为了更好的实现项目中类的管理，提供包的概念
  • 使用package声明类或接口所属的包，声明在源文件的首行
  • 包，属于标识符，遵循标识符的命名规则、规范
  • 每“.”一次，就代表一层文件目录

import的使用

import：导入

  1. 在源文件中显式的使用import结构导入指定包下的类、接口
  2. 声明在包的声明和类的声明之间
  3. 如果需要导入多个结构，则并列写出即可
  4. 可以使用”xxx.*”的方式，表示可以导入xxx报下的所有结构
  5. 如果使用的类或接口时java.lang包下定义的，则可以省略import结构
  6. 如果使用的类或接口是本包下定义的，则可以省略import结构
  7. 如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。
  8. import static：导入指定类或接口中的静态结构：属性或方法。