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

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

封装

概念：
就是把事物的特征，封装成对象的属性，并私有化，防止外界随意访问，行为封装成对象的方法，之后再对外提供公共方法，用于设置和获取属性，属性操作都必须通过提供的方法，来间接进行，增强安全性和可维护性。

public class Student {
    private String name;//属性私有化
    private int age;
    private boolean sex;//性别2个值 用boolean 节约内存

    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 boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }
}

另一个文件中调用

public class StudentTest {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("八哥");
        System.out.println(stu.getName());
    }
}

继承

概念：
继承就是先抽取共性，作为父类，子类继承父类的特征和行为，使得子类对象具有父类的属性（非私有）和方法。

语法：
通过 extends 关键字声明继承关系，一般形式如下：

class 父类 {
}
 
class 子类 extends 父类 {
}

注意：
当一个类没有继承的关键字，则默认继承 Object 祖先类。
有 final 关键字修饰的类，无法被继承

用处：
重复的代码写入父类，子类继承，新建多个对象的时候，代码更加简洁，提高代码的复用性，便于维护

特性：
子类拥有父类非 private 的属性、方法。

子类可以对父类的属性和方法进行扩展。

子类可以用自己的方式实现父类的方法。

Java 的继承是单继承，也可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是A继承B，B继承C，C就是始祖类，每次继承也都只有一个父类。

super 与 this 关键字
super关键字：持有父类的引用地址，我们可以通过它来实现对父类成员的访问。

this关键字：持有当前对象的引用地址。

public class ExtendsDemo {
    public static void main(String[] args) {
        Animal dog = new Dog();//父类接收 多态
        dog.eat();
        Dog dog1 = new Dog();//自己接收
        dog1.eatTest();
    }
}

class Animal{

    void eat(){
        System.out.println("天天吃草。。。");
    }
}

class Dog extends Animal{
    void eat(){
        System.out.println("顿顿吃肉。。。");
    }
    void eatTest() {
        this.eat();   // this 调用自己的方法
        super.eat();  // super 调用父类方法
    }
}

/*
运行结果：
顿顿吃肉。。。
顿顿吃肉。。。
天天吃草。。。
*/

多态

概念：
一种事物，多种形态
对程序而言，就是java编译和运行不一致的情况

Animal dog = new Dog();//用父类接收 子类创建的对象
dog.eat();//如果父类Animal中没有eat方法编译就会报错，不会去找子类Dog中的eat方法

存在条件：
继承关系，覆写方法，父类接收子类创建的对象

多态的好处：
可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

实际：
在实际开发中，如A类继承B类，父类接收（B b=new A()），如果在A类中不重写B类的方法的时候，调用的是B类方法，运行先在自身找，没有就往上找父类，一直找到Object；如果A类中重写了B类的方法，调用的是A类方法