继承（java）

小白一枚，若有侵权，请指出，谢谢

面对对象程序设计三大特性之一：继承

继承

  在原有的类的基础之上，加以拓展，从而产生新的子类（is A关系），子类其实就是父类的一种特殊情况（开发时，抽取子类共性，形成父类）

 

继承的格式：class 子类名 extends 父类名（继承会破坏封装）

注意：object类是所有类的根类，一个类的直接父类或者间接父类都是object类。object 表示对象，object 类是对象的封装体

子类可以继承到父类的哪些成员?
     1.如果使用的public或者protected修饰，子类可以继承.
     2.如果使用是包访问权限（即属性或者方法修饰符不写的情况）如果子类和父类 在同包中，可以继承，否则不可以继承.
     3.父类的成员使用private,子类不能继承.
  4.父类的构造器，子类不能继承.

构造器（构造方法）：

子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器重写了带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。

如果父类有无参构造器，则在子类的构造器中不用super调用父类构造器，系统会优先自动调用父类的无参构造器。

注意：在java中,只允许单继承,但允许多重继承,但是一般不要超过五重继承。

 继承则会涉及到方法的覆盖（Override）

方法覆盖

使用原则：子类继承父类的时候，某个方法不适合子类本身，所以需要对父类的方法进行覆盖。

1.该方法若有返回值，子类的返回类型小于等于父类方法的返回类型    （例如：父类给long类型的返回值，则子类必须给小于等于long的类型）

2.子类方法不能抛出新的异常

3.子类方法的修饰符权限必须大于等于父类方法的修饰符

4.子类的方法要是想覆盖父类的方法，则方法的名称要相同，参数类型及个数要相同

最好的解决：
直接赋值父类的方法定义到子类，重新定义方法体
 
判断覆盖的准则
用@Override 判断是否覆盖

注意：方法的覆盖，重写，只能对方法有效。类，字段，构造器没有覆盖的概念
 

class Bird{
    protected void fly() {
        System.out.println("飞得更高");
    }
}

class Qier extends Bird {
    
    //覆盖了父类的fly()方法
    @Override
    protected void fly() {
        super.fly();
        System.out.println("折翼天使 飞不动 ！！！！！！");
    }
}
public class OverrideDemo {
    public static void main(String[] args) { 
        
        Bird b = new Bird();
        b.fly();
        
        System.out.println("------------------");
        
        Qier q = new Qier();
        q.fly();
        
        
    }
}

 super关键字

使用super关键字：指向当前对象的父类对象

 super的应用场景：
         1.在子类的方法中，调用父类被覆盖的方法 super.父类方法名()
         2.在子类方法中，返回父类被隐藏的成员变量
         3.在子类构造器中，调用父类的构造器

//动物类
class Animal1{
    private String name;
    private int age;
    
    public Animal1(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public void say() {
        System.out.printf(this.name + "  年龄：" + this.age);
    }
}

//鱼类
class Fish extends Animal1{
    private String color;
    
    //构造器
    public Fish(String name,int age,String color) {
        super(name,age);//用super获取父类的字段
        this.color = color;
    }
    
    public void say() {
        super.say();//使用super获取父类被覆盖的方法
        System.out.printf("  颜色：" + color);
    }
}

//super关键字的使用
public class SuperDemo02 {
    public static void main(String[] args) { 
        
        /*
         * 子类的创建过程
         * 先对父类初始化，再对子类初始化
         * 在调用子类构造器之前，会先调用父类构造器,若父类没有重写构造器，则调用系统默认的构造器（无参）。调用时严格区分无参构造器和有参构造器
         * 注意：若重写了构造器，则不能使用系统默认构造器
         */
        
        Fish f = new Fish("小丑鱼",1,"红色");
        f.say();
    }
}

this关键字

使用this关键字：指向当前对象，哪个对象调用了this所在的成员，this就是哪个对象，哪一个对象调用this所在的方法，该方法中的方法的this就是哪一个对象

this的使用场景：
         1.解决成员变量和局部变量的二义性（必须使用setter方法）
         2.同一个类中多个实例方法间互调，当前类方法互调用this（默认可不写，标准化要写）
         3.将当前对象作为参数传递给另一个方法
         4.将当前对象作为方法的返回值

注意：
         1.构造器重载的互调，this必须写在第一行
         2.static不能与this一起使用

注意：
   1.静态方法不能覆盖，静态方法属于类方法，优先于对象的存在（若对静态方法覆盖会报错）

   2.静态方法与静态变量一样，属于类本身，而不属于类的某一个对象。

   3.调用一个被定义为静态（static）的方法，可以通过在它前面加上这个类的名称，也可以像调用非静态方法一样通过类对象调用。

public class ThisDemo {
    
    private String name = "成员变量";
    public int age;
    
    void setName(String name) {
        this.name = name;
    }
    
    //无参构造器
    public ThisDemo() {
        System.out.println("无参数构造器！");
    }
    
    //重写构造器，一个参数
    public ThisDemo(String name) {                       
        this();//调用无参构造器，必须写在第一行 若重写了构造器， 则不能使用系统默认构造器，这里会出错
        this.name = name;
    }
    
    //两个参数的构造器
    ThisDemo(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    void show() {
        System.out.println("show");
    }
    
    void doWork() {
        String name = "局部变量";//局部变量和成员变量同名，局部变量隐藏成员变量，此时可使用this解决
        System.out.println(name);
        System.out.println(this.name);

    //将当前对象作为方法的返回值
    ThisDemo append() {
        return this;
    }
    
    
    public static void main(String[] args) { 

        //创建对象方法1 匿名对象，调用无参构造器
        new ThisDemo();//若没有写构造器，系统默认会提供构造器。但是写了有参构造器（则系统不会再提供无参构造器），这里调用无参构造，会出错
        //output：无参构造器！
        
        System.out.println("----------------");
        
        //创建对象方法2
        ThisDemo d = new ThisDemo("乔峰");//调用一个参数的构造器  output：无参构造器！  乔峰
        System.out.println(d.name);
        
        System.out.println("----------------");
        d.setName("lucy");
        System.out.println(d.name);//output：lucky
        
        System.out.println("----------------");
        
        new ThisDemo("zzz",45);
        System.out.println(d.name + "," +  d.age);//output：lucky,0 为什么不是zzz,45？这里虽然调用了两个参数的构造器，
                                                  //但是仍然用的是上面的引用对象,其值仍然为lucky，age为默认0
        
        System.out.println("----------------");
        
        //创建对象方法2 这里调用无参构造器
        ThisDemo d2 = new ThisDemo();//output：无参构造器！
        
        System.out.println("----------------");
        d2.show();//output：show
        
        System.out.println("----------------");
        d2.doWork();//output：局部变量
        
        ThisDemo d3 = d2.append();//这里通过append方法将当前对象作为方法的返回值，可以做其他操作
    }
}

1.局部变量和成员变量同名，局部变量隐藏成员变量，使用this关键字解决
 2.在满足继承条件下，子类存在和父类相同的成员变量，子类变量隐藏了父类变量，使用super解决
 3.在满足继承条件下，子类存在和父类相同的静态方法