继承

继承意思就是将父类的属性和方法拿到子类中使用
子类继承父类之后，可以使用父类的某些属性和方法

java继承是单继承，只能有一个父类
但可以多重继承，即A继承B，然后B在继承C，间接的A继承C

继承作用

可以减少重复的代码

语法格式

class 子类 extends 父类{
}

注意事项：

成员属性
1.公开的和默认的属性可以被继承
2.私有的成员变量不能被继承
成员方法
1.公开的和默认的方法可以被继承
2.私有的成员方法不能被继承
总结：
凡是私有的都无法继承
构造方法
先执行父类的构造方法，在执行子类的构造方法。

package com.baidu.b_extends;
class Father{
    //公开的和默认的属性都可以被继承
    public String name;//公开的属性
    int age;//默认的属性
    
//  私有的不能被继承
    private int id;
    
    
    public Father() {
        System.out.println("父类构造方法");
    }
    //公开的方法
    public void eat() {
        System.out.println("吃饭");
    }
    //默认的方法
    void work() {
        System.out.println("剪花");
    }
    //私有方法
    private void smoke() {
        System.out.println("抽烟");
    }
}
class Son extends Father{
    public Son() {
        System.out.println("子类构造方法");
    }
    
}
public class Demo1 {
    public static void main(String[] args) {
        Son son = new Son();
        son.name = "小明";
        son.age = 12;
//      son.id = 123;报错：私有属性不能被继承
        
        son.eat();
        son.work();
//      son.smoke();私有的方法，不能被继承
    }
}

如果子类想使用父类中private修饰的成员变量和成员方法可以进行以下操作

package com.baidu.b_extends;
class Father1{
    //name无法直接被继承，但是可以使用set和get方法进行操作
    //因为set 和 get 方法是公开的
    private String name;
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //private 修饰的方法无法直接被继承，但是可以将smoke方法放在一个public修饰
    //的方法中，进行调用，间接的被继承
    private void smoke() {
        System.out.println("抽烟");
    }
    public void smokeing() {
        this.smoke();
    }
}
class Son1 extends Father1{
    
}
public class Demo2 {
    public static void main(String[] args) {
        Son1 son1 = new Son1(); 
        son1.setName("我是老大");
        System.out.println(son1.getName());
        son1.smokeing();
    }
}

内存分析

3.png

重写（重点）针对方法

Override
重写的目的：子类可以继承父类的非私有的方法，但是有的时候父类方法满足不了子类的要求，这个时候就需要重写父类方法。
重写要去：

1.必须是继承关系
2.父类的方法必须是非私有化的
3.在子类中重写父类的方法，这个方法除了方法体不一样，其他的都一样
4.必须在子类中重写

入门案例：

package com.baidu.c_override;
class Father{
    public void eat() {
        System.out.println("吃粗粮");
    }
    
    public void driver() {
        System.out.println("开拖拉机");
    }
}
class Son extends Father{
    @Override//是重写的严格限定，只要有这个，就证明咱们下面的这个方法
    //是重写的方法，告知程序员这个eat方法是重写的，不是独有的
    //重写的时候在子类中只需要打上方法的名字敲回车即可
    //重写的方法和父类的返回值参数方法名一模一样
    //重写不影响父类的方法
    public void eat() {
        System.out.println("吃白面馒头");
    }
    @Override
    public void driver() {
        System.out.println("开汽车");
    }
    
}
public class Demo1 {
    public static void main(String[] args) {
        Son son = new Son();
        son.eat();
        son.driver();
        
        Father father = new Father();
        father.eat();
    }
}

案例：

父类：
  交通工具：
      方法 run();
两个子类:
  飞机：
      方法 run()
  高铁:
      方法 run()
  公交车:
      方法 run()

package com.baidu.c_override;
//交通工具类
class Vehicle{
    public void run() {
        System.out.println("可以跑");
    }
}
//飞机类
class Fly extends Vehicle{
    @Override//开启重写的严格限制，告知编译器，下面的方法一定是重写的
    public void run() {
        System.out.println("我飞着走");
    }
}
//高铁类
class Train extends Vehicle{
    @Override
    public void run() {
        System.out.println("我在铁轨上跑");
    }
}
//公交车
class Bus extends Vehicle{
    @Override
    public void run() {
        System.out.println("在公路上跑");
    }
}

public class Demo2 {
    public static void main(String[] args) {
        Fly fly =new Fly();
        fly.run();
        
        Train train =new Train();
        train.run();
        
        Bus bus = new Bus();
        bus.run();
    }
}