参考书籍《Java编程思想》

参考网页编程网

如何理解“对象”和“类”

定义

  • 类： 是一个模板，它描述一类对象的行为和状态。

  • 对象：对象 ：对象是类的一个实例（ 对象不是找个女朋友🤣），有状态和行为。

“类”其实就是“类型”，比如“int”就是整数类型，9是int类型的一个实例，可以称之为“对象”。类可以理解为具有某些共有特点的物品的集合（比如“马”这个类），对象就是该集合中的一个例子。

Java是面向对象的编程，面向对象 ( Object Oriented )就是将现实问题构建关系，然后抽象成 类 ( class )，给类定义属性和方法后，再将类实例化成 实例 ( instance ) ，通过访问实例（也就是对象）的属性和调用方法来进行使用。

也就是说对象其实可以理解为：每一个对象其实就是一个服务提供着。编程的过程中只需要考虑自己需要哪些服务，然后引用对应的对象来解决问题。所以编程的重点不在于思考具体过程，而是“类”和“对象”的抽象所以称之为“面想对象编程”

封装

在面向对象程式设计方法中，封装（Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。（就是告诉你本类可以提供的服务是什么，单不告诉你具体实现，你只管用就行了，如sort()函数）

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。（程序通过接口来访问类及其属性和方法）

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。（如国别的类可以直接访问本类的方法以及重写本类方法那么会导致你在修改本类时要考虑调用这个类的其他类的代码）

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

1
2
3
4
5
// private 关键字限制了此类的属性只有本类可以访问
public class Person {
    private String name;
    private int age;
}

一个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Juice{
	private String juicename;  //如果这里private换成public那么会恢复正常
	public Juice(String name) {
		this.juicename=name;
	}

	public String printname() {
		System.out.println(juicename);
		return juicename;
	}
	
}


public class test1 {
    public static void main(String[] args){

        Juice myjuice=new Juice("橘子水");
        System.out.println(myjuice.juicename); //无法访问myjuice.juicename，报错
    }

}

继承

继承是面向对象的三大特征之一。继承和现实生活中的“继承”的相似之处是保留一些父辈的特性（属性或者方法），从而减少代码冗余，提高程序运行效率。

1
2
3
修饰符 class class_name extends extend_class {
    // 类的主体
}

java中的继承是使用的extends关键字，更好的描述了子类其实是对父类的一种扩展，子类其实是一种特殊的父类。

  • 一个例子

父类people

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class People {
    public String name; // 姓名
    public int age; // 年龄
    public String sex; // 性别
    public String sn; // 身份证号
    public People(String name, int age, String sex, String sn) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.sn = sn;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别：" + sex + "\n身份证号：" + sn;
    }
}

子类student

1
2
3
4
5
6
7
8
9
10
11
12
public class Student extends People {
    private String stuNo; // 学号
    private String department; // 所学专业
    public Student(String name, int age, String sex, String sn, String stuno, String department) {
        super(name, age, sex, sn); // 调用父类中的构造方法
        this.stuNo = stuno;
        this.department = department;
    }
    public String toString() {
        return "姓名：" + name + "\n年龄：" + age + "\n性别：" + sex + "\n身份证号：" + sn + "\n学号：" + stuNo + "\n所学专业：" + department;
    }
}

这里重写了父类toString方法

多态

多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。

简单来说，多态其实就是子类重写了父类的方法，而且子类储存在了父类之中。结果导致系统不确定引用数据的具体类型和具体方法，表现为具有多个状态，只有在运行时才可以确定具体状态，称为多态性。多态性提高了代码的复用性。

Java 实现多态有 3 个必要条件

  • 继承
  • 重写
  • 父类引用指向子类

一个例子

创建 Figure 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Figure {
    double dim1;
    double dim2;
    Figure(double d1, double d2) {
        // 有参的构造方法
        this.dim1 = d1;
        this.dim2 = d2;
    }
    double area() {
        // 用于计算对象的面积
        System.out.println("父类中计算对象面积的方法，没有实际意义，需要在子类中重写。");
        return 0;
    }
}

创建子类，并重写方法

1
2
3
4
5
6
7
8
9
public class Rectangle extends Figure {
    Rectangle(double d1, double d2) {
        super(d1, d2);   //向上转型，意思就是子类也可以是是父类
    }
    double area() {
        System.out.println("长方形的面积：");
        return super.dim1 * super.dim2;
    }
}

父类引用指向子类

1
2
3
4
5
6
7
public class Test {
    public static void main(String[] args) {
        Figure figure; // 声明Figure类的变量
        figure = new Rectangle(9, 9); //父类引用指向子类
        System.out.println(figure.area());
    }
}

从上述代码可以发现，figure 变量的对象是 Rectangle 但Rectangle类是Figure的子类，而且可以向上转型为该类，从而实现多态。