面向对象的三大特性：封装、继承、多态
面向对象的三大特性：封装、继承、多态
一、封装
1. 什么是封装
封装(Encapsulation)是面向对象方法的重要原则，就是把对象的属性和操作(或服务)结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。
- 将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。
- 通过该类提供的方法来实现对隐藏信息的操作和访问。
- 隐藏对象的信息。
- 留出访问的对外接口。
举个比较通俗的例子，比如我们的USB接口。如果我们需要外设且只需要将设备接入USB接口中，而内部是如何工作的，对于使用者来说并不重要。而USB接口就是对外提供的访问接口。说了那么多，那为什么使用封装？
2. 封装的特点
- 对成员变量实行更准确的控制。
- 封装可以隐藏内部程序实现的细节。
- 良好的封装能够减少代码之间的耦合度。
- 外部成员无法修改已封装好的程序代码。
- 方便数据检查，有利于保护对象信息的完整性，同时也提高程序的安全性。
- 便于修改，提高代码的可维护性。
3. 封装的使用
- 使用private修饰符，表示最小的访问权限。
- 对成员变量的访问，统一提供setXXX，getXXX方法。
下面请看一个Student实体对象类：
public class Student implements Serializable {
private Long id;
private String name;
private Integer sex;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
}
分析：对于上面的一个实体对象，我想大家都已经很熟悉了。将对象中的成员变量进行私有化，外部程序是无法访问的。但是我们对外提供了访问的方式，就是set和get方法。
而对于这样一个实体对象，外部程序只有赋值和获取值的权限，是无法对内部进行修改，因此我们还可以在内部进行一些逻辑上的判断等，来完成我们业务上的需要。到这里应该就明白封装对于我们的程序是多么的重要。下面再来说说继承的那点事。
二、继承
1. 什么是继承
继承就是子类继承父类的特征和行为，使得子类对象(实例)具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然，如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。
2. 继承的特点
（1）关于继承的注意事项：
只支持单继承，即一个子类只允许有一个父类，但是可以实现多级继承，及子类拥有唯一的父类，而父类还可以再继承。
子类可以拥有父类的属性和方法。
子类可以拥有自己的属性和方法。
子类可以重写覆盖父类的方法。
（2）继承的特点：
提高代码复用性。
父类的属性方法可以用于子类。
可以轻松的定义子类。
使设计应用程序变得简单。
3. 继承的使用
（1）在父子类关系继承中，如果成员变量重名，则创建子类对象时，访问有两种方式。
a. 直接通过子类对象访问成员变量。
等号左边是谁，就优先使用谁，如果没有就向上找。
b. 间接通过成员方法访问成员变量
该方法属于谁，谁就优先使用，如果没有就向上找。
public class FU {
int numFU = 10;
int num = 100;
public void method(){
System.out.println("父类成员变量："+numFU);
}
public void methodFU(){
System.out.println("父类成员方法!");
}
}
public class Zi extends FU{
int numZi = 20;
int num = 200;
public void method(){
System.out.println("子类成员变量："+numFU);
}
public void methodZi(){
System.out.println("子类方法！");
}
}
public class ExtendDemo {
public static void main(String[] args) {
FU fu = new FU();
// 父类的实体对象只能调用父类的成员变量
System.out.println("父类：" + fu.numFU); // 结果：10
Zi zi = new Zi();
System.out.println("调用父类：" + zi.numFU); // 结果：10
System.out.println("子类：" + zi.numZi); // 结果：20
/** 输出结果为200，证明在重名情况下，如果子类中存在则优先使用，
* 如果不存在则去父类查找，但如果父类也没有那么编译期就会报错。
*/
System.out.println(zi.num); // 结果：200
/**
* 通过成员方法调用成员变量
*/
zi.method(); // 结果：10
}
}
（2）同理：
成员方法也是一样的，创建的对象是谁，就优先使用谁，如果没有则直接向上找。
注意事项：
无论是成员变量还是成员方法，如果没有都是向上父类中查找，绝对不会向下查找子类的。
（3）在继承关系中，关于成员变量的使用：
局部成员变量：直接使用
本类成员变量：this.成员变量
父类成员变量：super.父类成员变量
int numZi = 10;
public void method() {
int numMethod = 20;
System.out.println(numMethod); //访问局部变量
System.out.println(this.numZi); //访问本类成员变量
System.out.println(super.numFu); //访问本类成员变量
}
（4）重写、重载
重写(override)
是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。即外壳不变，核心重写！
class Animal{
public void move(){
System.out.println("动物行走！");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
}
}
重写的规则：
- 参数列表必须与被重写方法相同。
- 访问权限不能比父类中被重写的方法的访问权限更低(public>protected>(default)>private)
- 父类成员的方法只能被它的子类重写。
- 被final修饰的方法不能被重写。
- 构造方法不能。
重载(overload)
是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
public class Overloading {
public int test(){
System.out.println("test1");
return 1;
}
public void test(int a){
System.out.println("test2");
}
//以下两个参数类型顺序不同
public String test(int a,String s){
System.out.println("test3");
return "returntest3";
}
public String test(String s,int a){
System.out.println("test4");
return "returntest4";
}
public static void main(String[] args){
Overloading o = new Overloading();
System.out.println(o.test());
o.test(1);
System.out.println(o.test(1,"test3"));
System.out.println(o.test("test4",1));
}
}
重载规则：
- 被重载的方法必须改变参数列表(参数个数或者类型不一样)。
- 被重载的方法可以改变返回类型。
- 被重载的方法可以改变访问修饰符。
（5）this、super关键字
super()关键字的用法
- 子类的成员方法中，访问父类的成员变量。
- 子类的成员方法中，访问父类的成员方法。
- 子类的构造方法中，访问父类的构造方法。
this关键字的用法
- 本类成员方法中，访问本类的成员变量。
- 本类成员方法中，访问本类的另一个成员方法。
- 本类的构造方法中，访问本类的另一个构造方法。
注意：
- this关键字同super一样，必须在构造方法的第一个语句，且是唯一的。
- this与super不能同时存在。
（6）构造器
继承关系中，父子类构造方法的访问特点：
- 在子类构造方法中有一个默认隐含的super();调用，因此一定是先调用父类构造方法，再调用子类构造方法。
- 子类构造可以通过super();调用父类的重载构造。(重载)
- super();的父类调用构造方法，必须在子类构造中的第一行，就是第一个;号结束的元素，并且只能调用一次。
（7）关于继承的注意事项：
- Java语言是单继承的，一个子类只能有唯一一个父类。
- Java语言可以是多级继承，一个子类有一个父类，一个父类还可以有一个父类。
- 一个子类只有一个父类，但是一个父类可以有多个子类。
三、多态
1. 什么是多态
多态是同一个行为具有不同表现形式或形态的能力。
2. 多态的特点
- 消除类型之间的耦合关系，实现低耦合。
- 灵活性
- 可扩充性
- 可替换性
3. 多态的体现形式
- 继承
- 父类引用指向子类
- 重写
注意：在多态中，编译看左边，运行看右边。
public class MultiDemo {
public static void main(String[] args) {
// 多态的引用，就是向上转型
Animals dog = new Dog();
dog.eat();
Animals cat = new Cat();
cat.eat();
// 如果要调用父类中没有的方法，则要向下转型
Dog dogDown = (Dog)dog;
dogDown.watchDoor();
}
}
class Animals {
public void eat(){
System.out.println("动物吃饭！");
}
}
class Dog extends Animals{
public void eat(){
System.out.println("狗在吃骨头！");
}
public void watchDoor(){
System.out.println("狗看门！");
}
}
class Cat extends Animals{
public void eat(){
System.out.println("猫在吃鱼！");
}
}
4. 向上转型
1，格式：父类名称 对象名 = new 子类名称();
含义：右侧创建一个子类对象，把它当作父类来使用。
注意：向上转型一定是安全的。
缺点：一旦向上转型，子类中原本特有的方法就不能再被调用了。
四、接口
最后，关于接口方面的细节，不同版本之间的区别。
问题描述：
现在接口中需要抽取一个公有的方法，用来解决默认方法中代码重复的问题。
但是这个共有的方法不能让实现类实现，所以应该设置为私有化。
在JDK8之后：
- default修饰，接口里允许定义默认的方法，但默认方法也可以覆盖重写。
- 接口里允许定义静态方法。
在JDK9之后：
- 普通私有方法，解决多个默认方法之间代码重复的问题。
- 静态私有化，解决多个静态方法之间代码重复问题。
接口的注意事项：
不能通过接口的实现类对象去调用接口中的静态方法。
正确语法：接口名称调用静态方法。
接口当中的常量的使用：
1，接口当中定义的常量：可以省略public static final。
2，接口当中定义的常量：必须进行赋值。
3，接口当中定义的常量：常量的名称要全部大写，多个名称之间使用下划线进行分割。
使用接口的注意事项：
1，接口是没有静态代码块或者构造方法
2，一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
3，如果实现类没有覆盖重写接口中所有的抽象方法，那么实现类就必须是一个抽象类
4，如果实现类中实现多个接口，存在重复的抽象方法，那么只需要覆盖重写一次即可。
5，在Java中，如果实现类的直接继承父类与实现接口发生冲突时，父类优先级高于接口。
接口之间的关系：
1，多个接口之间是继承关系。
2，多个父接口当中默认方法如果重复，那么子接口必须进行默认方法的覆盖重写。
五、总结
关于Java的特性基本总结完毕，当然还有一些细节没有完善。其实对于这些Java基础一定要掌握并熟记，因为这与我们的实际开发密切相关，好的编码习惯才能铸就好的产品，才能被社会认可。