面向对象 继承（1）

继承

继承：
多个类有共同的成员变量和成员方法，抽取到另外一个类中（父类），在让多个类去继承这个父类，我们的多个类就可以获取到父类中的成员了。

extends关键字

格式：
class 子类 extends 父类 {}

public class ExtendsDemo {
    public static void main(String[] args) {
        DotA1 d = new DotA1();
        d.start();
        
        LOL1 l = new LOL1();
        l.start();
    }
}

class Game1 {
    String name;
    double version;//版本号
    String agent;//代理商
    
    public void start() {
        System.out.println("游戏启动了");
    }
    
    public void stop() {
        System.out.println("游戏关闭了");
    }
}

class DotA1 extends Game1 {

}

class LOL1 extends Game1 {
    
}

继承的特点

1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类
2.多个类可以继承一个父类，例如下面这种情况是允许的。

     class A{}
     class B extends A{}
     class C extends A{}   

3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。

     class A{}
     class B extends A{}   // 类B继承类A，类B是类A的子类
     class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类

一个父类可以有多个子类，但一个子类只有一个父类

    public static void main(String[] args) {
        CSGO C = new CSGO();
        l.update();
        l.start();
    }
}

class Game {
    public void start() {
        System.out.println("游戏启动了");
    }
}

class PCGame extends Game {
    public void update() {
        System.out.println("PCGame更新了");
    }
}

class MobileGame extends Game {
    public void update() {
        System.out.println("MobileGame更新了");
    }
}

class CSGO extends PCGame {
    
}

继承中成员变量的特点

A:子类只能获取父类非私有成员
子父类中成员变量的名字不一样直接获取父类的成员变量
子父类中成员变量名字是一样的获取的是子类的成员变量

B:就近原则：谁离我近我 就用谁
如果有局部变量就使用局部变量
如果没有局部变量，有子类的成员变量就使用子类的成员变量
如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量
C: super:可以获取父类的成员变量和成员方法,用法和this是相似的

public static void main(String[] args) {
        Kid3 k = new Kid3();
        k.show();
    }
}

class Dad3 {
    String name = "建霖";
}

class Kid3 extends Dad3 {
    String name = "四葱";
    
    public void show() {
        String name = "五葱";
        
        System.out.println(super.name);
        System.out.println(this.name);
        System.out.println(name);
    }

继承中成员方法的特点和方法重写

A:子类中没有这个方法,调用父类的
B: 子类中重写了这个方法，调用子类的
a：方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法

b：方法的重载：在一个类中，有多个重名的方法，但是其参数不一样（参数的个数，参数的类型，参数的顺序），和返回值无关

    public static void main(String[] args) {
        Kid4 k = new Kid4();
        k.eat();
    }
}

class Dad4 {
    public void eat() {
        System.out.println("小酌两口");
        System.out.println("去睡觉了");
    }
}

class Kid4 extends Dad4 {
    public void eat() {//无重载情况继续调用父类方法
        System.out.println("好好吃饭");
    }

方法重写的应用场景和注意事项

方法重写的应用场景：当父类的方法不能完全满足子类使用的时候，既可以保留父类的功能（沿袭、传承），还可以有自己特有的功能

方法重写的注意事项：
不可以重写父类私有的成员方法，压根就看不到父类的私有成员

子类重写父类方法，权限必须大于等于父类方法的权限

注解

@Override：方法重写，说明下面的方法是重写父类的方法

public static void main(String[] args) {
        NewPhone np = new NewPhone();
        np.call();
    }
}

class Phone {
    void call() {
        System.out.println("打电话");
    }
}

class NewPhone extends Phone {
    
    @Override
    public void call() {
        System.out.println("录音");
        //System.out.println("打电话");
        
        //super.call();//调用父类的方法
    }