导语

        各位小伙伴们大家好呀，今天我们给大家分享一个我们java语言当中非常重要的一个模块——面向对象。

目录

导语

文章目录​​​​​​​​​​​​​

一、面向对象

   1.1面向对象概述 

   1.2面向对象三大特征——封装、继承、多态

        1.2.1、封装

        1.2.2、继承

        1.2.3、多态

总结：

一、面向对象

        1.1面向对象概述

        当我们接触编程语言时，总会有人提到面向对象编程（object-orientend programming，OOP），那么什么是面向对象呢 ？相信大家刚开始写出来的第一个程序就是helloworld。那么helloworld程序很简单哈。就是一个输出语句，那么在我们了解了面向对象编程之后，我们就要学会将我们所要做的东西把他封装成一个对象去实现我们想要的功能。

        很早很早以前的编程是面向过程的，比如实现一个算术运算1+1 = 2，通过这个简单的算法就可以解决问题。但是随着时代的进步，人们不满足现有的算法了，因为问题越来越复杂，不是1+1那么单纯了，比如一个班级的学生的数据分析，这样就有了对象这个概念，一切事物皆对象。将现实的事物抽象出来，注意抽象这个词是重点啊，把现实生活的事物以及关系，抽象成类，通过继承，实现，组合的方式把万事万物都给容纳了。实现了对现实世界的抽象和数学建模。这是一次飞跃性的进步。

        那么面向对象和面向过程又有什么区别呢？这两个概念十分的抽象，我们就举两个例子去理解，比如吃饭这个问题

1.你某天回家自己做饭，你的买菜，洗菜，点火，加料，炒熟，装盘，吃饭。

2.去饭店，老板，青椒牛肉丝一份儿！你：好嘞！

        看到了吗？你去饭店，直接就能得到你想要的菜，方便！你不需要知道这个菜是怎么做的，你会吃就行，降低了我们“吃饭”的耦合性，而且如果你自己做菜，你突然不想吃这个 菜了，你想换个口味，恐怕第一种方式要麻烦许多，而第二种你只需要再喊一句：“老板，青椒牛肉丝不要了，来分鱼香肉丝儿”相信百分百可以。降低了我们程序的维护性。

        了解完面向对象与面向过程，面向对象的三大特征，六大原则也是我们必须去掌握的。

1.2面向对象三大特征——封装、继承、多态

        1.2.1、封装

        关于类和对象我们之前也有分享过，不知道的小伙伴可以往前翻一翻，这里我们就简单回顾一下类：

        类（class）是构造对象的模板或蓝图。我们可以将类想象成制作菜品的秘方，将对象想象为菜品。由类构造对象的过程 称为创建类的实例。

        封装的定义及原则：将类的某些信息隐藏在类内部，（所以封装也被称为数据隐藏）不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

        封装的好处：通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性。

        封装就像我们吧做菜的步骤交给了做菜师傅，我们需要什么，就直接点什么，不需要我们去做任何东西。

        关于封装的一些细节性问题，我们前面也有分享过，各位小伙伴也可以往前翻一翻哦！

        1.2.2、继承

        在分享继承之前，我们还分享两个常见的类之间的关系：依赖和聚合

        依赖即（uses-a）的关系，是一种最明显的、最常见的关系。如果一个类的方法使用或操纵另一个类的对象，我们就说一个类依赖于另一个类。例如我们的菜单类，和我们师傅炒菜类，师傅要想炒菜，师傅类就需要菜单类是因为师傅的对象他是需要查看菜单对象来查看他要怎么炒菜。在我们的开发当中，应当尽可能的去减少依赖，减少类与类之间的耦合，这里的关键就是如果类A不知道类B的存在，那么他就不会去关心 类B的任何改变（也就是B的改变不会导致A产生任何bug）；

        聚合即是（has a） 的关系，比如说我的A类中包含了一些B类的对象，这两个类就存在这聚合关系。

        到了我们的继承，他就是一个（is-a）的关系，表示一个更特殊的类与一更一般的类之间的关系，比如我的菜单类和炒菜类在我们的更特殊的类炒菜类中就包含了一些用于优先处理的特殊方法，例如点火，等等，而菜品量的多少，顺序方法都是继承自菜单类的。

        那么继承就是可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法。

        那么在java当中，继承如何去实现呢？

        在java当中，继承我们通过关键字extends去实现两个类之间的继承。extends表示正在构造的新类派生于一个已存在的类。他的格式是：

        class子类extends父类{}； 例如：class Dog extends Animal{}；。

        继承给我们带来的好处是：继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类可以使用父类中非私有的成员；

        例如我们这里的代码：        

