java学习（面向对象基础）

一、继承(代码复用性）

继承可以解决代码复用，让我们的编程更加靠近人类思维，当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。

继承的基本语法：class子类 extends 父类{}

1）子类就会自动拥有父类的属性和方法

2）父类又叫超类，基类

3）子类又叫派生类

以下是一个便于更好理解继承的例子

1)首先定义一个父类Student

package object;

public class Student {
    public String name;
    public int age ;
    public int rank;
    public double score;

    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setRank(int rank){
        this.rank=rank;
    }
    public void setScore(double score){
        this.score=score;
    }
}

2）定义pupil子类

package object;

public class pupil extends Student{
    public  void show() {
        System.out.println("小学生的信息为：");
        System.out.println(name+"\t"+age+"\t"+rank+"\t"+score+"\t");
    }
}

3）定义undergraduate子类

package object;

public class undergraduate extends Student{
    public void show(){
        System.out.println("该大学生信息为：");
        System.out.println(name+"\t"+age+"\t"+rank+"\t"+score+"\t");
    }
}

4）最后定义一个test1类进行操作

package object;

public class test1 {
    public static void main(String[] args) {
        pupil pupil1 =new pupil();
        pupil1.setName("小王");
        pupil1.setAge(10);
        pupil1.setRank(1);
        pupil1.setScore(99);
        pupil1.show();
        //输出结果为
        //小学生的信息为：
        //小王	10	1	99.0

        undergraduate n1 =new undergraduate();
        n1.setName("大王");
        n1.setAge(20);
        n1.setRank(1);
        n1.setScore(100);
        n1.show();
        //输出结果为：
        //该大学生信息为：
        //大王	20	1	100.0
    }
}

引入新知识：super关键字

a）含义：super代表父类的引用，用于访问父类的属性、方法、构造器

b）用以下例子来解释其三个特点：

//先定义一个父类
package object;

public class base {
    public int n1=100;
    protected int n2=200;
    int n3=300;
    private int n4=400;

    public void test1(){
    }
    protected void test2(){
    }

    void test3(){
    }
    private void test4()
    {
    }
}

1）访问父类的属性，但不能访问父类的private属性。

package object;

public class improve extends base{
    public void test(){
        System.out.println(super.n1);
        System.out.println(super.n2);
        System.out.println(super.n3);
        System.out.println(super.n4);//由于n4是私有的，所以不能进行访问。
    }
}

2）访问父类的方法，不能访问父类的private方法。

package object;

public class improve extends base{
    public void test(){
        super.test1();
        super.test2();
        super.test3();
        super.test4();//由于test4方法是私有的，所以不能进行访问。
    }
}

3）访问父类的构造器：super(参数列表)，只能放在构造器的第一句，只能出现一句。

    public  improve(){
        super();//访问父类的无参构造器。
    }

c）super关键字的细节

1）调用父类的构造器的好处(分工明确，父类属性由父类初始化，子类的属性由子类初始化)

2）当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super（在使用super找方法时，与this和直接访问不同，在调用方法时，没有查找本类这一步骤）、this、直接访问是一样的效果！

3)super的访问不局限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类中都有同名的成员，使用super访问遵循就近原则。

插入知识：调用某方法的顺序是：

（1）先找本类，如果有，则调用。

（2）如果没有，则找父类（如果有，并可以调用，则调用）。

（3）如果父类没有，则继续找父类的父类，直到object类。

提示：如果在查找方法的过程中找到了，但不能访问，则报错；如果在查找方法的过程中，没有找到，则提示方法不存在。