面向对象、封装、继承、多态、JavaBean

发布时间：2024年01月24日

二、面向对象

什么是对象

什么是对象？之前我们讲过，对象就是计算机中的虚拟物体。例如 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 属性

文章来源:https://blog.csdn.net/qq_51523316/article/details/135832784
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！