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

  • 面向过程：

​ 强调的是功能行为，以函数为最小单位，考虑怎么做。

  • 面向对象：

​ 强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
举例对比：人把大象装进冰箱。

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

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

3. 类和对象的使用–面向对象思想落地实现

面向对象程序设计的重点是类的设计
设计类，就是设计类的成员。
创建类的对象 = 类的实例化 = 实例化类

  • 创建类、设计类的成员

  • 创建类的对象

  • 通过“对象.属性”或“对象.方法”调用对象的结构

  • 几个概念的使用说明
    属性 = 成员变量 = field = 域、字段
    方法 = 成员方法 = 函数 = method

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

  • 理解”万事万物皆对象”

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

      • Scanner,String等

      • 文件：File

      • 网络资源：URL

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

4. 类的实例化与对象的内存解析

图略看，现在只需要记住：栈，堆，方法区就够了

栈（复习）：方法内定义的变量，存储在栈中。

堆（复习）：new出来的结构。包括对象中的属性

方法区（新增）：存放类的模板，比如：Person类的模板

内存解析：
编译完源程序以后，生成一个或多个字节码文件。
我们使用 JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。

意味着，需要` 将字节码文件对应的类加载到内存中，涉及到内存解析，图如下。

对象存放位置

典型代码：

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

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

第2次出现JVM内存结构

对象的属性（非static的)加载在堆空间中。

方法区：存放类的模板

无标题2

5. 成员变量与局部变量的对比

对比：属性  vs  局部变量

1.相同点：

	1.1 定义变量的格式：数据类型  变量名 = 变量值
	1.2 先声明，后使用
	1.3 变量都有其对应的作用域

2.不同点：

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）

局部变量：加载到栈空间

6. 方法的作用与方法的声明

方法：描述类应该具的功能。

  • 比如：Math类：sqrt()\random() …

Scanner类：nextXxx() …
Arrays类：sort() \ binarySearch() \ toString() \ equals() \ …

1. 举例：

  • public void eat(){}
  • public void sleep(int hour){}
  • public String getName(){}
  • public String getNation(String nation){}

2. 方法的声明：

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

注意： static、final、abstract来修饰的方法,后面再讲

3. 说明：

3.1. 关于权限修饰符：

默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected 等讲封装性再细说

3.2. 返回值类型：

返回值 vs 没返回值

  • 如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用 return 关键字来返回指定类型的变量或常量：“return 数据”。

  • 如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。

  • 我们定义方法该不该返回值？
    ① 按要求
    ② 凭经验：具体问题具体分析

3.3. 方法名：

属于标识符，遵循标识符的规则和规范，“见名知意”

3.4. 形参列表:

方法可以声明0个，1个，或多个形参。

  • 格式：数据类型1 形参1,数据类型2 形参2,…
  • 我们定义方法时，该不该定义形参？
    ① 题目要求
    ② 凭经验：具体问题具体分析
3.5. 方法体：

方法功能的体现。

3.6. return关键字

1.使用范围：使用在方法体中
2.作用：
① 结束方法
② 针对于返回值类型的方法，使用”return 数据”方法返回所要的数据。
3.注意点
return关键字后面不可以声明执行语句。

  • 方法的使用中，可以调用当前类的属性或方法
  • 方法A中又调用了方法A:递归方法。
  • 方法中，不可以定义方法。

7. 方法的内存解析

第3次出现JVM内存结构

每个方法对应一个栈帧

无标题3

8. 对象数组的使用及内存解析

略过

9. 方法应用 1：方法的重载

1. 方法的重载的概念

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

"两同一不同":同一个类、相同方法名;参数列表不同：参数个数不同，参数类型不同

2. 构成重载的举例：

举例一：

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

1
2
3
4
5
6
7
8
9
10
11
12
//如下的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");	}

不构成重载的举例：

1
2
3
4
5
6
7
8
9
10
11
12
//如下的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){
//		
//	}

3. 如何判断是否构成方法的重载？

严格按照定义判断：两同一不同。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！

4. 如何确定类中某一个方法的调用：

方法名 —> 参数列表

10. 方法应用 2：可变个数形参的方法

可变个数形参的区别

1. 使用说明：

jdk 5.0新增的内容

2. 具体使用：

1 可变个数形参的格式：

​ 数据类型 … 变量名
​ 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
2 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
3 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
4 可变个数形参在方法的形参中，必须声明在末尾
5 可变个数形参在方法的形参中,最多只能声明一个可变形参。

3. 举例：

1
2
3
4
5
public void show(int i){
}
public void show(String s){
    System.out.println("show(String)");
}	
1
2
3
4
5
6
7
8
public void show(String ... strs){
    System.out.println("show(String ... strs)");

    for(int i = 0;i < strs.length;i++){
        System.out.println(strs[i]);
    }
}
//不能与上一个方法同时存在
1
2
3
//	public void show(String[] strs){
//		
//	}

调用时：

1
2
3
4
test.show("hello");
test.show("hello","world");
test.show();
test.show(new String[]{"AA","BB","CC"});

11. 方法应用 3：方法值传递机制的剖析

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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);
//1002           1002

注意理解这段：

1
2
3
o2.orderId = 1002;			//传的地址值==
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
//1002           1002 (同一个实体)

规则：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

2. 针对于方法的参数概念

形参：方法定义时，声明的小括号内的参数。实参：方法调用时，实际传递给形参的数据

3. 参数传递机制：值传递

规则：
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

推广：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

12. 方法应用4：递归方法

1. 定义：

递归方法：一个方法体内调用它自身。

2. 如何理解递归方法？

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。`