Java基础之面向对象-上

一、类与对象

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

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

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

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

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

类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)
- 面向对象程序设计的重点是类的设计
- 设计类，就是设计类的成员

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

4.面向对象思乡落地实现的规则一

创建类，设计类的成员
创建类的对象
通过"对象.属性"或"对象.方法"调用对象的结构

补充：几个概念的使用说明

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

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

经典代码

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

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

内存解析

6.匿名对象

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

特点

匿名对象只能调用一次

举例

new Phone().sendEmail();
new Phone().playGame();

new Phone().price = 1999;
new Phone().showPrice();

应用场景

PhoneMall mall = new PhoneMall();
// 匿名对象的使用
mall.show(new Phone());

class PhoneMall{
	public void show(Phone phone) {
		phone.sendEmail();
		phone.playGame();
	}
}

7.理解“万事万物皆对象”

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

二、类的结构之一：属性

对比：属性和局部变量

相同点：
- 定义变量的格式：数据类型变量名 = 变量值
- 先声明，后使用
- 变量都有其对应的作用域
不同点：
- 在类中声明的位置不同
  - 属性：直接定义在类的一对{}内
  - 局部变量：声明在方法内，方法形参、代码块内、构造器形参、构造器内部的变量
- 关于权限修饰符的不同
  - 属性
    - 可以用在声明属性是，指明其权限，使用权限修饰符
    - 常用的权限修饰符：private、public、缺省、protected ----> 封装性
  - 局部变量
    - 不可以使用权限修饰符
- 默认初始化值的情况
  - 属性
    - 类的属性，根据其类型，都默认初始化值
    - 整型（byte、short、int、long）：0
    - 浮点型（float、double）：0.0
    - 字符型（char）：0或'\u0000'
    - 布尔型（boolean）：false
    - 引用数据类型（类、数组、接口）：null
  - 局部变量
    - 没有默认初始化值，调用前一定要先赋值
  - 特别的：形参在调用时赋值即可
- 在内存中加载的位置
  - 属性：加载到对空间中（非static）
  - 局部变量：加载到栈空间

变量的分类

方式一：按照数据类型

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

三、类的结构之二：方法

类中方法的声明和使用

方法：描述类一个具有的功能
比如：Math类：sqrt()
1.举例：

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

2.方法的声明：

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

3.说明：
- 3.1 权限修饰符
  - private public 缺省 protected
- 3.2 返回值类型：有返回值和没有返回值类型
- 3.2.1 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用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 方法体：方法功能的体现
4.方法的使用中，可以调用当前类的属性或方法
- 特殊的
  - 方法A中又调用了方法A称为递归方法
  - 方法中不可以定义方法

return关键字的使用

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

方法的重载

1.方法的重载的概念

定义
- 在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可。
总结
- "两同一不同"
  - 同一个类、相同方法名
  - 参数列表不同：参数个数不同，参数类型不同

构成重载的举例

举例一

Arrays类中重载的sort() / binarySearch()；PrintStream中的println()

举例二

public void getSum(int i, int j) {
    System.out.println(i + j);
}

public void getSum(double d1, double d2) {
    System.out.println(d1 + d2);
}

public void getSum(String s, int i) {
	System.out.println(1);
}

public void getSum(int i, String s) {
	System.out.println(2);
}

不构成重载的举例

// 如下三个方法不能和上述四个方法构成重载
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.如何确定类中某一个方法的调用

方法名 --> 参数列表

面试题：方法的重载与重写的区别

可变个数形参的方法

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) {
    System.out.println("show(int i)");
}

public void show(String s) {
    System.out.println("show(String s)");
}

public void show(String ... strs) {
    System.out.println("show(String ... strs)");
}
// 不能与上一个方法同时存在
public void show(String[] strs) {

}

调用时：

public static void main(String[] args) {
    MethodArgsTest test = new MethodArgsTest();
    test.show(12); // "show(int i)"
    test.show("show"); // "show(String s)"
    test.show("shiw","wodd"); // "show(String ... strs)"
}

Java的值传递机制

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

public static void main(String[] args) {
		
    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);

}

规则：

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

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

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

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

规则：

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

推广：

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

4.内存解析

基本数据类型

引用数据类型

递归方法

1.定义

一个方法体内调用它自身

2.如何理解递归方法

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

3.举例

// 例1：计算1-n之间所有自然是的和
public int getSum(int n) {
    if (n == 1) {
        return 1;
    }else {
        return n + getSum(n - 1);
    }
}
// 例2：计算1-n之间所有自然是的乘积
public int getSum1(int n) {
    if (n == 1) {
        return 1;
    }else {
        return n * getSum(n - 1);
    }
}
// 例3：已知一个数列：f(0)=1,f(1)=4,f(n+2)=f(n+1)+f(n),其中n是大于0的整数，求f(10)的值
public int getSum2(int n) {
    if (n == 0) {
        return 1;
    }else if (n == 1) {
        return 4;
    }else {
        return 2 * getSum2(n - 1) + getSum2(n - 2);
    }
}

四、面向对象的特征之一：封装性

1.为什么要引入封装性？

我们程序设计追求“高内聚，低耦合”。
- 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
- 低耦合：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.问题引入

当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
此时，针对于属性就体现了封装性。

3.封装性思想具体体现

体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

private double radius;
public void setRadius(double radius){
	this.radius = radius;
}
public double getRadius(){
	return radius;
}

体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的

4.java规定的四种权限修饰符

4.1 权限从小到大顺序为：private > 缺省 > protected > public

4.2 具体的修饰范围

4.3 权限修饰符可用来修饰的结构说明：

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

五、类的结构：构造器

1.构造器的作用

创建对象
初始化对象的信息

2.使用说明

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

3.举例

//构造器
public Person(){
    System.out.println("Person().....");
}

public Person(String n){
    name = n;

}

public Person(String n,int a){
    name = n;
    age = a;
}

属性赋值顺序

总结：属性赋值的先后顺序

① 默认初始化

② 显式初始化

③ 构造器中初始化

④ 通过"对象.方法" 或 "对象.属性"的方式，赋值

以上操作的先后顺序：① - ② - ③ - ④

JavaBean的概念

所谓JavaBean，是指符合如下标准的Java类：
> 类是公共的
> 一个无参的公共的构造器
> 属性，且对应的get、set方法

六、关键字：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(形参列表)"，用来调用其他的构造器