类与对象

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

Java类及类的成员：属性、方法、构造器；代码块、内部类
面向对象的大特征：封装性、继承性、多态性、(抽象性)
其它关键字：this、super、static、final、abstract、interface、package、import等
“大处着眼，小处着手”
面向对象与面向过程（理解）

面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
举例对比：人把大象装进冰箱。
完成一个项目（或功能）的思路：

面向对象中两个重要的概念：

类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)
- 面向对象程序设计的重点是类的设计
- 设计类，就是设计类的成员。
二者的关系：
- 对象，是由类new出来的，派生出来的。
  面向对象思想落地实现的规则一
1. 创建类，设计类的成员
1. 创建类的对象
1. 通过“对象.属性”或“对象.方法”调用对象的结构
补充：几个概念的使用说明
- 属性 = 成员变量 = field = 域、字段
- 方法 = 成员方法 = 函数 = method
- 创建类的对象 = 类的实例化 = 实例化类
  对象的创建与对象的内存解析
  典型代码：
```
Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。
```
  说明：
  如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
  意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

内存解析：

匿名对象:我们创建的对象，没显式的赋给一个变量名。即为匿名对象

特点：匿名对象只能调用一次。
举例：

new Phone().sendEmail();
        new Phone().playGame();
        new Phone().price = 1999;
        new Phone().showPrice();//0.0

应用场景：

PhoneMall mall = new PhoneMall();
//匿名对象的使用
mall.show(new Phone());
其中，
class PhoneMall{
    public void show(Phone phone){
        phone.sendEmail();
        phone.playGame();
    }
}

理解”万事万物皆对象”

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

扩展：JVM内存结构

编译完源程序以后，生成一个或多个字节码文件。
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。

《JVM规范》
虚拟机栈：即为平时提到的栈结构。我们将局部变量存储在栈结构中
堆：我们将new出来的结构（比如：数组、对象）加载在对空间中。补充：对象的属性（非static的）加载在堆空间中。
方法区：类的加载信息、常量池、静态域

类的结构之一：属性

类的设计中，两个重要结构之一：属性
对比：属性 vs 局部变量

相同点：

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

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

2.2 关于权限修饰符的不同

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

2.3 默认初始化值的情况：
属性：类的属性，根据其类型，都默认初始化值。
- 整型（byte、short、int、long：0）
- 浮点型（float、double：0.0）
- 字符型（char：0 （或’\u0000’））
- 布尔型（boolean：false）
- 引用数据类型（类、数组、接口：null）
局部变量：没默认初始化值。
- 意味着，我们在调用局部变量之前，一定要显式赋值。
特别地：形参在调用时，我们赋值即可。

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

补充：回顾变量的分类：
方式一：按照数据类型：

方式二：按照在类中声明的位置：

类的设计中，两个重要结构之二：方法
方法：描述类应该具的功能。
比如：Math类：sqrt()\random() ...
Scanner类：nextXxx() …
Arrays类：sort() \ binarySearch() \ toString() \ equals() \ …

举例：
public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}

方法的声明：
```
权限修饰符  返回值类型  方法名(形参列表){
           方法体
}
```
注意：static、final、abstract 来修饰的方法，后面再讲。

说明：
3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
- Java规定的4种权限修饰符：private、public、缺省、protected —>封装性再细说
3.2 返回值类型：返回值 vs 没返回值
- 3.2.1 如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
- 3.2.2 我们定义方法该不该返回值？
  - ①题目要求
  - ②凭经验：具体问题具体分析
3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
3.4 形参列表：方法可以声明0个，1个，或多个形参。
- 3.4.1 格式：数据类型1 形参1,数据类型2 形参2,…
- 3.4.2 我们定义方法时，该不该定义形参？
  - ① 题目要求
  - ② 凭经验：具体问题具体分析
3.5 方法体：方法功能的体现.
方法的使用中，可以调用当前类的属性或方法
特殊的：方法A中又调用了方法A:递归方法。
方法中，不可以定义方法。
关键字:return
return关键字：
1.使用范围：使用在方法体中
2.作用：
①结束方法
②针对于返回值类型的方法，使用”return 数据”方法返回所要的数据。
3.注意点：return关键字后面不可以声明执行语句。
方法的重载
方法的重载的概念
定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
总结：”两同一不同”:同一个类、相同方法名,参数列表不同：参数个数不同，参数类型不同

构成重载的举例：

举例一：Arrays类中重载的sort() / binarySearch()；PrintStream中的println()
举例二：

