Java面向对象知识详解——三大基本特征

前言

相信很多程序员在最初接触Java的时候就听过，Java中一切皆对象那么什么是面向对象呢？前言先介绍什么是面向对象和面向过程，这样有助于读者更好的理解面向对象

什么是面向过程？

面向过程顾名思义是一种以过程为中心的编程思想，自顶向下的编程模式，试想一下c语言。
我们将问题分解开，一个一个函数来实现一个一个的步骤，依次调用。

也就是说在进行面向过程编程时候，可以先定义一个函数，然后使用if-else等方式执行代码，下面我们来看用面向过程实现一个简单算法——冒泡排序

#include
using namespace std;
void print(int n, int *a, int cur)
{
	if (cur == n)//递归边界
	{
		for (int i = 0; i < n; i++)
		{
			printf("%d", a[i]);
		}
		printf("\n");
	}
	else for (int i = 1; i <= n; i++)
	{
		int OK = 1;
		for (int j = 0; j < cur; j++)
		{
			if (a[j] == i)//判断i是否出现过
				OK = 0;
			if (OK)//i没有出现过下一个
			{
				a[cur] = i;
				print(n, a, cur + 1);//递归
			}
		}
	}
}
int main()
{

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

自顶向下用函数来实现功能

什么是面向对象？

现在主流的面向对象的编程语言代表有：c++，java，c#……
简单的来说，面向对象，程序员将问题分解为一个一个的步骤，对每个步骤进行抽象，形成对象，通过不同对象之间的调用，组合形成问题

他之所以如此受欢迎，是因为他更符合人类的思考方式，用这种方式编写出来的代码，可拓展性，可维护性都更高，这个我们后面再说。

面向对象有3大基本特征，6大基本原则，我们在下文中逐一介绍：

三大基本特征

对事物的抽象，理解，这里就要请出面向对象的三大基本特征：封装，继承，多态

封装

所谓封装，就是把客观的事物封装为抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的类或对象隐藏信息

简单的来说，一个类就是一个封装了数据和操作这些代码的实体。我们可以人为的设定某些代码私有，不能被外界访问

好处：对内部数据的不同级别包含，防止程序中无关的部分被意外被改变

举例：

class Rectangle {
    public Rectangle(int length, int width) {
        this.length = length;
        this.width = width;
    }

    private int length;
    private int width;

    //area
    public int area() {
        return this.width * this.length;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

我们通过封装的方式，给矩形定义了长度和宽度

继承

继承，继承指它可以使用现有类的所有功能，并在无须编写原来的类的情况下对这些功能进行拓展，通过继承创建的新类（子类），被继承的类（父类）

举例：

class Square extends Rectangle{
    public Square(int length){
        super(length,length);
        //调用父类中参数的构造
    }
}
1
2
3
4
5
6
7

与现实世界一样，正方形是通过矩形派生出来

多态

多态：指一个类实例的相同方法在不同情形下有不同的表现形式
使得有不同内部结构的对象可以共享相同的外部接口

下面我们将站在广义的角度来说多态

1. 特设多态
   例如：多态函数有不同版本的实现，通过其实参而调用相应版本的函数，函数重载和运算符重载是常见的形式

//函数重载
public class FunctionOverloading {
    public static int add(int a, int b) {
        return a + b;

    }

//通过调用另一个重载函数实现重载

    public static int add(int a, int b, int c) {
        return add(a, b) + c;

    }

    public static void main(String[] args) {
        System.out.println(add(1, 2));

        System.out.println(add(2, 3, 4));

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2. 参数多态
   参数多态指声明与定义函数，复合类型，变量时不指定其具体的类型，而把这部分类型作为参数使用，使得该定义对各种具体类型都使用
   例如：Java中的泛型就是参数多态的一种，参数多态还广泛运用于函数式编程
   这个我们后面再讲
3. 子类型
   在面向对象的程序设计中，当计算机程序运行时，相同的消息可能会发送给多个不同类别的对象，而系统依赖对象所属类别，触发对应类别的方法，产生不同的行为。
   Java中常见的多态，正是这种多态，下面我们来介绍：

Java中的多态

java 层面的多态：

Java中多态的概念比较简单，就是同一操作作用于不同的对象，可以有不同的解释，产生不同执行结果

为了实现运行期的多态，需要满足以下三个条件：

1. 有类继承或者接口实现
2. 子类要重写父类的方法
3. 父类的引用指向子类的对象

public class parents {
    public void call(){
        System.out.println("i am parents");
    }
}
public class son extends parents {
    public void call() {
        System.out.println("i am sons");
    }
}

public class Daughter extends parents {
    public void call() {
        System.out.println("i am Daughter");
    }
}
public class Test {
    public static void main(String[] args) {
        parents p = new son();//父类的引用指向子类的对象
    	parents p1 = new Daughter();    
        p.call();
        p1.call();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

同样是Parents类的实例，p.call调用的是Son类的实现，p1.call调用的是Daughter的实现。

最后

如果对你有帮助，不妨一键三连，博主能力有限，如有差错，还请指出！