自学java

java的继承性：就是声明一个子类，继承于父类的属性和方法，这样做减少了重复代码的编写，例如：

class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void show(){
        System.out.println("我是父类");
    }
}

class Student extends Person{

}
public class StudentTest {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("小飞");
        s.setAge(18);
        s.show();
    }
}

上述通过extends继承了Person类的属性和方法，通过创建子类的对象，修改了子类的名字和年龄，并且调用了父类的方法。当然子类也可以有自己独有的属性和方法。继承父类只是减少重复代码的书写。虽然继承了父类的方法，但是如果继承来的方法不能满足子类的需求，这时候就要进行方法的重写，用来满足本方法的需求。

例如：

class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void show(){
        System.out.println("我是父类");
    }
}

class Student extends Person{
    @Override
    public void show() {
        System.out.println("我是子类重写之后的方法");
    }
}
public class StudentTest {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("小飞");
        s.setAge(18);
        s.show();
    }
}

 重写就是override，方法名一致，返回类型一致。方法体随便。这样通过对象调用方法时就是执行的当前对象，重写之后的方法。注意要看父类的权限修饰符，如果父类的方法为私有化方法，那么就不会被直接继承，只是子类不可以直接操作它们。

权限修饰范围从大到小：public protected 缺省，private。

学了继承，我们就要了解一个关键字，叫做super，意思是父类的。可以在子类的方法中，通过super.属性和方法，调用父类的属性和方法。

例如：

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.show();
    }
}

class Person{
    String name;
    public void show(){
        System.out.println("111");
    }
    public void ass(){
        System.out.println("123");
    }
}

class Student extends Person{
    @Override
    public void show() {
        System.out.println(super.name);
        super.ass();
    }
}

上面的代码。就在子类重写的show方法中调用了父类的name属性和ass方法。super的使用可以减少重复代码的书写。例如：

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.show();
    }
}

class Person{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public void show(){
        System.out.println("Person");
    }
}

class Student extends Person{
    private int grand;
    public Student(){}
    public Student(String name,int age,int grand){
        super.setName(name);
        super.setAge(age);
        this.grand = grand;
    }

    public int getGrand() {
        return grand;
    }

    public void setGrand(int grand) {
        this.grand = grand;
    }
    @Override
    public void show() {
        System.out.println("Student");
    }
}

上面的代码可以看到，在子类中的构造中使用super调用父类的构造器给子类的对象赋值，但是这样的方法还是不够简单，在继承中子类的构造方法都会默认调用父类的无参构造器，默认在子类构造方法的首行。但是注意this(形参列表)是在另一个构造器中调用另一个构造器，通过形参列表来进行匹配，这里super和this都只能是第一行，就是说只能存在之一。

这里我们可以直接使用super（形参列表）来调用父类的对应的构造器给子类继承过来的属性进行赋值，自己独有的属性就是在构造器里自己赋值。