二、面向对象
什么是对象
什么是对象？之前我们讲过，对象就是计算机中的虚拟物体。例如 System.out，System.in 等等。然而，要开发自己的应用程序，只有这些现成的对象还远远不够。需要我们自己来创建新的对象。
1. 抽取属性
代码里怎么表示类呢，看一下类的语法
class 类 {
字段;
构造方法(参数) {
}
返回值类型 方法名(参数) {
代码
}
}
-
字段定义与之前学过的局部变量、方法参数的定义类似，它们本质都是变量
-
构造方法也是一种方法，在将来创建对象时被使用，作用是为对象字段赋初始值
- 构造方法与类同名，不用加返回值类型声明
-
从属于对象的方法不用 static 修饰，它就代表对象的行为，这里先放一下
例如：
public class Phone {
// 类型 名字
String brand; // 品牌
String memory; // 内存
String size; // 大小
String color; // 颜色
double price; // 价格
public Phone(String b, String m, String s, String c, double p) {
brand = b;
memory = m;
size = s;
color = c;
price = p;
}
}
有了类，才能创建对象，创建对象的语法
new 类构造方法(参数)
例如
public class TestPhone {
public static void main(String[] args) {
Phone p1 = new Phone("苹果", "128G", "6.1寸", "星光色", 5799.0);
Phone p2 = new Phone("红米", "4G", "6.53寸", "金色", 1249.0);
Phone p3 = new Phone("华为", "4G", "6.3寸", "幻夜黑", 999.0);
System.out.println(p1.color); // 获取p1的颜色
System.out.println(p1.price); // 获取p1的价格
p1.price = 3000.0; // 修改p1的价格
System.out.println(p1.price); // 获取p1的价格
}
}
总结一下：
- 类是对象的模板，用字段描述对象将来长什么样，用构造给字段变量赋值
- 对象说白了，就是一组数据的集合，但这些数据不是乱写的，有什么，不该有什么，得按类的规则来
2. 字段默认值
如果字段没有通过构造方法赋值，那么字段也会有个默认值
| 类型 | 默认值 | 说明 |
|---|---|---|
| byte short int long char | 0 | |
| float double | 0.0 | |
| boolean | false | |
| 其它 | null |
比如说，想加一个字段 available 表示手机上架还是下架，这时就可以使用默认值统一设置
public class Phone {
// 类型 名字
String brand; // 品牌
String memory; // 内存
String size; // 大小
String color; // 颜色
double price; // 价格
boolean available; // 是否上架
public Phone(String b, String m, String s, String c, double p) {
brand = b;
memory = m;
size = s;
color = c;
price = p;
}
}
- 构造方法里不对 available 字符赋值，默认为下架（false）
- 要设置为默认上架（true）可以给字段直接赋值为 true 或在构造方法里给它赋值为 true
3. this
当方法参数与字段重名时，需要用在字段前面加 this 来区分
public class Phone {
// 类型 名字
String brand; // 品牌
String memory; // 内存
String size; // 大小
String color; // 颜色
double price; // 价格
boolean available; // 是否上架
public Phone(String brand, String memory, String size, String color, double price) {
this.brand = brand;
this.memory = memory;
this.size = size;
this.color = color;
this.price = price;
this.available = true;
}
}
- 前面有 this 的 brand 对应的是字段的 brand，前面没有 this 的 brand 对应的是方法参数中的 brand
- this 代表对象自己，但只能在构造方法、对象方法中使用
- 没有重名的情况下可以省略 this
提示
- 如果觉得自己写 this 比较麻烦，可以使用 IDEA 的快捷键 ALT + Insert 来生成构造方法
- 用 IDEA 生成的构造方法字段和方法参数都是用 this 区分好的
4. 无参构造
带参数的构造并不是必须的，也可以使用无参构造，例如
public class Student {
String name; // 姓名 null
int age; // 年龄 0
Student() {
}
}
使用无参构造创建对象示例如下
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student();
s1.name = "张三";
s1.age = 18;
System.out.println(s1.name);
System.out.println(s1.age);
}
}
- 字段赋值现在不是构造方法内完成了，而是先创建了对象
- 再通过【对象.字段】来赋值，最终赋值效果是一样的
无参构造有个特性：
- 默认提供一个无参构造，但是如果你书写了带参构造方法，此时默认的无参构造方法需要你重新书写
5. 对象方法演化
方法执行总得需要一些数据，以前我们学习的主要是这种 static 方法，它的数据全部来自于方法参数。
今天开始，要学习对象方法，顾名思义，它是从属于对象的方法，语法上要去掉 static，变成这个样子
public class Cal {
double p;
int m;
double yr;
public Cal(double p, int m, double yr) {
this.p = p;
this.m = m;
this.yr = yr;
}
double cal() {
double mr = yr / 100.0 / 12;
double pow = Math.pow(1 + mr, m);
return m * p * mr * pow / (pow - 1);
}
}
看看改动成对象方法后，都有哪些代码发生了变化？为啥不需要参数了呢？
这种对象方法执行需要的数据：
- 一部分来自于方法参数
- 另一部分来自于方法从属的对象
既然我们讲的这种对象方法都从属于 Calculator 对象了，那么方法参数这里是不是就没必要再加一个 Calculator 对象了啊
方法体内这些本金、月份、利率，都来自于方法所从属的对象的字段。不用写前面的 c. 了
- 当然，我们这个例子中，本金、月份、利率，在方法所从属的那个 Calculator 对象中已全部包含，因此方法上也无需更多其它参数。如果方法执行的有些数据，对象未包含，那你还是得添加方法参数
最后，方法调用时，为了表达与对象的这种从属关系，格式也应变化为：对象.方法()
public class TestCal {
public static void main(String[] args) {
// 对比相同本金，不同利率和贷款月份，计算总还款额(等额本息)，看哪个更划算一些
Cal c1 = new Cal(100000.0, 24, 4.5);
double r1 = c1.cal();
System.out.println("4.5% 利率借 2 年：" + r1);
Cal c2 = new Cal(100000.0, 12, 6.0);
double r2 = c2.cal();
System.out.println("6.0% 利率借 1 年：" + r2);
}
}
例如：
- c1.cal() 执行时，cal 方法就知道，我执行需要的 y，m，yr 这些数据来自于 c1 对象
- c2.cal() 执行时，cal 方法就知道，我执行需要的 y，m，yr 这些数据来自于 c2 对象
对象的方法演化完毕
静态方法 vs 对象方法
- 而 static 方法需要的数据，全都来自于方法参数，它没有关联对象，没有对象的那一部分数据
- 对象方法执行的数据，一部分数据从方法参数转移至对象内部
6. 静态变量
public class Circle {
double r; // 半径
static double pi = 3.14; // 静态变量, 所有圆对象共享它
public Circle(double r) {
this.r = r;
}
double area() {
return pi * r * r;
}
}
回到测试代码
public class TestCircle {
public static void main(String[] args) {
Circle c1 = new Circle(1.0);
c1.pi = 3.14;
Circle c2 = new Circle(1.0);
c2.pi = 3;
System.out.println(c1.area()); // 圆的面积计算结果为 3
System.out.println(c2.area()); // 圆的面积计算结果为 3
}
}
两次计算结果相同，因为 c1.pi 和 c2.pi 都是修改的同一个变量。注意几点
- 静态变量虽然也能通过对象来使用，但建议通过类名类使用，例如上例中，应该这么写：
Circle.pi = 3 - 如果不希望 pi 的值改来改去，可以再加一个 final 修饰符：
static final pi = 3.14- final 加在变量上，表示该变量只能赋值一次，之后就不能修改了
- 最后要知道，计算如果需要更为精确的 pi 值，可以用
Math.PI，上面我们自己写的 pi 只是为了举例需要
7. 四种变量
至今为止，一共学习了四种变量，下面就对它们做一个简单对比
public class TestVariable {
public static void main(String[] args) {
m(10);
if (true) {
C c1 = new C(30); // 出了if语句块,c1 对象就无法使用了，随带的它内部的对象变量也失效
}
}
static void m(int a) { // 1. 参数变量, 作用范围是从方法调用开始，直到方法调用结束
for (int i = 0; i < 10; i++) {
int b = 20; // 2. 局部变量, 作用范围从定义开始，到包围它的 } 为止, 必须赋初值才能使用
System.out.println(b);
}
}
}
class C {
int c; // 3. 对象变量(成员变量) 从对象创建开始, 到对象不能使用为止
public C(int c) {
this.c = c;
}
static int d = 40; // 4. 静态变量, 从类加载开始, 到类卸载为止
}
- 方法参数的作用范围就是从方法调用开始，直到这个方法结束为止，这是参数变量的作用范围
- 局部变量的作用范围要更小一些，它是从局部变量定义开始，到包围它的 } 为止
- 局部变量跟其它几个变量有个不一样的地方，它需要先赋值，再使用，否则会报错
- 对象变量（其实就是对象中的字段）的作用范围是从对象创建开始，到对象不能使用为止，它的作用范围和对象是一样的
- 对象变量是每个对象私有的
- 静态变量，它的作用范围从类加载开始，到类卸载为止
- 第一次用到这个类时，会把类的字节码加载到虚拟机里，这称之为类加载
- 某个类以后不会再用到，类就会从虚拟机中卸载
- 静态变量是所有对象共享的
三. 继承
1. 继承语法
阅读代码发现，这两个类中有一些相同的对象变量和方法代码，能否减少这两个类的重复代码，答案是继承
继承的语法
class 父类 {
字段;
方法() {}
}
class 子类 extends 父类 {
}
可以用父子类继承的方式减少重复声明，例如 A 是父类，B，C 类是子类，那么
class A {
String name;
void test() {}
}
class B extends A {
}
class C extends A {
}
- 子类能从父类中继承它所声明的字段、方法
但注意，构造方法不能继承
- 给父类加一个带参构造，发现子类都报错了，为什么呢？一方面构造方法不能继承
- 另一方面对子类来说，你得调用父类的带参构造给父类的 name 字段赋值吧
- 子类得先创建自己的构造方法，然后用 super 调用父类的带参构造，快捷键，alt+enter
class A {
String name;
A(String name) {
this.name = name;
}
void test() {}
}
class B extends A {
B(String name) {
super(name);
}
}
class C extends A {
C(String name) {
super(name);
}
}
2. java 类型系统
java 中的类型分成了两大类
-
基本类型 primitive type
- 整数 byte short int long
- 小数 float double
- 字符 char
- 布尔 boolean
-
引用类型 reference type
- 除了基本类型以外的其它类型都属于引用类型，引用类型可以看成是由基本类型组成的复杂类型，例如
- String 内部由 byte[] 组成，而 byte[] 又是由 byte 组成
- Phone 内部价格是 double，品牌等都是 String
- 包装类型
- 每个基本类型都有与之对应的包装类型，见下表
- 包装类型是对象，既然是对象，就可以有对象的特征，如字段、方法、继承 …
- null 值，不能对 null 值进一步使用（使用字段、调用方法），例如
- String str = null;
- str.length() 求字符串长度时，就会出现 NullPointerException 空指针异常
- 使用引用类型之前，最好做非空判断，例如：if(str != null) 再做进一步操作
- 除了基本类型以外的其它类型都属于引用类型，引用类型可以看成是由基本类型组成的复杂类型，例如
| 包装类型 | 基本类型 | 备注 |
|---|---|---|
| Byte | byte | |
| Short | short | |
| Integer | int | |
| Long | long | |
| Float | float | |
| Double | double | |
| Character | char | |
| Boolean | boolean |
3. 类型转换
1) 基本类型转换
- 整数和 char 7种类型
- 顺箭头方向隐式转换
- 逆箭头方向需要显式强制转换，可能会损失精度
- boolean 类型无法与其它基本类型转换
- short 与 char 也不能转换
隐式转换
byte a = 10;
int b = a; // 自动从 byte 转换为 int
强制转换
int c = 20;
byte d = (byte) c; // 在圆括号内加上要转换的目标类型
强制转换可能损失精度
int c = 1000;
byte d = (byte) c; // byte 的数字范围就是在 -128 ~ 127，存不下 1000，最后结果是 -24
2) 包装类型转换
- 包装类型和它对应的基本类型之间可以自动转换，如
int a = 20;
Integer b = a;
Integer c = new Integer(30);
int d = c;
3) 引用类型转换
Java 继承的特点
- 单继承，子类只能继承一个父类
- Object 是所有其它类型直接或间接的父类型，定义 class 时，不写 extends 这个类也是继承自 Object
- 子类与父类、祖先类之间，可以用【是一个 is a】的关系来表达
向上向下转型
-
顺箭头方向（向上）隐式转换，即子类可以用它的更高层的类型代表，表达一种是一个的关系
-
例如一个猫对象，可以隐式转换为动物
Animal a = new Cat(); // 用父类型的变量 a 代表了一只猫对象 Object b = new Cat(); // 用祖先类型的变量 b 代表了一只猫对象
-
-
逆箭头方向（向下）首先要符合是一个规则，然后用显式强制转换
-
如果一个动物变量，它代表的是一个猫对象，可以通过强制转换还原成猫
Animal a = new Cat(); Cat c = (Cat) a; -
如果一个动物变量，它代表的是一个猫对象，即使强制转换，也不能变成狗，编译不报错，但运行就会出现 ClassCastException
Animal a = new Cat(); Dog d = (Dog) a;
-
为什么需要向上转型？主要是为了使用父类统一处理子类型
例1：
static void test(Animal a) {
}
这时，此方法既可以处理猫对象，也可以处理狗对象
test(new Cat());
test(new Dog());
例2：用父类型的数组，可以既装猫对象，也装狗对象
Animal[] as = new Animal[]{ new Cat(), new Dog() };
类型判断
Animal a = new Cat();
如果想知道变量 a 代表对象的实际类型，可以使用
System.out.println(a.getClass()); // 输出结果 class com.itheima.Cat
- getClass() 是对象从 Object 类中继承的方法
如果想检查某个对象和类型之间是否符合【是一个】的关系，可以使用
Animals a = new Cat();
Object b = new Cat();
System.out.println(a instanceof Cat); // true
System.out.println(a instanceof Dog); // false
System.out.println(b instanceof Animal);// true
经常用在向下转型之前，符合是一个的关系，再做强制类型转换
4) 其它类型转换
除了以上转换规则，在赋值、方法调用时，一旦发现类型不一致，都会提示编译错误，需要使用一些转换方法才行
例如：两个字符串对象要转成整数做加法
String a = "1";
String b = "2";
System.out.println(a + b); // 这样不行，字符串相加结果会拼接为 12
System.out.println(Integer.parseInt(a) + Integer.parseInt(b)); // 转换后再相加，结果是 3
四. 多态
1. 何为多态
同一个方法在执行时，表现出了不同的行为，称这个方法有多态的特性。
2. 多态前提
不是所有方法都有多态，像之前写过的静态方法，不管怎么调用，表现出的行为都是一样的。那么要成为这种多态方法要满足哪些条件呢？先来看看多态这个词是怎么来的
多态，英文 polymorphism 本意是多种形态，是指执行一个相同的方法，最终效果不同。为什么会有这种效果？
方法虽然都是同一个，但调用它们的对象相同吗？看起来都是 Animal 啊，其实不是
- 之前讲向上转型时讲过，子类对象可以向上转型，用父类型代表它
- 这里的每个 Animal a 只是代表右侧对象，右侧的实际对象，是一些子类对象，大家应该都猜出来了，分别是猫、狗、猪
- 这种有多态特性的方法在调用时，会根据实际的对象类型不同而行为不同
- 而正是每个子类对象中的 say 方法写的不一样，从而表现出不同的叫声
方法具备多态性的两个条件：
条件1
用父类型代表子类对象，有了父类型才能代表多种子类型，只有子类型自己，那将来有多种可能吗，不行吧？
- 比如说无论获取数组还是遍历，都使用猪类型，那最终也只能发出猪叫声，这是第一个前提条件
条件2
第二个条件，是子类和父类得有一个相同的 say 方法。如果子类存在与父类相同的方法，称发生了方法重写。重写方法要满足：
- 方法名和参数都完全相同
- 对象方法才能重写
- 检查是否发生了重写可以用 @Override 注解，它可以帮我们检查子类方法是否符合重写规则
只有重写了，才能表现出多种形态，如果没有重写，调用的都是父类方法，最终的效果是相同的，没有多态了
3. 贷款计算器 - 多态改造
在控制器代码中，需要用 if else 来判断使用哪个 Calculator 对象完成计算，Calculator0 还是 Calculator1，将来如果贷款类型越来越多，就要写好多 if else，如何避免呢？利用多态的原理，让 jvm 帮我们做判断
- Animal a = … 利用多态，a 如果代表的是狗对象，走狗的逻辑，代表的是猫对象，走猫的逻辑
- Calculator c = … 利用多态，c 如果代表的是等额本息对象，走等额本息逻辑，代表的是等额本金对象，走等额本金的计算逻辑
1) 产生方法重写
原来的
- Calculator0 的方法叫 cal0 和 details0
- Calculator1 的方法叫 cal1 和 details1
- Calculator 父类中没有这俩方法
显然不行
改写如下：
class Calculator {
// ...
String[] cal() {
return null;
}
String[][] details() {
return null;
}
}
class Calculator0 extends Calculator {
Calculator0(double p, int m, double yr) {
super(p, m, yr);
}
@Override
String[] cal() {
// ...
}
@Override
String[][] details() {
// ...
}
}
class Calculator1 extends Calculator {
Calculator1(double p, int m, double yr) {
super(p, m, yr);
}
@Override
String[] cal() {
// ...
}
@Override
String[][] details() {
// ...
}
}
2) 父类型代表子类对象
根据类型创建不同 Calculator 对象有点小技巧（避免了创建对象时的 if else），如下：
Calculator[] getCalculator(double p, int m, double yr) {
return new Calculator[] {
new Calculator0(p, m, yr),
new Calculator1(p, m, yr)
};
}
最后通过父类型来执行，表面上是调用 Calculator 父类的 cal() 和 details() 方法，但实际执行的是某个子类的 cal() 和 details() 方法，通过多态，避免了方法调用时的 if else 判断
@Controller
public class CalController {
Calculator[] getCalculator(double p, int m, double yr) {
return new Calculator[] {
new Calculator0(p, m, yr),
new Calculator1(p, m, yr)
};
}
@RequestMapping("/cal")
@ResponseBody
String[] cal(double p, int m, double yr, int type) {
Calculator[] cs = getCalculator(p, m, yr);
return cs[type].cal();
}
@RequestMapping("/details")
@ResponseBody
String[][] details(double p, int m, double yr, int type) {
Calculator[] cs = getCalculator(p, m, yr);
return cs[type].details();
}
}
cs[type] 是根据类型找到对应的子类对象，例如
- type = 0 时，其实是获取了数组中索引 0 的对象，即 new Calculator0(p, m, yr)
- type = 1 时，其实是获取了数组中索引 1 的对象，即 new Calculator1(p, m, yr)
3) 小结
关于多态的应用的例子讲完了，总结一下
前提
- java 中的类型系统允许用父类型代表子类型对象，这是多态前提之一
- 子类和父类之间发生了方法重写，这是多态前提之二
效果
- 调用父类型的方法，可能会有不同的行为，取决于该方法是否发生了重写
什么时候使用多态
- 多态能够用一个父类型，统一操作子类对象
- 原本要根据类型做判断，写很多 if else 的地方，都可以考虑使用多态来消除 if else，提高扩展性
五. 封装
1.加强封装
Java 中可以用访问修饰符来对字段或方法进行访问权限控制，一共有四种
| 名称 | 访问权限 | 说明 |
|---|---|---|
| public | 标识的【字段】及【方法】及【类】，谁都能使用 | |
| protected | 标识的【字段】及【方法】，只有同包类、或是子类内才能使用 | |
| 标识的【字段】及【方法】及【类】，只有同包类才能使用 | 默认访问修饰符 | |
| private | 标识的【字段】及【方法】只有本类才能使用（或内部类） |
- 类上能使用的访问修饰符，只有 public 和默认两种
private
package com.itheima.encapsulation;
public class Car {
private int y; // 私有的
private void test() { } // 私有的
void update() {
// 本类内可以使用
System.out.println(this.y);
this.test();
}
}
package com.itheima.encapsulation; // 同包测试类
public class Test1 {
public static void main(String[] args) {
Car car = new Car();
System.out.println(car.y); // 错误，不能访问 private 字段
car.test(); // 错误，不能访问 private 方法
}
}
默认
package com.itheima.encapsulation;
public class Car {
int y; // 默认的
void test() {} // 默认的
void update() {
// 本类内可以使用
System.out.println(this.y);
this.test();
}
}
package com.itheima.encapsulation; // 同包测试类
public class Test2 {
public static void main(String[] args) {
Car car = new Car();
System.out.println(car.y); // 同包可以使用
car.test(); // 同包可以使用
}
}
package com.itheima; // 不同包测试类
import com.itheima.encapsulation.Car;
public class Test3 {
public static void main(String[] args) {
Car car = new Car();
System.out.println(car.y); // 错误，不同包不能访问 默认 字段
car.test(); // 错误，不同包不能访问 默认 方法
}
}
protected
package com.itheima.encapsulation;
public class Car {
protected int y; // 受保护的
protected void test() {} // 受保护的
// 本类内可以使用
void update() {
System.out.println(this.y);
this.test();
}
}
package com.itheima; // 不同包子类
import com.itheima.encapsulation.Car;
public class SubCar extends Car {
void display() {
System.out.println(this.y); // 不同包子类内可以使用
this.test(); // 不同包子类内可以使用
}
}
尽可能让访问范围更小
- private < 默认 < protected < public
- 尤其是字段，建议设置为 private
- 想让子类用 考虑设置为 protected
2. JavaBean
JavaBean 规范
- 字段私有, 提供公共 get、set、is 方法来访问私有字段
- 获取字段值用 get 方法
- 获取 boolean 类型字段值用 is 方法
- 修改字段值用 set 方法
- get、set、is 方法的命名必须是：getXXX，setXXX，isXXX
- 其中 XXX 是字段名（首字母变大写）
- 这些方法可以用 idea 的 ALT + Insert 快捷键生成
- 最好提供一个无参的构造
- 最好实现一个接口 Serializable
例子
class Teacher implements Serializable {
private String name; // 小写
private boolean married; // 已婚
private int age;
public boolean isMarried() { // 对 boolean 类型，用这种 isXXX
return this.married;
}
public void setMarried(boolean married) {
this.married = married;
}
// get 方法 用来获取私有字段值
public String getName() { // get 后面单词首字母要大写
return this.name;
}
// set 方法 用来修改私有字段值
public void setName(String name) {
this.name = name;
}
public Teacher(String name, boolean married) {
this.name = name;
this.married = married;
}
public Teacher() {
}
}
测试类
public class TestJavaBean {
public static void main(String[] args) {
Teacher t = new Teacher("张老师", false);
// 全部改用公共方法来间接读写字段值
System.out.println(t.getName());
System.out.println(t.isMarried());
t.setMarried(true);
System.out.println(t.isMarried());
}
}
Java Bean 主要用来封装数据，不会提供哪些包含业务逻辑的方法
最后要区分两个名词：字段和属性
- 有 getXXX、setXXX、isXXX 方法的，可以称该对象有 XXX 属性（首字母变小写）
- 例如，上面的 Teacher 类有 name 属性和 married 属性
- 没有对应 get、set、is 方法的，不能说有属性
- 例如，上面的 Teacher 类没有 age 属性
![[docker] Docker 网络](https://img-blog.csdnimg.cn/direct/3a8f0fad1348469bbdb41bd5d65dbd57.png)
