面向对象的三大特征

面向对象有三个特征：封装、继承、多态

一、封装

将具体功能封装到方法中，学习对象时，也提过将方法封装在类中，这些其实都是封装。

        所谓封装，就是把客观事物封装成抽象类，一个类就封装了数据和操作这些数据的多个实体，在这些实体中，有些是私有化的，不能被外界访问，通过这种方式，对内部数据进行了不同级别的保护，如果需要访问就要提供特定的方法来进行访问。

        举个通俗的例子，电视机就是由各个部件组成的，但是我们只能看见屏幕和后面的电视机壳，那么这个电视机壳就相当于把内部部件进行封装保护，但是里面的部件有很多功能需要实现，所以电视机克上又有很多插口或者按钮，那么这些插口和按钮就是外界操纵电视机的方法途径。

所以外界要访问被保护的实体，就要提供getter()和setter()方法，同时也要提供两个或两个以上构造方法。

封装的三个好处

1. 提高了代码的复用性。

2. 隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可 以理解为就是封装的概念。

3. 提高了安全性。

完整的Java bean示例：

package com.simple.ex.day12;
//封装
public class Blogs {
    private String article;
    private String reply;
    private String board;
    private Author author;
    

    //两种构造方法
    public Blogs(String article, String reply, String plate, Author author) {
        this.article = article;
        this.reply = reply;
        this.board = board;
        this.author = author;
    }
    public Blogs(){

    }

    //setter和getter方法
    public String getArticle() {
        return article;
    }

    public void setArticle(String article) {
        this.article = article;
    }

    public String getReply() {
        return reply;
    }

    public void setReply(String reply) {
        this.reply = reply;
    }

    public String getPlate() {
        return board;
    }

    public void setPlate(String plate) {
        this.board = plate;
    }

    public Author getAuthor() {
        return author;
    }

    public void setAuthor(Author author) {
        this.author = author;
    }
}

二、继承

        在Java中，可以编写一个类去描述事物，但是通过代码演示描述多个事物，多个事物之间发现有共同的属性和行为。那么代码的复用性很差，那么怎么办呢？

为了让类与类具有联系，子类可以通过关键字extend继承父类的所有属性。

继承的好处

• 继承的出现提高了代码的复用性，提高软件开发效率。
• 继承的出现让类与类之间产生了关系，提供了多态的前提。

单继承与多继承

        因为继承，让类与类之间有了关系，但是使用继承必须保证类与类之间有所属关系，比如学生是人的一种，葡萄是水果中的一种。Java只支持单继承，不支持多继承，即一个子类只能由一个父类，不可以有多个父类。

注意：private修饰的属性和方法都是无法被子类继承的

           protected修饰的方法就是用来给子类继承的

继承代码示例：

package com.simple.ex.day12;
//继承
public class Super {
    public double money = 123456789.987654321;
    protected String car = "特斯拉";
    String company = "伯爵";
    private String sec = "星辰";

    void doing(){
        System.out.println("我不能这样做！");
    }
    private void test01(){
        System.out.println(this.money);
    }
    protected void test02(){
        System.out.println(this.car);
    }
    private void test03(){
        System.out.println(this.sec);
    }

    public Super(double money, String car, String company, String sec) {
        this.money = money;
        this.car = car;
        this.company = company;
        this.sec = sec;
    }
    public Super(){

    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public String getCar() {
        return car;
    }

    public void setCar(String car) {
        this.car = car;
    }

    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }

    public String getSec() {
        return sec;
    }

    public void setSec(String sec) {
        this.sec = sec;
    }
}

package com.simple.ex.day12;

public class Son extends Super {

    //在子类中，重写父类的方法,修饰符可大不可小，最好保持一致
    @Override//该注解表示下面是重写的方法
    public void doing(){
        System.out.println("duoduo");
    }
    public void say(){
        System.out.println("hello");
        super.doing();
    }

    public static void main(String[] args) {

        Son son1 = new Son();

        son1.doing();
        son1.say();
    }
}

三、多态

有继承才能有多态。

一个父类可以有多个子类，当子类继承父类的某种方法时，有多个对象都要调用这个行为，这样会导致代码重复性非常严重。为了提高代码的复用性，可以将这个行为的代码进行封装，然后创建对象，直接调用这个方法即可，当有其他对象时，也可以进行调用。

当每多一个对象，都要单独定义功能，封装方法让这一类的对象去做事，会发现代码的扩展性很差。如何提高代码的扩展性呢？既然是让这类对象去做事，无论是哪个具体的对象，这个方法是他们的共性，那么将这个方法进行抽取，抽取到父类中。

父类可以接受各种子类，当再让子类去做事时， 不用面对具体的子类，而只要面对父类即可。因此可以有以下代码：

public static void method(Car a){
            
                a.stop();
}

Car类就是父类，定义了一个stop()方法，其他汽车类都可以继承。

method(Car a)可以接受Car的子类型的所有汽车，而method方法不用关心是具体的哪一个类型。即就是只建立Car的引用就可以接收所有的对象进来，让它们去stop。从而提高了程序的扩展性。

多态的优缺点：

优点：提高了程序的扩展性

缺点：通过父类引用操作子类对象时，只能使用父类中已有的方法，不能操作子类特有的方法。

多态的前提：

1.继承、实现

2.通常都有重写操作

多态代码示例：

class Tesla extends Car{
void stop(){
System.out.println("停车");
    }

}

class Audi extends Car{
void stop(){
System.out.println("停车");
    }

}
public class Test {
public static void main(String[] args) {
Car a = new Tesla(); //这里形成了多态
a.stop();
Car a1 = new Audi();
a1.stop();