Java学习 三 核心技术——类的封装，继承与多态

类的封装性
类的封装是因为如果输入的数据是不合理的话，那么它的结果一定也是不合理的，为例的解决这种问题就需要用到类的封装性了：

1. 利用get（）方法实现数据的返回
2. 利用set（）方法实现数据的获得
3. 不让外部直接接触类的内部变量

package com.gao;

public class Test_6 {
    public static void main(String[] args) {
        People people = new People();
        System.out.println("name:"+people.getName()+"\nsex:"+people.getSex()+"\ngrade:"+people.getGrade());
        people.setName("timi");
        people.setSex("man");
        people.setGrade(26);
        System.out.println("******************************************************8");
        System.out.println("name:"+people.getName()+"\nsex:"+people.getSex()+"\ngrade:"+people.getGrade());
    }
}

class People{
    private String  name;
    private String sex;
    private int grade;
    public People(){
        this.name = "nina";
        this.sex = "woman";
        this.grade = 23;
    }

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

    void setSex(String sex){
        if((sex == "woman")||(sex == "man")){
            this.sex = sex;
        }
        else{
            System.out.println("输入错误\n请输入“woman“或”man“");
        }
    }
    void setGrade(int grade){
        if (grade>=10){
            this.grade = grade;
        }
        else{
            System.out.println("抱歉你所输入的年龄不符合要求！");
        }
    }

    String getName(){
        return this.name;
    }
    String getSex(){
        return this.sex;
    }
    int getGrade(){
        return this.grade;
    }
}

类的继承性
一个子类同时只能继承一个父类，不能同时继承多个父类即：

class 子类名称 extends 父类名称{
}

但可以多层继承：

class 子类_1 extends 父类_1{
}
class 子类_2 extends 子类_1{
}

实例：

package com.gao;

public class Test_7 {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.getName());
    }
}

class Student extends People{

}

在子类实例化的时候，首先默认调用父类的构造方法，然后再调用自己的构造方法；

super关键字的作用？

super的作用：主要是在子类中用于继承父类的属性或方法

限制子类的继承：当父类的属性或方法为“private”的时候这个属性（方法）是无法在子类中被调用的

类的覆写
子类可以在自己内部重新复写父类的方法或属性：

package com.gao;

public class Test_7 {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.getName());
    }
}

class Student extends People{
    @Override
    String getName() {
        String temp;
        temp = "（这是覆写之后的getName方法）"+super.getName();
        return temp;
    }
}

类的多态

package com.gao;

public class Test_7 {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.getName());
        //这里的父对象是由子对象实例化出来的
        People people = new Student();
        //调用的getName（）方法得到的依然是子类的覆写方法
        System.out.println(people.getName());
    }
}

class Student extends People{
    @Override
    String getName() {
        String temp;
        temp = "（这是覆写之后的getName方法）"+super.getName();
        return temp;
    }
}

父类与子类之间存在：

1. 向上转型（自动完成）
2. 向下转型（需要奇迹转换，但不一定都成功）

解释：
跑车是可以称为汽车（子类用父类表示——向上转型）
但汽车不都是跑车（父类用子类表示——向下转型）