封装继承多态是java面向对象中的三大特性，关于这三个特性具体有什么作用，能干什么，我们一起来探讨一下，如有语言形容不清楚，或者表达不准确，欢迎留言。
一、封装
1、封装是什么：官方来讲就是隐藏对象的属性和内部实现细节。以我个人观点来看，封装就是我们在实例化一个类对象时，把这个对象所具备的属性和内部实现的具体细节进行隐藏，不允许外部进行修改，只能通过类中定义的一些方法来访问这些被隐藏的东西，这些方法呢，就是我们所说的向外部提供一个接口。
2、我们通过一个例子来分析
public class Demo02 {
//用private关键字来表示该属性是私有的，不允许外部直接调用。
private int age;
private String name;
private char sex;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}public class Demo01 {
//什么叫做封装，高内聚低耦合又是什么呢
//封装是指把抽象出的类中的属性，方法的实现细节进行隐藏，只提供给外界接口。
//高内聚：就是类中的数据，其操作的细节由类内部完成，不允许外部进行修改。
//低耦合：仅暴露少量的方法给外部
public static void main(String[] args) {
Demo02 demo02=new Demo02();
demo02.setAge(10);
System.out.println(demo02.getAge());
demo02.setName("刘");
System.out.println(demo02.getName());
demo02.setSex('M');
System.out.println(demo02.getSex());
}
}以上是我们定义的两个类
（1）、其中Demo02这个类中声明了三个私有属性，分别为age，name，sex。
（2）、在该类中定义了get()和set()方法，用于对本类中的私有属性进行赋值和取值。
（3）、声明一个Demo01类，在这个类中对Demo02类进行操作
（4）、在Demo01类中实例化类Demo02，对象名为demo02
（5）、我们通古demo02这个对象无法访问类Demo02中的私有属性，这就体现出来了封装的思想，即私有属性是我们定义在类内部的，外界无法直接访问。
（6）、我们在Demo02类中定义了一些方法，这些方法就为外界的访问提供了接口，我们可以过访问这些方法，间接访问属性
（7）、通过demo02.setAge（10），我们就访问到了这个方法，并且把10这个数赋值给了私有属性Age，然后通过demo02.getAge（）就得到了这个私有属性的值。
封装的特性：
方便维护对象的信息，提高了程序的安全性，避免了外部对类内部的信息进行修改。可以通过get和set方法，为外界的访问提供一个接口。类内部的属性都是用private关键字进行修饰，表明为私有属性。
二、继承
1、继承是什么：继承就是子类继承了父类的属性和行为，拥有了父类所具有的特性，同时又可以定义一些自己特有的特性。父类中用private修饰的属性和方法不能被子类所拥有。
2、当用到继承时我们需要注意什么：
（1）、java中的继承是单继承，子类只能继承一个父类，而父类可以被多个子类所继承。如下图所示：
（2）、继承的关键字是extends，例如C类继承A类，C extends A。
（3）、我们可以在子类中重写父类中的方法，只要保证方法名和形参，返回值都相同，而方法体中的内容可以不同。
（4）、重写方法时，它的访问优先级不能低于父类，优先级次序从高到低分别为：
public protected default private
（5）、如果父类和子类有相同的方法，那就看我们实例化的时候是实例化的哪个类的对象，优先调用咱们实例化的这个类的方法。若没有则往上一级找。
（5）、访问类的属性和方法分为三种，一种是直接访问局部变量，一种是通过this.访问本类的属性，一种是通过super.访问父类：例如以下代码：
先定义一个父类Person：
public class Person {
int age;
int a;
String name="父类的名字";
public static void main(String[] args) {
Person person=new Person();
Student student=new Student();
student.print("我是学生");
student.print2();
student.eat();
person.eat();
person.sleep();
}
public void eat(){
System.out.println("人们都会吃饭");
}
public void sleep(){
System.out.println("人们都会睡觉");
}
public void print(){
System.out.println("父类的方法");
}
}在定义一个子类Student：
public class Student extends Person{
String name="子类的名字";
public void eat(){//父类方法的重写
System.out.println("学生吃食堂的饭");
}
public void print(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
public void print1(){
System.out.println("子类的方法");
}
public void print2(){
print1();
this.print1();
super.print();
}
}结合着上面的话来看这段代码就会一清二楚。
3、上面我们提到了重写方法，我们之前也提到过方法重载，两者之间有什么区别呢
（1）、方法重写前提是需要有继承关系，并且重写方法的方法名和形参和返回值是与父类中的方法相同的。
（2）、方法重载是我们定义在一个类中，有多个方法名相同的方法，只要保证参数列表个数，类型，顺序不同即可，返回值可以相同也可以不同。如下代码：
public void eat(){
System.out.println("人们都会吃饭");
}
public void eat(String name){
System.out.println("这个是方法的重载"+name);
}
三、多态
1、什么叫做多态：多态就是同一个方法可以具有多种不同的表现形式。
2、如何使用：我们在实例化一个子类的对象时，可以把这个对象定义为父类的引用
即：父类名称 对象名=new 子类名称（）；
3、就是在等号右侧创建一个子类对象，把这个对象当作父类来用。
4、如果把父类对象转为子类对象，格式为：子类名称 子类对象名=（子类名称） 父类对象。
5、下面我们用代码来使用多态，拿人、学生、老师这三个类来说明：
（1）首先声明一个Person类，它具有一个方法为eat（）
public class Person {
public void eat(){
System.out.println("人们都会吃饭");
}
}（2）再声明一个Student类，继承自Person类，它也具有一个eat（）方法，还有一个sleep方法：
public class Student extends Person{
public void eat(){//父类方法的重写
System.out.println("学生吃食堂的饭");
}
public void sleep(){
System.out.println("学生们有午休");
}
}
（3）另外再声明一个Teacher类，同样继承自Person类，也具有方法eat（）：
public class Teacher extends Person{
public void eat(){
System.out.println("老师们在家里吃饭");
}
}（4）我们在Main方法中实例化Student的对象，将对象作为父类Person的引用，然后调用方法eat，它会执行子类Student中的eat方法，而如果子类Student中没有这个eat方法时，就往上调用父类Person的eat方法，和Teacher类没有关系，同样我们也可以实例化Teacher的对象，代码如下：
public class Main {
public static void main(String[] args) {
Person student=new Student();
student.eat();//结果为：学生吃食堂的饭
Person teacher=new Teacher();
teacher.eat();//结果为：老师们在家里吃饭
}
}（5）运行以上程序证明，当我们当子类的对象作为父类的引用使用时，只能访问子类中和父类中都有的方法，而无法去访问子类中特有的方法，这是我们就可以强制的把父类的引用对象转换为子类本身的对象进行使用，格式为：子类名称 子类对象名=（子类名称）父类对象，添加两行之后的代码如下：
public class Main {
public static void main(String[] args) {
Person student=new Student();
Student student1=(Student)student;
student1.sleep();//结果为：学生们有午休
student.eat();//结果为：学生吃食堂的饭
Person teacher=new Teacher();
teacher.eat();//结果为：老师们在家里吃饭
}
}即这时就可以通过student1这个对象访问Student类独有的方法sleep，这和数据类型的强制转换很相似。
总结：封装继承多态的基本知识差不多就是以上这些，这在我们编程中占有举足轻重的地位，一定要牢牢掌握这些基本知识。