【JavaOOP】3、面向对象的三大特征

6. 面向对象的三大特征

6.1 封装

对当前类中不想让外界直接访问的字段或方法添加private修饰符，同时提供对外的public方法以供外界访问，外界只需要调用此方法即可，不用关系实现细节，这种行为叫“封装”。

public class Person {

    private int pid; 
    private String pname;
    private String sex; 
    private int age; 
    private String addr;
    private int cid;

    public Person(){}

    // 封装：包装内部实现细节，使用者不关心内部实现
    // 为sex字段设置公有方法，外界可以写入性别sex
    public void setSex(String sex){
        if(sex.equals("男") || sex.equals("女")){
            this.sex = sex;
        }else{
            System.out.println("你的性别有问题！");
        }
    }

    // 为sex提供公有的读取方法，外界可以获取属性
    public String getSex(){
        return this.sex;
    }
    // 提供写入年龄的方法
    // 注意：getter与setter方法代表对字段进行读写操作，我们根据我们的需求定义对应字段的读写方法，不一定两个都要同时定义。
    public void setAge(int age){
        if(age >= 1 && age <= 150){
            this.age = age;
        }else{
            System.out.println("年龄不合法！");
        }
    }

    // 提供一个读取年龄的方法
    public int getAge(){
        return this.age;
    }

    @Override
    public String toString() {
        return this.pid + "\t" + this.pname + "\t" + this.sex + "\t" + this.age + "\t" + this.addr;
    }

}

注意： 如果对类中的字段做了封装，就得在构造函数中使用对应的set方法为字段赋值。

public class TestPerson {

    @Test
    public void test01(){
        Person p1 = new Person();
        p1.pid = 1001;
        p1.pname = "张三";
        p1.setSex("男");
        p1.setAge(180);
        System.out.println(p1);
    }
}

程序运行结果：

6.2 继承

继承：
1、使用extends关键字实现继承。
2、Java是单根继承，不支持多继承。
3、每个子类的构造方法，默认都会调用父类的无参构造方法，即：super()，我们也可以手动调用父类的有参构造方法。
4、super关键字与this关键字：
① super代表父类的对象，this代表本类的对象。
② super()代表调用父类的无参构造方法，this()代表调用本类的无参构造方法。他们二者都要写在第一行上，不可能同时出现。
③ super.方法名()：代表调用父类被重写的方法。
super.属性名：代表调用父类的属性。

public class Student extends Person {       // extends: 代表继承
    private int score;          // 分数,是子类自己的属性

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        if(score >= 0 && score <= 100) {
            this.score = score;
        }else{
            System.out.println("分数不合法！");
        }
    }

    /**
     * 子类在构造方法的第一句，默认会调用父类的无参构造方法，即：super()
     * 我们可以手动调用一下父类的其他构造方法，这样才会在父子类中真正建立绑定关系。
     */
    public Student(int sid,String sname,String sex,int age,String addr,int score){
        this(sid,sname,sex,score);
        super.setAge(age);
        this.addr = addr;
    }

    public Student(int sid,String sname,String sex,int score){
        super(sid,sname,sex);
        this.setScore(score);
    }

    /**
     *  super.toString(): 代表父类被重写的toString()方法
     * @return
     */
    @Override
    public String toString() {
        return super.toString() + "\t" + this.score;
    }
}

继承关系的子类的构造方法中注意：（继承关系中的父子类构造方法说明）
① 在继承关系中，子类的构造方法的第一句默认会调用父类的午餐构造方法。
② 我们也就以在子类构造方法的第一句调用一下父类的任意一个构造方法，如果我们不调用，JVM会默认帮你调用父类的无参构造方法。
③ super(…)也必须放在子类构造方法的第一句上。
④ 在子类的构造方法中，不管是this(…)还是super(…)，只能有一个。

小结：
1、如果一个类没有继承自任何一个类，那么它的父类就是Object类。
2、使用extends实现继承，Java中的继承只能是单根继承，即一个子类只能有一个父类。
3、Java中的继承子类不能继承由private修饰的任何成员变量或方法。
4、子类不能改写父类由final修饰的方法，可以继承父类由final修饰的属性（常量）或方法，子类不能继承由final修饰的父类。
5、Java中的继承子类的构造方法默认会在第一句调用父类的无参构造方法，如果父类没有无参构造方法，则会报错。当然，我们也可以在第一句手动调用父类的其他构造方法。
6、Java中的继承子类如果想要调用父类被重写的方法，可以使用super.方法名的方式进行。
7、继承的重要作用就是为了增强代码的复用性。

6.3 多态

6.3.1 方法重载（overload）-- 静态多态性

1、在一个类的内部，方法名相同，参数列表不同的多个方法构成方法的重载。简称：一同（方法名相同）一不同（参数列表不同）。方法的访问修饰符、返回值类型都不能作为方法重载的构成条件。
2、参数列表：参数个数、参数顺序、参数类型只要有一个不同参数列表就不同。
3、多个构造方法也可以构成方法的重载。这里的构造方法是一种特殊的方法，特殊在没有返回值，名称固定与类名一致。

public class Calculator {

    public int add(int a,int b){
        return a + b;
    }
    
    // 返回值不同不能构成方法重载
    // private double add(int a,int b){
    // 	return a + b;
    // }
    
    public int add(int a,int b,int c){
        return a + b + c;
    }
    public double add(int a,double b){
        return a + b;
    }
    public double add(double a,int b){
        return a + b;
    }
}

/**
 * 测试方法重载: 静态多态性
 */
@Test
public void test04(){
    Calculator calc = new Calculator();
    double s1 = calc.add(3.4, 10);
    System.out.println("s1 = " + s1);
    double s2 = calc.add(10,2.56);
    System.out.println("s2 = " + s2);
    int s3 = calc.add(1,2);
    System.out.println("s3 = " + s3);
}

程序运行结果为：

6.3.2 方法重写（override）-- 动态多态性，即覆盖

1、方法的重写发生在继承关系的父子类中。
2、子类重写父类的方法要求：（三同一不同）
① 类的方法的访问修饰权限不得低于父类被重写方法的访问修饰权限。
② 子类与父类方法返回值类型、方法名、参数列表都必须完全相同。

// 父类
public class Person {
    public void sayHello(){
        System.out.println("Person: SayHello()");
    }
}

// 子类
public class Student extends Person {
    @Override
    public void sayHello() {
        System.out.println("Student: sayHello()");
    }
}