关于Java继承

一:

1.继承是Java中提供了一个关键字extends，用这个关键字，可以让一个类和另一个类建立起父子关系。

public class static1other extends static1{}

2.继承的特点是子类能够继承父类的非私有成员（成员变量，成员方法）。

3.子类的对象是由子类，父类共同完成的。

4.带继承关系的类，Java会用类和其父类，这多张设计图来一起创建类的对象。

5.对象创建出来后能够直接访问什么成员，是由子父类这多张设计图共同决定的，这多张设计图对外暴露了什么成员，对象就可以访问什么成员。

注意：继承中由子类创建出来的对象可以访问子类和父类中非私有的成员，但由父类创建出来的对象只能够访问父类中非私有的成员。

6.继承的案例：可以减少重复代码的编写，提高代码的复用性。

public class static1 {
    private String name;

    public String getName() {
        return name;
    }

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

public class static1other extends static1{
    private String skills;

    public String getSkills() {
        return skills;
    }

    public void setSkills(String skills) {
        this.skills = skills;
    }
}

public class static1apply {
    public static void main(String[] args) {
        static1other s = new static1other();
        s.setName("蔡建宇");
        s.setSkills("瓦罗兰特，CSGO2");
        System.out.println(s.getName());
        System.out.println(s.getSkills());
    }
}

二:权限修饰符

1.权限修饰符就是用来限制类中的成员（成员变量，成员方法，构造器，代码块...）能够被访问的范围。

2.修饰符共有四种 它们的作用如下

注意：对于protected限制的在任意包下的子类里访问 是指只能在子类中去访问 而不是在其他类中用其子类的对象去访问

三:继承相关的两个注意事项

1.Java是单继承的：一个类只能继承一个直接父类；Java中的类不支持多继承，但是支持多层继承。

2.object类是Java中所有类的祖宗，所有类都直接，间接或者多层继承于object类

四:方法重写

1.方法重写就是子类写了一个方法名称，形参列表与某个父类某个方法一样的方法去覆盖父类的该方法。

2.方法重写的注意事项：

建议加上：@Override注解，可以效验重写是否正确，同时可读性好。

子类重写父类方法时，访问权限必须大于或者等于父类被重写的方法的权限。

重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。

私有方法，静态方法不能重写。

3.方法重写的应用场景：当子类觉得父类的方法不好用，或者不满足之间的需求时，就可以用方法重写。

注意方法重写中输出的访问讲究就近原则

例如：在static1 类中 作为 object的子类来改写object类中的toString的方法

@Override
public String toString() {
    return "static1{" +
    "name='" + name + '\'' +
    ", age=" + age +
    '}';
}

static1 s1 = new static1("蔡建宇",12);
System.out.println(s1);

结果为

若不进行改写用则使用s1默认输出的是对象在内存中的地址

四:子类访问成员的特点

1.在子类方法中访问其他成员（成员方法，成员变量），是依照就近原则的。

先在子类局部范围找。

然后在子类成员范围找。

最后在父类成员范围找，如果父类范围还没有找到则报错。

2.若是子父类中出现了重名的成员，会优先使用子类的，如果此时一定要在子类中使用父类成员可以通过super关键字，指定访问父类的成员：super.父类成员变量/父类成员方法

例如：

五:继承中关于构造器

1.子类构造器的特点：子类的全部构造器，都会先调用父类的构造器，再执行自己。

子类调用父类的构造器在默认情况下 子类的全部构造器的第一行代码都是 super() （写不写都有），它会调用父类的无参数构造器。

2.如果父类没有无参数构造器，我们必须在子类构造器的第一行手写super(……),指定去调用父类的有参数构造器。

其常见的应用场景为：为对象中包含父类这部分的成员变量进行赋值。

public class static1 {
    public static void main(String[] args) {
        Z z = new Z("蔡建宇",18,"eat");
        System.out.println(z.getSkill());
        System.out.println(z.getAge());
        System.out.println(z.getName());
    }
}
class F{

    private String name;
    private int age;

    public F() {
    }

    public F(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;
    }
}
class Z extends F{
    private String skill;
    public Z(String name,int age,String skill){
        super(name, age);
        this.skill = skill;
    }
    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }
}

3.this兄弟构造器

在任意类的构造器中，是可以通过this(……)去调用该类的其他构造器的

public class static1other{
    public static void main(String[] args) {
        A a = new A("蔡建宇",18,"男");
        A a1 = new A("王凯",19);
        System.out.println(a1);
    }
}
class A{
    private String name;
    private int age;
    private String sex;

    public A(String name, int age) {
        this(name ,age ,"未知");
    }

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

    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

注意：this(……)和super(……)的使用都必须放在构造器的第一行，因此this(……)和super(……)不能同时使用。