面向对象（封装、继承、多态）

面向对象三大特征

---

前言

提示：java只是面向对象编程语言中的一种，除了java之外，还有很多其他的编程语言也是面向对象的。
类和对象当中，“类”是抽象的，“对象”是类的实例化。

---

一、封装

1.封装的定义和作用

举例：手机，电脑这些外部都有一个坚硬的壳把手机封装起来，保护内部的零件。封装了之后，我们不需要关心内部有多么的复杂，在平常使用过程中只需要通过外部的按钮就可以完成操作。
作用：一个类体当中的数据，封装之后，对于代码的调用人员来说，不需要关心代码的复杂实现，只需要用过一个简单的入口就可以访问了，另外，类体中安全级别高的数据封装起来，外部人员不能随意访问，来保证数据的安全性。

2.封装的用法

//如果没有进行封装，可以在外部程序中随意访问并且修改，非常的不安全
public class Person {
   private int age=22;
   private String name;
  public int getAge(){
       return age;
  }

  public void setAge(int Age){
      //就是在这里设置关卡，保证了外部修改是只能输入正确范围
      if(Age<0||Age>150){
          System.out.println("请输入正确的年龄段范围");
      }
       age=Age;
  }
  public String getName(){
      return name;
  }
  public void setName(String Name){
      name=Name;
  }
}
//封装之后，不再对外暴露复杂的数据，只对外提供简单的操作入口
//优点：数据安全了，对其他人也方便了
//需要通过(get负责读)和(set写)方法

然后我们通过外部类调用的时候：

public class PersonTest {
    public static void main(String[] args) {
        Person p1=new Person();
        //访问一个对象的属性，通常包括两种数据，要么读要么改
        //修改年龄,在PersonTest这个外部程序中目前是可以随意对age进行操作的
        p1.setAge(20);
        System.out.println("修改之后的年龄是"+p1.getAge());
//        System.out.println(p1.setAge(20));
        //接下来我们给年龄赋值一个负数，发现还是可以运行成功的
        //其实这就是一个程序的bug
        p1.setName("吕鹏");
        System.out.println("这个人的姓名是"+p1.getName());
    }
}

输出结果：

二、继承

1.继承有什么用?怎么用？

继承的作用：
基本作用：子类继承父类，代码可以得到复用。
重要作用：因为有了继承关系，才有了后期的方法覆盖和多态机制。
如何用？
子类extends父类

代码如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

2.继承的特性：

① B类继承A类，则称A类为超类，父类，基类
B类称为子类，派生类，扩展类。

 class A{ }
 class B extends A{ }

②java只支持单继承，不支持多继承（引申：接口）
③虽然java不支持多继承，但是可以支持间接继承：

 class C extends B{ }
 class B extends A{ }
 //C 直接继承了B，还间接继承了A

④除构造方法不能直接继承之外，其余的都可以继承。但是private修饰的诗句无法在子类中直接访问，只能通过调用父类中的set和get方法访问和使用。
⑤java默认继承Object类
⑥继承的缺点：耦合度高，父类修改，子类收到牵连。

data = pd.read_csv(
    'https://labfile.oss.aliyuncs.com/courses/1283/adult.data.csv')
print(data.head())

---

三、多态

1.什么是多态？

多态就是多种形态：分为编译形态和运行形态。
多态中涉及到的概念：

• 向上转型 （父子类型转换）
• ----子类型转换成父类型—（自动类型转换）
• *向下转型 （强制转换）
• ----- 父类型转换成子类型—（强制类型转换）
• 无论是向上还是向下转型，两者之间都必须是继承关系，否则在编译期间就过不去
• 如果是向下转型，需要加强制类型转换符

1.1向上转型：

在这里我们通过代码来演示：
先创建一个父类Animal，

public class Animal {
    public void move(){
        System.out.println("动物在移动");
    }
}

然后再创建子类Cat和Bird分别来继承父类Animal，

public class Cat extends Animal{
    //重写父类中的move方法
    public void move(){
        System.out.println("猫在走猫步");
    }
    //这个是Cat特有的行为，自定义的
     public void catMouse(){
         System.out.println("猫在抓老鼠!");
     }
   }

public class Bird extends Animal{
    //继续重写父类中的方法
    public void move(){
        System.out.println("鸟儿在飞翔");
    }
    public void fly(){
        System.out.println("鸟儿在飞飞飞")
}

然后我们在另一个类中创建一个main函数来运行：

public class Poly语法机制 {
    public static void main(String[] args) {
        //普通语法编写的代码
        Animal a1 =new Animal();
        a1.move();
        Cat c1=new Cat();
        c1.move();
        c1.catMouse();
        Bird b1=new Bird();
        b1.move();
        // 使用多态语法编写的代码
        Animal a2=new Cat();//向上转型，子类型转换成父类型//在编译期的时候是Animal的方法，但是在运行期的时候是Cat方法，因为父类最终指向的是Cat
        a2.move();
        System.out.println(a2);
    }
}

1.2向下转型：

Animal a1=new Cat();
Animal a2=new Bird();
if (a1 instanceof Cat){
   Cat c1=(Cat)a1;
   c1.CatMouse;//调用子类中特有的方法**只有进行强制类型转换之后才可以在父类中调用子类的方法，而且两者必须是继承关系
   }
if(a2 instanceof Bird){
  Bird b2=(Bird)a2;
  b2.fly;//调用子类中特有的方法    
  }

2.多态在实际开发中的应用：

/**
 * 多态在实际开发中的作用，以主人喂养宠物为例说明多态的作用
 * 1、分析：  -主人【类】
 *          -主人可以喂养宠物
 *          -宠物【类】
 *          -宠物可以吃主人喂养的东西
 * 2、面向对象的核心：先定义好类，然后将类实例化为对象，让各个对象之间协作起来形成一个系统
 * 3、
 */
public class TestDemo {
    public static void main(String[] args) {
        TestCat cat=new TestCat();
        TestPeople zhangsan=new TestPeople();
        zhangsan.feed(cat);
    }
}

public class TestCat {
    public void eat(){
        System.out.println("小猫正在吃主人喂的鱼");
    }
}

public class TestPeople {
    public void feed(TestCat cat){
        cat.eat();
    }
}

四、总结

封装：保证数据的安全性（使用set和get方法）
继承：代码得到了复用，使代码不再变得冗余
多态：在一个指定的范围之内进行概念的转换