JAVA基础----继承

关键字：extends

一、继承特点

Java继承具有单继承的特点，每一个子类仅有一个直接父类，但是可以有很多个间接父类；

比如说：class 猫 extends 猫科动物;    class 猫科动物 extends 动物; 这样动物就是猫的间接父类；

注意所有类都继承java.lang.Object类，所以java.lang.Object是所有类的直接或间接父类。这也说明了父类可以有多个子类；

二、继承的特性

子类继承父类可以获得父类的全部成员变量和方法：

Class Fu{
public String name;
public int age;
public static info(){
    System.out.println("我是父类方法");
}
String name = "noob";
int age = 24;
}

Class Zi extends Fu{
    Zi zi = new Zi;
//这里子类就可以直接调用父类的成员变量及成员方法
    System.out.println(zi.name);  //输出noob
    System.out.println(zi.age);    //输出24
    zi.info(); //输出 我是父类方法
}

三、重写父类的方法

子类继承父类也可以说成子类在继承父类的基础上可以扩展父类；  这样的子类重写父类的方法称为方法重写（overide）也叫方法覆盖（子类方法名和父类方法名一样）

Class animal{
    public void eat(){
    System.out.println("我可以吃菜")
}
public void run(){
    System.out.println("我可以跑")
    }
}

Class dog extends animal{
//重写父类方法
    public void eat(){
    System.out.println("我不仅可以吃菜，还可以吃屎")
    }
public static void main(String[] args){
    dog d  = new dog;
        d.eat();//输出：我不仅可以吃菜，还可以吃屎
        d.run();//输出：我可以跑
    }
}

注意一：方法重写的注意点   两同两小一大；

• 两同: 方法名相同 / 形参列表相同
• 两小: 子类方法返回值类型应比父类方法返回值类型小或相等. / 子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等.
• 一大: 子类方法的访问权限应比父类方法的访问权限大或相等.

注意二：方法重写的类型必须一致，都为类方法或者都为实例方法；

这个代码就会报错：

Class Fu{
    public static void info(){
        sout("带有static，说明是类方法")
    }
}
Class Zi extends Fu{
    public void info(){
        sout("这是个成员方法")
    }
}

注意三、子类重写父类方法之后，父类方法就会被隐藏。这样子类的对象不能访问父类方法，如果要访问的话就要使用super；如果重写的是类方法，也可以使用类名.方法去调用。

public class Demo01Fu {
    public void Fumethod(){
        System.out.println("父类方法执行");
    }
    public void method(){
        System.out.println("父类method方法");
    }
}


public class Demo01Zi extends Demo01Fu {
    public void Zimethod(){
        System.out.println("子类方法执行");
    }
   /* public void method(){
        System.out.println("子类重写父类方法");  //这里我把子类方法隐藏之后，他就会向上去找父类方法，打印父类method方法；
                                                //如果没有隐藏的话，因为创建的是子类对象，就会去执行子类方法；
                                                //谁的对象被创建就先用谁；

    }*/
}


public class Demo01Extends {
    public static void main(String[] args) {
        Demo01Zi z = new Demo01Zi();
        z.Fumethod(); //父类方法执行
        z.Zimethod(); //子类方法执行
        z.method();  // 父类method方法
        Demo01Fu f = new Demo01Fu();
        f.Fumethod(); //父类方法执行
        f.method();  //父类method方法
    }
}

但是如果父类方法被private修饰，那么子类就无法访问该方法，就不能重写该方法。如果子类写了与父类同名的方法的话，不能称之为重写，而是新建了一个方法；