封装
封装简单来说就是将代码进行私有，把数据保密起来，然后再将所有私有的数据进行get/set方法。这就是封装的整个过程，下面给大家代码进行理解理解。
//类 private:私有的
public class Student {
private String name;//名字
private int id;//学号
private char sex;//性别
private int age;//年龄
//提供一些可以操作这个属性的方法！
//提供一些public的get、set方法
//get获得这个数据
public String getName(){
return this.name;
}
//set给这个数据设置值
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<0||age>120) {
this.age=3;
}else {
this.age = age;
}
}
}
知道了封装的过程，那我们为什么要进行封装呢？
- 提高了程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护增加
而且我们程序设计要追求“高内聚低耦合”
继承
继承的概述
继承，就像一个父亲有两三个儿子一样，这三个儿子都有爸爸身上的一些特点，那就是继承了爸爸身上的某些地方。
继承关系的两个类，一个为子类（派生类），一个为父类（基类），使用extends来表示。我光说，大家也会很晕，我直接上代码给大家看看把
public class Student extends Person {
在上面的代码就是表示Student这个类是Person这个类的子类，Person类是Student类的父类。简单点说Person类是Student类的爸爸。既然是他的爸爸了应该有它的一些特征才对嘛。所以，Student类可以使用Person类中除了私有的数据其他都可以调用！
//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
//Ctrl + H
}
这个是学生类（派生类），里面什么方法都没有。
//在Java中所有的类，都默认之间或者间接继承object类。
//Person 人：父类
public class Person {
//public 公有的
//protected
//defoult
//private 私有的 不能被继承
private int money =1_0000_0000;
public void say(){
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
这个是Person类（基类）上面有很多类，但是private私有的数据子类不能继承，其它都可以继承。
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
}
}
然后我有写了一个类来运行实例化Student对象，再继续调用say这个方法，大家都知道我的Student类中并没有写任何一个方法，但我可以进行调用say方法，这都因为它的爸爸拥有这个方法！
这是运行结果。
object类：
在Java中所有的类，都默认直间或者间接继承object类。
super：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中！
3.super和this不能同时调用构造方法！
Vs this：
代表的对象不同：
this： 本身调用者这个对象
super：只能在继承条件才可以使用
前提
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法
this（）；本类的构造
super（）；父类的构造！
重写
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
4.抛出异常：范围，可以被缩小，但不能扩大：ClassNotFoundException -->Exception(大)
重写，子类的方法和父类必须要一致：方法体不同！
为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足！重之后就会延申到我们的多态方面。
多态
-
同一方法可以根据发送对象的不同而采用多种不同的行为方式。
-
一个对象的数据类型是确定的，但可以指向对象的引用的类型有很多
-
多态存在的条件
-
有继承关系
-
子类重写父类方法
-
父类引用指向子类对象
注意多态是方法的多态，属性没有多态性
public class Person { public void run(){ System.out.println("run"); } }这是父类。
public class Student extends Person { @Override//重写的注释 public void run() { System.out.println("son"); } public void eat(){ System.out.println("ear"); } }这是子类，我们可以发现，他们俩有同一个方法run但是他们输出的东西不一样。
public class Application { public static void main(String[] args) { Student s1 = new Student(); s1.run(); } }我们写一个类，new个对象，运行run方法。我们看看会是那个结果。
-
很显然，我们执行了子类的方法，而父类的方法没有执行，所以在重写的时候，会覆盖掉父类的方法，运行出来会是不一样的结果，这就是多态的体现！
多态的注意事项
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系，类型转换异常！ ClassCastException!
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();
不能重写的：
1.static 方法，属于类，它不属于实例
2.final 常量；
3.private方法；
判断父子关系
1.通过instanceof可以判断定义的对象他们两个是否存在父类和子类的关系
2.判断完了之后如果存在父子关系，就可以进行强制类型转换
3.父类引用指向子类的对象，向上转型（直接转！）
4.把父类转为子类，向下转型，向下转型，（强制转换！）
5.方便方法的调用，减少重复的代码！简洁
抽象： 封装、继承、多态！
小结
可能我理解的封装、继承、多态，如果大家看到很模糊，还是不清楚，大家就去b站是去看视频学习把。我总结的知识都是看狂神说java总结出来的,大家有兴趣的话一起学习把！