//如下的4个方法构成了重载
    public void getSum(int i,int j){
        System.out.println("1");
    }
    public void getSum(double d1,double d2){
        System.out.println("2");
    }
    public void getSum(String s ,int i){
        System.out.println("3");
    }
    public void getSum(int i,String s){
        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){
//        
//    }

如何判断是否构成方法的重载？
严格按照定义判断：两同一不同。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！
4.如何确定类中某一个方法的调用：
方法名 —-> 参数列表
面试题：方法的重载与重写的区别？
throws\throw
String\StringBuffer\StringBuilder
Collection\Collections
final\finally\finalize
…
抽象类、接口
sleep() / wait(
可变个数形参的方法

1.使用说明：
- 1.jdk 5.0新增的内容
- 2.具体使用：
  - 2.1 可变个数形参的格式：数据类型 … 变量名
  - 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
  - 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
  - 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
  - 2.5 可变个数形参在方法的形参中，必须声明在末尾
  - 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。

2.举例说明：

public void show(int i){
  }
  public void show(String s){
      System.out.println("show(String)");
  }
  public void show(String ... strs){
      System.out.println("show(String ... strs)");
      for(int i = 0;i < strs.length;i++){
          System.out.println(strs[i]);
      }
  }
  //不能与上一个方法同时存在
//    public void show(String[] strs){
//        
//    }
//调用时：
      test.show("hello");
      test.show("hello","world");
      test.show();
      test.show(new String[]{"AA","BB","CC"});

java的值传递机制

针对于方法内变量的赋值举例：

```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);

规则：<br />**如果变量是基本数据类型，此时赋值的是变量所保存的数据值。**<br />**如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。**
<a name="RlkU1"></a>
### 针对于方法的参数概念
**形参：方法定义时，声明的小括号内的参数**<br />**实参：方法调用时，实际传递给形参的数据**
<a name="n5oTd"></a>
### java中参数传递机制：值传递
规则：<br />**如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。**<br />**如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。**<br />推广：<br />**如果变量是基本数据类型，此时赋值的是变量所保存的数据值。**<br />**如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。**
<a name="M5QfP"></a>
### 典型例题与内存解析：
【例题1】<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/22782459/1632528292898-d02ba372-f6a4-4e78-bce5-5bcecc838f85.png#averageHue=%23f7f5f5&clientId=u94457119-bdb6-4&from=paste&height=386&id=u18fa372d&originHeight=386&originWidth=462&originalType=binary&ratio=1&rotation=0&showTitle=false&size=17720&status=done&style=shadow&taskId=u764070b4-bb4c-4afa-85b2-f2b5243832e&title=&width=462)<br />【例题2】<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/22782459/1632528313130-e9981149-070b-4808-ae63-57873e2eaa29.png#averageHue=%23f7f4f4&clientId=u94457119-bdb6-4&from=paste&height=382&id=ud1c9f7ff&originHeight=382&originWidth=764&originalType=binary&ratio=1&rotation=0&showTitle=false&size=32828&status=done&style=shadow&taskId=u5c67ca16-160f-4dff-93a1-b8f15fb0289&title=&width=764)
<a name="gS4tM"></a>
### 递归方法
1.定义：<br />递归方法：一个方法体内调用它自身。<br />2.如何理解递归方法？<br />方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。<br />递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。<br />3.举例：
```java
// 例1：计算1-n之间所自然数的和
    public int getSum(int n) {// 3
        if (n == 1) {
            return 1;
        } else {
            return n + getSum(n - 1);
        }
    }
    // 例2：计算1-n之间所自然数的乘积:n!
    public int getSum1(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * getSum1(n - 1);
        }
    }
    //例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
    //其中n是大于0的整数，求f(10)的值。
    public int f(int n){
        if(n == 0){
            return 1;
        }else if(n == 1){
            return 4;
        }else{
//            return f(n + 2) - 2 * f(n + 1);
            return 2*f(n - 1) + f(n - 2);
        }
    }
    //例4：斐波那契数列
    //例5：汉诺塔问题
    //例6：快排

类的结构之三：构造器

构造器（或构造方法）：Constructor

构造器的作用：
1.创建对象
2.初始化对象的信息

使用说明：

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

举例：

//构造器
public Person(){
    System.out.println("Person().....");
}
public Person(String n){
    name = n;
}
public Person(String n,int a){
    name = n;
    age = a;
}

关键字：this

1.可以调用的结构：属性、方法；构造器
2.this调用属性、方法 : this理解为：当前对象或当前正在创建的对象
2.1 在类的方法中，我们可以使用”this.属性”或”this.方法”的方式，调用当前对象属性或方法。但是，
通常情况下，我们都择省略”this.”。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式
的使用”this.变量”的方式，表明此变量是属性，而非形参。
2.2 在类的构造器中，我们可以使用”this.属性”或”this.方法”的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略”this.”。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用”this.变量”的方式，表明此变量是属性，而非形参。
3.this调用构造器：
①我们在类的构造器中，可以显式的使用”this(形参列表)”方式，调用本类中指定的其他构造器
②构造器中不能通过”this(形参列表)”方式调用自己
③如果一个类中有n个构造器，则最多有 n - 1构造器中使用了”this(形参列表)”
④规定：”this(形参列表)”必须声明在当前构造器的首行
⑤构造器内部，最多只能声明一个”this(形参列表)”，用来调用其他的构造器

关键字：package/import

package的使用

1.使用说明：

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

2.举例：
举例一：某航运软件系统包括：一组域对象、GUI和reports子系统

举例二：MVC设计模式

3. JDK中的主要包介绍：

import的使用：

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

编程知识

6. 面向对象-上（属性，方法，构造器）

类与对象

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

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

完成一个项目（或功能）的思路：

面向对象中两个重要的概念：

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

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

匿名对象:我们创建的对象，没显式的赋给一个变量名。即为匿名对象

理解”万事万物皆对象”

扩展：JVM内存结构

类的结构之一：属性

相同点：

不同点：

补充：回顾变量的分类：

类的设计中，两个重要结构之二：方法

举例：

方法的声明：

说明：

方法的使用中，可以调用当前类的属性或方法

方法的重载

方法的重载的概念