一，前言

今天总结一下关于Java的三大特性，封装，继承，多态。其实关于三大特性对于从事编程人员来说都是基本的了，毕竟只要接触Java这些都是先要认识的，接下来就系统总结一下。

二，封装

先来说说特性之一：封装

2.1，什么是封装

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。
通过该类提供的方法来实现对隐藏信息的操作和访问。
隐藏对象的信息。
留出访问的对外接口。

举个比较通俗的例子，比如我们的USB接口。如果我们需要外设且只需要将设备接入USB接口中，而内部是如何工作的，对于使用者来说并不重要。而USB接口就是对外提供的访问接口。

说了这么多，那为什么使用封装？

2.2，封装的特点

对成员变量实行更准确的控制。
封装可以隐藏内部程序实现的细节。
良好的封装能够减少代码之间的耦合度。
外部成员无法修改已封装好的程序代码。
方便数据检查，有利于保护对象信息的完整性，同时也提高程序的安全性。
便于修改，体高代码的可维护性。

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方法。

而对于这样一个实体对象，外部程序只有赋值和获取值的权限，是无法对内部进行修改，因此我们还可以在内部进行一些逻辑上的判断等，来完成我们业务上的需要。

到这里应该就明白封装对于我们的程序是多么重要。下面再来说说继承的那点事。

三，继承

3.1，什么是继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然，如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。

3.2，继承的特点

1，关于继承的注意事项：

只支持单继承，即一个子类只允许有一个父类，但是可以实现多级继承，及子类拥有唯一的父类，而父类还可以再继承。

子类可以拥有父类的属性和方法。

子类可以拥有自己的属性和方法。

子类可以重写覆盖父类的方法。

2，继承的特点：
```
   提高代码复用性。父类的属性方法可以用于子类。可以轻松的定义子类。使设计应用程序变得简单。
```
3.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);   // 结果：10Zi zi = new Zi();System.out.println("调用父类：" + zi.numFU); // 结果：10System.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); // 访问本类成员变量
}
```
3.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 类的方法}
}
```
重写的规则：

1，参数列表必须与被重写方法相同。

2，访问权限不能比父类中被重写的方法的访问权限更低（public>protected>(default)>private）。

3，父类成员的方法只能被它的子类重写。

4，被final修饰的方法不能被重写。

5，构造方法不能

重载(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));}}

重载规则：

1，被重载的方法必须改变参数列表（参数个数或者类型不一样）。

2，被重载的方法可以改变返回类型。

3，被重载的方法可以改变访问修饰符。

3.5，this，super关键字

super()关键字的用法
1，子类的成员方法中，访问父类的成员变量。

2，子类的成员方法中，访问父类的成员方法。
3，子类的构造方法中，访问父类的构造方法。

this关键字用法：
1，本类成员方法中，访问本类的成员变量。
2，本类成员方法中，访问本类的另一个成员方法。
3，本类的构造方法中，访问本类的另一个构造方法。
注意：

this关键字同super一样，必须在构造方法的第一个语句，且是唯一的。
this与super不能同时存在。

3.6，构造器

继承关系中，父子类构造方法的访问特点：
1，在子类构造方法中有一个默认隐含的super();调用，因此一定是先调用父类构造方法，再调用子类构造方法。
2，子类构造可以通过super();调用父类的重载构造。(重载)
3，super();的父类调用构造方法，必须在子类构造中的第一行，就是第一个;号结束的元素，并且只能调用一次。

3.7，关于继承的注意事项：

1，Java语言是单继承的，一个子类只能有唯一一个父类
2，Java语言可以是多级继承，一个子类有一个父类，一个父类还可以有一个父类。
3，一个子类只有一个父类，但是一个父类可以有多个子类。

四，多态

4.1，什么是多态

多态是同一个行为具有多个不同表现形式或形态的能力。

4.2，多态的特点

1，消除类型之间的耦合关系，实现低耦合。

2，灵活性。

3，可扩充性。

4，可替换性。

4.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.4，向上转型

1，格式：父类名称 对象名 = new 子类名称(); 含义：右侧创建一个子类对象，把它当作父类来使用。注意：向上转型一定是安全的。缺点：一旦向上转型，子类中原本特有的方法就不能再被调用了。

五，接口

最后，关于接口方面的细节，不同版本之间的区别。

问题描述：

现在接口中需要抽取一个公有的方法，用来解决默认方法中代码重复的问题。
但是这个共有的方法不能让实现类实现，所以应该设置为私有化。

在JDK8之后：

1，default修饰，接口里允许定义默认的方法，但默认方法也可以覆盖重写。
2，接口里允许定义静态方法。

在JDK9之后：

