面向对象＜三＞Java三大特性（封装、继承、多态）-CSDN博客

本文链接：https://blog.csdn.net/Ft_Blackben0/article/details/109891832

系列文章目录

1.面向对象<一>思想篇
 2.面向对象<二>类与对象
3.面向对象<三>三大特性
4.面向对象<四>关键字

前言

本文是面向对象编程的第二篇，主要介绍下Java中的三大特性：继承性、封装性以及多态性，如有不足之处，还请各位批评指正哦。

一、封装与隐藏

1.1、封装的含义

所谓的封装性，通俗来说，就是将该隐藏的都隐藏起来，该暴露的暴露出来。需要隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，从而提高系统的可扩展性、可维护性。

程序设计需要追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。

一般来说，一个类里的属性应该是每个类里自身的东西，是不允许外部对象进行调用的，因此就需要将这些属性封装起来，防止乱用。例如下面的例子

class Animal{
	public int legs；
	public void eat(){
		System.out.println("Eating");
	}
}
public class Zoo{
	public static void main(String[] args){
		Animal dog = new Animal();
		dog.legs = 10;//这里我们就随便设置dog的腿数，想来是不太好的，造物主肯定不
					  //希望造出来的小狗是个奇葩吧，，
		System.out.println(dog.legs);
		dog.eat();
	} 
}

那么我们该如何避免这个问题呢，就应该将数据声明为private，再提供public的getXXX（）和setXXX（）方法实现对属性的操作。因此代码可以改进成：

class Animal{
	private int legs；
	public void eat(){
		System.out.println("Eating");
	}
	public int getlegs（）{
		return this.legs;//这里的this会在后续的第四篇里进行讲解
	}
	public void setlegs（int leg）{
		this.legs = leg;
	}
}
public class Zoo{
	public static void main(String[] args){
		Animal dog = new Animal();
		dog.setlegs(4);//在这里为private属性赋值
		System.out.println(dog.getlegs（）);//在这里获取dog对象的腿数
		dog.eat();
	} 
}

乍一看程序变得复杂了，其实完全可以使用IDEA中附带的自动生成功能，使用alt+insert，直接生成getter（）和setter（）方法，甚至比之前的暴露在外的，自己敲代码还快，，
当然，除了对属性进行封装，还可以将方法、构造器进行封装，请大家自行查阅。

1.2、四种访问权限修饰符

常见的四种访问权限修饰符为public、protected、缺省（啥都没有）以及private，常置于类的内部结构前，包括：属性，方法，构造器，内部类，用来限定对象对该结构的访问权限。

对于类来说，只能使用public或者为default（缺省值）来修饰。

1.3、总结

引入封装性是为了
1.追求程序设计的“高内聚”和“低耦合”；
2.隐藏对象内部的复杂性，只对外公开简单的接口，便于外界调用，从而提高系统的可扩展性和可维护性。

二、继承性

1.继承性的目的

① 减少了代码的冗余，提高了代码的复用性；
② 便于功能的扩展；
③ 为之后多态性的使用，提供了前提。

2.继承的含义

先上图，让大家直观了解一下，啥叫继承。通俗来讲，就是一个叫做Person的类，它内部又可以按照不同功能分为Customer类,Student类，Waiter类以及Teacher类。每个类都在Person类的基础上，都各自实现了自己的功能。比如：这里的Student类，会将Person类中的name，id，age以及info（）方法全部拿到，而Student类还可以具有自己的属性以及方法，这样就是继承，诸如Student这样的类就称为子类，Person类就称为父类。
继承示意图
接下来上一下继承的代码格式：

/*继承的语法格式
*class A extends B{}
*     A:子类、派生类、subclass
*     B:父类、超类、基类、superclass
*/ 

class Person {
	public String name;
	public int age;
	public Date birthDate;
	public String getInfo() {
		// ...
	}
}
//Student类继承Person类
class Student extends Person {
	public String school;//除了继承的属性，Student自己定义的属性
}

3.继承性的说明

1.一个子类只能有一个父类，但是一个父类可以有多个子类，即Java只支持单继承和多层继承，但不支持多重继承，但是可以通过接口实现；
2.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类；
3.子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法（包括私有方法和私有属性）；
4. 如果我们没显式的声明一个类的父类的话，则此类继承于java.lang.Object类。

4.方法的重写

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

要求：
1.子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限，子类不能重写父类中声明为private权限的方法
4. 子类方法抛出的异常不能大于父类被重写方法的异常

PS：只有非static，同名同参数的方法才称为方法的重写。static方法是属于类的，无法被覆盖。
PS：一道被考烂的面试题：重载与重写有什么区别？

三、多态性

多态性是面向对象中最为重要的概念。对象的多态性：父亲的引用指向子类的对象，可以直接应用在抽象类和接口上。
Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。

对象的多态性：子类的对象可以替代父类的对象使用，自动向上转型。
代码如下：

Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象

但一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。例如：

//school是Student类的属性，非Person类的属性
Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; //非法,Person类没有school成员变量