public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show();

        Zi z = new Zi();
        z.method();
        z.show();
    }
}

        输出结果

show方法被调用
method方法被调用
show方法被调用

那么我们很明显的发现，我们子类中没有得show方法居然神奇的被调用了，这就是继承。

继承注意点：
   1、子类不是父类的子集，子类一般比父类包含更多的数据域和方法。
   2、 父类中的 private 数据域在子类中是不可见的，因此在子类中不能直接使用它们。
   3、继承是为"is-a"的关系建模的，父类和其子类间必须存在"is-a"的关系，否则不能用继承。
   4、但也并不是所有"is-a"的关系都应该用继承。例如，正方形是一个矩形，但不能让 Square 类来继承 Rectangle 类，因为正方形不能从矩形扩展得到任何东西。正确的继承关系是 Square 类继承 Shape 类
   5、Java 只允许单一继承（即一个子类只能有一个直接父类，可以有多重继承），C++ 可以多继承（即一个子类有多个直接父类）。

继承中一个小问题：方法重写

方法重写
    1.方法重写概念
        子类出现了和父类一模一样的方法声明（方法名一样，参数列表也必须一样）
    2.方法重写的应用场景
        当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，既沿袭了父类的功能，又定义了子类特有的内容。
    3.@override注解
        用来检测当前的方法，是否是重写的方法，起到（校验）的作用
方法重写的注意事项
        1.私有方法不能被重写（父类私有成员子类是不能继承的）
        2.子类方法访问权限不能更低（public >默认 >私有）
    示例代码
      

 public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}

public class Zi extends Fu {

    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }

    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

1.2.3、多态

        多态，是面向对象三大特征之一。
        多态，即是同一个对象，在不同时刻表现出来的不同形态，多态就是同一个接口，使用不同的实例而执行不同操作。

在现实生活中，例如学生是人的一种，但是他的一个具体实现李四他既是学生，也是人，老师也是如此，老师的具体实现对象李明华他既是老师同时又是一个人。
    多态的前提是要有继承或实现关系、  要有方法的重写、要有父类引用指向子类对象：Parent p = new Child();
      

多态中成员的特点
多态成员变量：编译运行看左边
         Fu f=new Zi();

         System.out.println(f.num);//f是Fu中的值，只能取到父中的值

 多态成员方法：编译看左边，运行看右边

        Fu f1=new Zi();

        System.out.println(f1.show());//f1的表面类型是Fu,但实际类型是Zi,所以调用的是重写后的方法。为什么成员方法和成员变量不一样呢？就是因为成员方法有重写。
 

   多态的好处和弊端
    好处
        提高程序的扩展性。定义方法的时候，使用父类型作为参数，再使用的时候，使用具体的子类型参与操作
    弊端
        不能使用子类的特有成员

多态中的转型
    1.向上转型
         从子到父：父类引用指向子类对象就是向上转型
            Animal  a = new Cat();
    2.向下转型
        从父到子：父类引用转为子类对象
            格式：子类型 对象名 = （子类型）父类引用;
                Cat c = (Cat )a;
    示例代码
      

  public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}
        输出结果
            吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

这边给大家看一个猫狗案例帮助大家更深刻的理解多态

​​​​​​​

动物类：

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat() {
        System.out.println("动物吃东西");
    }
}

猫类：

public class Cat extends Animal {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

   测试类：

public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类对象进行测试
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();

        a = new Cat("加菲", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
    }
}

总结：

        面向对象的三大特征封装，继承，多态我们就先分享的这里，后续会分享更多的综合案例以及细节内容，欢迎大家的持续关注。
        ​​​​​​​