继承

1、继承的基本概念： 扩展父类的功能
2、JAVA中使用extends完成继承
class 子类 extends 父类{ }

package w;
// 创建一个类
class People{
    private int age;
    private String name;
    //自动创建set,get
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

//再创建一个类
class Student{
    private int age;
    private String name;
    private int score;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }

    }
//人和学生中都有age,name代码冗余了
public class asdf {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

对比如下：

package w;
// 创建一个类
class People{
    private int age;
    private String name;
    //自动创建set,get
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
public void tell() {
    System.out.println("姓名"+getName()+"年纪"+getAge());
}

}

//再创建一个类
//继承父类
class Student extends People{
    /*private int age;
    private String name;*/
    private int score;
/*  public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }*/
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    public void say() {
        System.out.println("分数"+getScore());
    }

    }
//人和学生中都有age,name代码冗余了
public class asdf {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
//实例化子类对象
        Student s=new Student();
        //用Student调用父类的方法

        s.setAge(20);
        s.setName("zhangsan");
        s.setScore(100);
        s.tell();
        s.say();
    }

}

JAVA继承的限制

1、在JAVA中只允许单继承（没有继承2次比如下面那个代码）
2、子类不能直接访问父类的私有成员
代码演示如下：
可以单继承可以多层继承

package scavenger;
class Person{

     int age;
}
class Worker extends Person{


}
class PetWorker extends Worker{
    public void tell() {

    System.out.println(age);
    }

}
public class wzjy {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

子类不能直接访问其父辈变量（private型）要通过set、get来访问（可以自动生成）。
代码如下：

package scavenger;
class Person{

    private int age;

    public int getAge() {
        return age;
    }

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

}
class Worker extends Person{
    public void tell() {

        System.out.println(getAge());
        }

}
/*class PetWorker extends Worker{
    public void tell() {

    System.out.println(age);
    }

}*/
public class wzjy {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Worker w=new Worker();
        w.setAge(100);
        w.tell();


    }

}

JAVA子类实例化过程

在子类对象实例化之前，必须先调用父类中的构造方法，之后调用子类构造方法。

代码如下：

package scavenger;
class Father{
    private String name;
    private int age;
    //创建一个构造方法
    public Father(){
        System.out.println("父类的构造方法");

    }
}

class Son extends Father{
    public Son() {
        System.out.println("子类的构造方法");
    }
}

public class erere {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
//构造方法不需要调用直接实例化
        Son s=new Son();
    }

}

结果：*父类的构造方法
子类的构造方法
*
（先执行父类的构造方法，再执行子类的构造方法）

方法的重写

1、在继承中也存在着重写的概念，其实就是子类定义了和父类同名的方法。
2、定义：方法名称相同，参数相同，返回值类型也相同
3、重写限制：被子类重写的方法不能拥有比父类更加严格的访问权限
4、访问权限：private”<”default(什么都不写的方法，void tell(){})”<”public
*private只能在当前类中进行访问
default在整个包下进行访问
public在整个工程下都能进行访问*
所以顾名思义，父类定义了default类型的方法话，子类不能定义private类型的方法了。

package scavenger;
class A {
public void tell() {

        System.out.println("我重写了tell方法");
        }
}
class B extends A{
public void tell() {

        System.out.println("我重写了tell方法");
        }
} 
public class QWT {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        B b = new B();
        b.tell();
    }

}

结果是：我重写了tell方法
我们发现父类的方法没有执行，而我们必须要让父类中的方法执行，则用到一个关键字super，代码如下：

package scavenger;
class A {
public void tell() {

        System.out.println("我重写了tell方法");
        }
}
class B extends A{
public void tell() {
        super.tell();
        System.out.println("我重写了tell方法");
        }
} 
public class QWT {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        B b = new B();
        b.tell();
    }

}

super关键字强行调用父类方法的执行
super不一定在重写中使用，也可以表示那些方法时从父类中继承而来的。

重写与重载