1，普通私有方法，解决多个默认方法之间代码重复的问题。
2，静态私有化，解决多个静态方法之间代码重复问题。
接口的注意事项：
1，不能通过接口的实现类对象去调用接口中的静态方法。
正确语法：接口名称调用静态方法。

接口当中的常量的使用：

1，接口当中定义的常量：可以省略public static final。
2，接口当中定义的常量：必须进行赋值。
3，接口当中定义的常量：常量的名称要全部大写，多个名称之间使用下划线进行分割。

使用接口的注意事项：

1，接口是没有静态代码块或者构造方法
2，一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
3，如果实现类没有覆盖重写接口中所有的抽象方法，那么实现类就必须是一个抽象类
4，如果实现类中实现多个接口，存在重复的抽象方法，那么只需要覆盖重写一次即可。
5，在Java中，如果实现类的直接继承父类与实现接口发生冲突时，父类优先级高于接口。

接口之间的关系：

1，多个接口之间是继承关系。
2，多个父接口当中默认方法如果重复，那么子接口必须进行默认方法的覆盖重写。

六，总结

关于Java的特性基本总结完毕，当然还有一些细节没有完善。其实对于这些Java基础一定要掌握并熟记，因为这与我们的实际开发密切相关，好的编码习惯才能铸就好的产品，才能被社会认可。

以上总结均是自己学习所得，如有不适之处，还请留言（邮箱）指教。

感谢阅读！

java之封装，继承，多态相关推荐

Java的封装继承多态简介与实例
封装所谓封装就是访问权限控制,不允许调用者直接访问类的属性,使用private修饰,将属性藏起来此时若创建对象,直接修改属性值,则会报错想要对属性进行读写则需要在类中添加get/set方法此时 ...
(十)Core Java 面向对象(封装,继承,多态,接口) -02 (96)
目录 : 24 ). 面向对象(聚集关系) 25 ). 面向对象(子父类中变量的特点) 26 ). 面向对象(子父类中函数的特点-覆盖) 27 ). 面向对象(子父类中构造函数的特点 ...
c语言编程菲薄拉,C语言设计模式-封装-继承-多态
快过年了,手头的工作慢慢也就少了,所以,研究技术的时间就多了很多时间,前些天在CSDN一博客看到有大牛在讨论C的设计模式,正好看到了,我也有兴趣转发,修改,研究一下. 记得读大学的时候,老师就告诉我们 ...
Java继承_Hachi君浅聊Java三大特性之封装继承多态
Hello,大家好~我是你们的Hachi君,一个来自某学院的资深java小白.最近利用暑假的时间,修得满腔java语言学习心得.今天小宇宙终于要爆发了,决定在知乎上来一场根本停不下来的Hachi君个人 ...
大数据笔记8—java基础篇4（面向对象-封装-继承-多态）
面向对象一.面向对象 1.面向过程 1.2.举例 1.3.总结二.面向对象 1.简述 2.举例 3.思想特点 2.1.类的定义格式 2.1.1.简述 2.2.2.格式 2.3.3.示例三.类的使 ...
Day55-每日一道Java面试题-Java 面向对象编程三大特性: 封装继承多态
Java 面向对象编程三大特性: 封装继承多态封装封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问.但是如果一个类没有 ...
小白理解——封装继承多态
一.封装是什么:首先是抽象,把事物抽象成一个类,其次才是封装.对外表示为一个对象,隐藏对象的属性和动作实现的细节,仅对外公开接口. ...
白话文带你了解封装继承多态
这里讲的仅仅是带你理解封装继承多态染好您可以移步去别的文章学习具体的实现 (只是个人理解您可以不爱,请别伤害哦!) 首先你要知道 java是面向对象的,说白了就是我拿你当个人,请认清你的地位 ...
python多态的三种表现形式_python小结----面向对象的三大特征(封装,继承,多态)
面向对象的三大特征: 封装,继承,多态面向对象的编程思想核心:高类聚,低耦合–程序的设计模式范畴封装什么是封装: 在面向对象编程的思想中,对代码进行高度封装,封装又叫包装封装就是指将数据或者函 ...
python 参数类型的多态_【Python】面向对象：类与对象\封装\继承\多态
六.Python面向对象--类与对象\封装\继承\多态 1.什么是面向对象编程 1.1 程序设计的范式:程序可控,易于理解 1.2 抽象并建立对象模型 1.3 程序是不同对象相互调用的逻辑.每个对象在 ...

java之封装，继承，多态

一，前言

二，封装

2.1，什么是封装

2.2，封装的特点

2.3，封装的使用

三，继承

3.1，什么是继承

3.2，继承的特点

3.3，继承的使用

3.4，重写，重载