【Java面试题1】面向对象（OOP）的特征

面向对象的特征

四大特征：抽象、封装、继承、多态

抽象

1. 定义：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象。
2. 注意点：抽象只关注对象有哪些属性和行为，并不关注行为细节，一般我们将事务的静态特征对应类中属性，动态特征对应类中的方法/函数。
3. 代码理解：

数据抽象：表示世界中一类事物的特征，就是对象的属性。比如人有姓名、性别、身份证号等

过程抽象：表示世界中一类事物的行为，就是对象的行为。比如人会吃饭、睡觉等(类的方法)

public class Person {
    //姓名
    public String name;
    //性别
    public String sex;
    //身份证号
    public String card;
    
    
    //吃饭
    public void eat(){
        System.out.println("吃饭");
    }
    
    //睡觉
    public void sleep(){
        System.out.println("睡觉");
    }
}

封装

1. 定义：使用对象的方法将对象的变量与实现保护起来。
2. 外界只能通过对象的接口（方法）访问对象的服务，而对对象其他成员都无法访问。
3. 代码理解：
   我们类有3个变量 name、sex和card，外界不能直接访问，只能通过对象的接口（方法）访问对象的服务，我们这里类的服务：无参构成、有参构造、3个私有变量的设置和获取服务。

public class Person {
    //姓名
    private String name;
    //性别
    private String sex;
    //身份证号
    private String card;

    //无参构造
    public Person() {
    }
    
    //有参构造
    public Person(String name, String sex, String card) {
        this.name = name;
        this.sex = sex;
        this.card = card;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

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

    public String getCard() {
        return card;
    }

    public void setCard(String card) {
        this.card = card;
    }
}

继承（extends）

1. 定义：如果一个类A是另一个类B的特例，或类A和类B之间存在 is-a 关系，则类A将成为类B的子类，而类B称为类A的父类，例如矩形与多边形，可以说“矩形是一种多边形”。
2. 父子类之间具有继承关系，子类可以以分类为基础进行定义。
3. 子类与父类的差异主要体现在两个方面：

（a）子类往往对父类进行扩充，增加了新的变量和方法。
（b）子类可以改变从父类继承而来的方法，这称为方法的重写（overriding）。重写意味着子类使用与父类相同的接口，但是实现不同的行为。

4. 子类不能继承父类的什么：
   （1）带private 修饰符的属性、方法。
   （2）构造方法。

5. 单继承：只能从一个类继承，extends关键字后的类名只能有一个。

6. 子类对象的创建与实例化过程：
   Step1：子类基本初始化，分配内存，并初始化为0值。
   Step2：执行构造方法之前先执行父类的构造方法。
   Step3：执行父类构造方法之前，要执行父类显式初始化语句。

7. 代码理解

父类：

public class Person {
    //姓名
    private String name;
    //性别
    private String sex;
    //身份证号
    private String card;


    //吃饭
    public void eat(){
        System.out.println("吃饭");
    }

    //睡觉
    public void sleep(){
        System.out.println("睡觉");
    }

    //工作
    public void work(){
        System.out.println("工作");
    }

    //无参构造
    public Person() {
    }

    //有参构造
    public Person(String name, String sex, String card) {
        this.name = name;
        this.sex = sex;
        this.card = card;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

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

    public String getCard() {
        return card;
    }

    public void setCard(String card) {
        this.card = card;
    }
}

子类：保留父类的方法，调用super（）给父类中属性赋值，子类加一个属性 学号，一个方法 play（），重写父类的work（）方法。

public class Student extends Person{
    //学号
    private int ID;

    //玩
    public void play(){
        System.out.println("玩");
    }

    //重写父类work（）方法
    @Override
    public void work() {
        System.out.println("学习");
    }

    public Student() {
    }

    public Student(String name, String sex, String card, int ID) {
        super(name, sex, card);
        this.ID = ID;
    }

    public int getID() {
        return ID;
    }

    public void setID(int ID) {
        this.ID = ID;
    }
}

8. 向上转型
   定义：父类类型的引用指向子类的对象：Person student = new Student();
   特点：
   （1）该引用只能调用父类中定义的方法和变量。
   （2）如果子类中重写了父类中的一个方法，那么在调用这个方法时，将会调用子类中的这个方法。

多态

1. 定义：对外一个接口，内部多种实现。
2. 两种形式的多态：运行时多态和编译时多态。

（a）编译时多态主要通过重载（overloading）技术实现的，即在一个类中相同的方法名可以来定义多种不同的方法。
（b）运行时多态是在面向对象的继承性的基础上建立的，是运行时动态产生的多态性，重写（overriding）。

3. 重写父类方法的要求：

（1）必须返回与原来方法完全相同的返回值。
（2）方法的访问权限不能缩小。
（3）不能抛出新的异常。

4. 重载方法时要求：

（1）方法的参数必须不同，包括参数的类型或个数。
（2）方法的返回类型、修饰符可以相同，可以不同。
（3）不能通过访问权限、返回类型抛出异常。