面向对象编程有三大特性：封装、继承、多态。

封装

概念：就是对一个对象的属性或方法私有化，同时提供一些可以被外界访问属性的方法。

• 封装属性

class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

/**
 * 封装属性：
 *  1.将属性私有化，使用private关键字修饰
 *  2.然后通过set来设置私有属性的值，通过get来获取私有属性的值
 *  3.封装属性后，无法通过实例化对象访问属性，即 实例化对象.属性名 无效
 */
public class Demo {
    public static void main(String[] args) {
        Student student=new Student();
        // ; // 无法通过这种方式访问属性或设置属性值

        student.setName("张三");// 通过setXXX(Val)方法设置属性值
        System.out.println(student.getName());// 通过getXXX()方法获取属性值
    }
}

我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。

继承

概念：在已经存在的类的基础上建立新的类，新类的定义可以增加新的属性和方法，也可以使用父类的方法，还可以重写父类的方法，最大的好处就是提高了代码的可复用性。

提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。

继承的三个注意事项：

• ⼦类拥有⽗类对象所有的属性和⽅法（包括私有属性和私有⽅法），但是⽗类中的私有属性
  和⽅法⼦类是⽆法访问，只是拥有。

class Father {
    public String name;// 公有属性
    private String identity;// 私有属性

    public Father(String name, String identity) {
         = name;
        this.identity = identity;
    }

    // 共有方法
    public void say() {
        System.out.println("我的名字是：" + name);
    }

    // 私有方法
    private void publish() {
        System.out.println("我的身份是" + identity);
    }
}

class Son extends Father {
    public Son(String name, String identity) {
        super(name, identity);
    }
}


public class Demo {
    public static void main(String[] args) {
        Son son = new Son("张三", "父亲");
        son.say();// 访问父类的公有方法
        System.out.println();// 访问父类的公有属性

        son.publish();// 无法访问父类的私有方法
        son.identity;// 无法访问父类的私有属性，报编译错误：identity' has private access in 'Father'
    }
}

• 子类可以拥有自己独有的属性和方法。

class Father {
    public String name;// 公有属性
    private String identity;// 私有属性

    public Father(String name, String identity) {
         = name;
        this.identity = identity;
    }

    // 共有方法
    public void say() {
        System.out.println("我的名字是：" + name);
    }

    // 私有方法
    private void publish() {
        System.out.println("我的身份是" + identity);
    }
}

class Son extends Father {
    public String lesson;// 子类独有的属性

    public Son(String name, String identity) {
        super(name, identity);
    }

    // 子类独有的方法
    public void learn(){
        System.out.println("学习"+lesson);
    }
}


public class Demo {
    public static void main(String[] args) {
        Son son = new Son("张三", "父亲");
        son.say();// 访问父类的公有方法
        System.out.println();// 访问父类的公有属性

        // son.publish();// 无法访问父类的私有方法
        // son.identity;// 无法访问父类的私有属性，报编译错误：identity' has private access in 'Father'

        son.lesson="语文";
        son.learn();
    }
}

• 子类可以重写父类的方法。

class Father {
    public String name;// 公有属性
    private String identity;// 私有属性

    public Father(String name, String identity) {
         = name;
        this.identity = identity;
    }

    // 共有方法
    public void say() {
        System.out.println("我的名字是：" + name);
    }

    // 私有方法
    private void publish() {
        System.out.println("我的身份是" + identity);
    }
}

class Son extends Father {
    public String lesson;// 子类独有的属性

    public Son(String name, String identity) {
        super(name, identity);
    }

    // 子类独有的方法
    public void learn() {
        System.out.println("学习" + lesson);
    }

    // 重写父类的方法
    @Override
    public void say() {
        System.out.println("我是子类，我可以重写父类的方法");
    }
}


public class Demo {
    public static void main(String[] args) {
        Father father = new Father("张三", "父亲");
        father.say();

        Son son = new Son("张三", "父亲");
        son.say();
    }
}
/**
 * 打印结果：
 * 我的名字是：张三
 * 我是子类，我可以重写父类的方法
 */

多态

概念：指允许不同类的对象对同一消息做出不同的响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

关于多态的解释可以参考这篇博客：https:///mz-lover/p/4786337.html

用比较贴近生活的例子来说，在生活中狗、猫、鸟都会叫，但叫的声音不一样，狗叫“汪汪汪”、猫叫“喵喵喵”、鸟叫“啾啾啾”。

在这里“狗、猫、鸟”就是“不同类的对象”，而“叫”就是“同一消息”，最后叫出不同的声音“汪汪汪”、“喵喵喵”、“啾啾啾”就是“不同的响应”。

多态的三个必要条件：继承（普通类继承、接口实现）、重写、父类引用指向子类对象

class Father {
    public void print() {
        System.out.println("Father");
    }
}

class Son extends Father {// 继承

    // 重写方法
    @Override
    public void print() {
        System.out.println("Son");
    }
}

/**
 * 简单的多态应用
 */
public class Demo {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Father son = new Son();
        son.print();
    }
}
/**
 * 打印结果：
 * Son
 */

多态性分为编译时的多态性和运行时的多态性。方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。

在 Java 中有两种形式可以实现多态：继承（多个⼦类对同⼀⽅法的重写）和接⼝（实现接⼝并覆盖接⼝中同⼀⽅法）。

interface Animal {
    public void say();
}

class Dog implements Animal {
    @Override
    public void say() {
        System.out.println("汪汪汪");
    }
}

class Cat implements Animal {
    @Override
    public void say() {
        System.out.println("喵喵喵");
    }
}

class Bird implements Animal {
    // 实现接口
    @Override
    public void say() {
        System.out.println("啾啾啾");
    }
}

/**
 * 使用接口实现多态
 */
public class Demo {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Animal dog = new Dog();
        dog.say();

        Animal cat = new Cat();
        cat.say();

        Animal bird = new Bird();
        bird.say();
    }
}
/**
 * 打印结果：
 * 汪汪汪
 * 喵喵喵
 * 啾啾啾
 */

抽象

默认情况下面向对象有三大特性：封装、继承、多态，但有时候也会问到第四种，就是抽象。

概念：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。