- 🍁 个人主页：爱编程的Tom
- 💫 本篇博文收录专栏：Java专栏
- 👉 目前其它专栏：c系列小游戏 c语言系列--万物的开始_
- 🎉 欢迎 👍点赞✍评论⭐收藏💖三连支持一下博主🤞
- 🧨现在的沉淀就是对未来的铺垫🎨
目录
前言
1.封装
🧐封装是什么
🧐封装的原则
🧐封装的实现
🧐封装的意义
2.继承
📜继承是什么
📜继承的语法
📜继承的方式
📜继承的意义
3.多态
🚩多态是什么
🚩实现多态的条件
🚩重写的介绍
🚩重写的规则
🚩向上转型和向下转型
🚩多态的优缺点
前言
这篇文章旨在让大家深刻理解关于Java方面的基础语法，即面向对象的三大特性。
1.封装
🧐封装是什么
简单来说，封装就是套壳屏蔽细节，即将类的具体细节进行隐藏，对外只提供一些开放的接口。出于安全考虑，我们将一些重要的数据选择不公开，即封装起来。
其次，Java当中的类具有可封装性，即可以将里面的某些字段设置为私有字段，对外不公开，我们也可以直接将该类设置为私有类。，通过不同的访问限定符，即关键字private、default、protected、public来控制其它类对该类中数据的调用，具体使用范围如下图：
🧐封装的原则
在Java当中，我们通过不同的类来实现封装，从而实现程序的高内聚，低耦合的特性，其中通常使用上面提到的4种关键字来实施封装，按照作用范围从大到小排序，分别是public、protected、default、private。
- public
通常我们用其设置公有且对外可开放的成员变量，让类外的方法能够访问到这个类当中的私有数据，从而能够起到保护数据的作用。通俗的来讲：可以理解为一个人的外貌特征，谁都可以看得到
- protected
protected主要是用在继承中，本篇文章会在后面的继承部分当中介绍
- default
default权限指：什么都不写时的默认权限
- private
我们通常用它设置一个类当中的私有数据，拒绝其它类访问获取数据以及修改，通俗的讲：对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了 。
🧐封装的实现
Java中主要通过类和访问权限来实现封装：
类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认 知，而访问权限用来控制方法或者字段能否直接在类外使用。 （四种访问控制符在上面已经介绍）
🧐封装的意义
将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互，从而降低整个程序的风险，考虑安全因素。
📜举个例子
public class Computer {
private String cpu; // cpu
private String memory; // 内存
public String screen; // 屏幕
String brand; // 品牌---->default属性
public Computer(String brand, String cpu, String memory, String screen) {
this.brand = brand;
this.cpu = cpu;
this.memory = memory;注意：一般情况下成员变量设置为private，成员方法设置为public。
this.screen = screen;
}
public void Boot(){
System.out.println("开机~~~");
}
public void PowerOff(){
System.out.println("关机~~~");
}
public void SurfInternet(){
System.out.println("上网~~~");
}
}
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW", "i7", "8G", "13*14");
System.out.println(p.brand); // default属性：只能被本包中类访问
System.out.println(p.screen); // public属性： 可以任何其他类访问
// System.out.println(p.cpu); // private属性：只能在Computer类中访问，不能被其他类访问
}
}2.继承
📜继承是什么
面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。
继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了 由简单到复杂的认知过程。
继承主要解决的问题是：共性的抽取，实现代码复用。
上述图示中，Dog和Cat都继承了Animal类
其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的 子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。
从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态(后文会讲)。
📜继承的语法
// Animal.java
public class Animal{
String name;
int age;
public void eat(){
System.out.println(name + "正在吃饭");
}
public void sleep(){
System.out.println(name + "正在睡觉");
}
}
// Dog.java
public class Dog extends Animal{
void bark(){
System.out.println(name + "汪汪汪~~~");
}
}
// Cat.Java
public class Cat extends Animal{
void mew(){
System.out.println(name + "喵喵喵~~~");
}
}
// TestExtend.java
public class TestExtend {
public static void main(String[] args) {
Dog dog = new Dog();
// dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
System.out.println(dog.name);
System.out.println(dog.age);
// dog访问的eat()和sleep()方法也是从Animal中继承下来的
dog.eat();
dog.sleep();
dog.bark();
}
}这里注意：成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。
Java当中提供了super关键字，在子类方法中访问父类的成员。具体代码如下：
public class Base {
int a;
int b;
public void methodA(){
System.out.println("Base中的methodA()");
}
public void methodB(){
System.out.println("Base中的methodB()");
}
}
public class Derived extends Base{
int a; // 与父类中成员变量同名且类型相同
char b; // 与父类中成员变量同名但类型不同
// 与父类中methodA()构成重载
public void methodA(int a) {
System.out.println("Derived中的method()方法");
}
// 与基类中methodB()构成重写(即原型一致，重写后序详细介绍)
public void methodB(){
System.out.println("Derived中的methodB()方法");
}
public void methodC(){
// 对于同名的成员变量，直接访问时，访问的都是子类的
a = 100; // 等价于： this.a = 100;
b = 101; // 等价于： this.b = 101;
// 注意：this是当前对象的引用
// 访问父类的成员变量时，需要借助super关键字
// super是获取到子类对象中从基类继承下来的部分
super.a = 200;
super.b = 201;
// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
methodA(); // 没有传参，访问父类中的methodA()
methodA(20); // 传递int参数，访问子类中的methodA(int)
// 如果在子类中要访问重写的基类方法，则需要借助super关键字
methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
super.methodB(); // 访问基类的methodB()
}
}这里注意：super只能在非静态方法中使用，在子类方法中，访问父类的成员变量和方法。
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
这里可以利用代码执行一下：
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Person：构造方法执行");
}
{
System.out.println("Person：实例代码块执行");
}
static {
System.out.println("Person：静态代码块执行");
}
}
class Student extends Person{
public Student(String name,int age) {
super(name,age);
System.out.println("Student：构造方法执行");
}
{
System.out.println("Student：实例代码块执行");
}
static {
System.out.println("Student：静态代码块执行");
}
}
}
public class TestDemo4 {
public static void main(String[] args) {
Student student1 = new Student("张三",19);
System.out.println("===========================");
Student student2 = new Student("gaobo",20);
}
public static void main1(String[] args) {
Person person1 = new Person("bit",10);
System.out.println("============================");
Person person2 = new Person("gaobo",20);
}
}
执行结果：
Person：静态代码块执行
Student：静态代码块执行
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行
===========================
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行
📜继承的方式
Java的继承方式：
注意：Java中不支持多继承。 时刻牢记, 我们写的类是现实事物的抽象. 而我们真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到 一系列复杂的概念, 都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多. 类之间的关系也会 更加复杂. 但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系.
如果继承层 次太多, 就需要考虑对代码进行重构了.
如果想从语法上进行限制继承, 就可以使用 final 关键字
这里对final关键字几点说明：
1. 修饰变量或字段，表示常量(即不能修改)
2. 修饰类：表示此类不能被继承
📜继承的意义
实现代码复用，避免实现代码臃肿
3.多态
🚩多态是什么
通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状 态。这里需要注意的是：多态是一种思想，同一个引用调用了同一个方法，但是因为引用的对象不一样，所表现的行为不一样，这种思想，称为多态。
🚩实现多态的条件
在java中要实现多态，必须要满足如下几个条件，缺一不可：
1. 必须在继承体系下
2. 子类必须要对父类中方法进行重写
3. 通过父类的引用调用重写的方法
多态体现：在代码运行时，当传递不同对象时，会调用对应类中的方法。
🚩重写的介绍
重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程 进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定 于自己的行为。 也就是说子类能够根据需要实现父类的方法。
🚩重写的规则
- 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
- 被重写的方法返回值类型可以不同，但是必须是具有父子关系的
- 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方 法就不能声明为 protected
- 父类被static、private修饰的方法、构造方法都不能被重写。
- 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心 将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法 构成重写.
【重写和重载的区别】 
这里给大家介绍两个绑定：
- 静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
- 动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体 调用那个类的方法。
🚩向上转型和向下转型
向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。
语法格式：父类类型 对象名 = new 子类类型()
Animal animal = new Cat("元宝",2);animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。
应用场景：1. 直接赋值 2. 方法传参 3. 方法返回
public class TestAnimal {
// 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
public static void eatFood(Animal a){
a.eat();
}
// 3. 作返回值：返回任意子类对象
public static Animal buyAnimal(String var){
if("狗".equals(var) ){
return new Dog("狗狗",1);
}else if("猫" .equals(var)){
return new Cat("猫猫", 1);
}else{
return null;
}
}
public static void main(String[] args) {
Animal cat = new Cat("元宝",2); // 1. 直接赋值：子类对象赋值给父类对象
Dog dog = new Dog("小七", 1);
eatFood(cat);
eatFood(dog);
Animal animal = buyAnimal("狗");
animal.eat();
animal = buyAnimal("猫");
animal.eat();
}
}向上转型的优点：让代码实现更简单灵活。 向上转型的缺陷：不能调用到子类特有的方法。
而向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入 了 instanceof ，如果该表达式为true，则可以安全转换。
🚩多态的优缺点
1. 能够降低代码的 "圈复杂度", 避免使用大量的 if - else
什么叫 "圈复杂度" ? 圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如 果有很多的条件分支或者循环语句, 就认为理解起来更复杂.
因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 "圈复杂度". 如果一个方法的圈复杂度太高, 就需要考虑重构. 不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10 .
下面提供使用多态和非多态的两种表现形式：
- 非多态
public static void drawShapes() {
Rect rect = new Rect();
Cycle cycle = new Cycle();
Flower flower = new Flower();
String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};
for (String shape : shapes) {
if (shape.equals("cycle")) {
cycle.draw();
} else if (shape.equals("rect")) {
rect.draw();
} else if (shape.equals("flower")) {
flower.draw();
}
}
}
- 多态
public static void drawShapes() {
// 我们创建了一个 Shape 对象的数组.
Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),
new Rect(), new Flower()};
for (Shape shape : shapes) {
shape.draw();
}
}2. 可扩展能力更强
如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.
多态缺陷：代码的运行效率降低。
- 属性没有多态性
- 当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
- 构造方法没有多态性
![uniapp运行项目到微信小程序报错——未找到[“sitemapLocation“]](https://img-blog.csdnimg.cn/direct/d670e1dfc189487a8eec4dc6f5efb370.png#pic_center)
