Java基础 Day09(继承)

继承：类与类的关系，继承的设计原理是为了简化代码的书写，提高代码的复用性。

一、如何使用继承

　　在定义类时使用extends关键字 跟父类名。

public class Student extends Person{
}

二、继承的特点

　　1、没有父类的类称为根类，Java中根类是Object
       2、继承的上层：父类        继承的下层：子类
       3、继承的内容，所有的成员变量(私有的不能直接访问)和方法(除了构造方法)
       4、Java中的继承为单继承！！！ 你的亲生父亲只有一个！
    　　 一个类可以有多个子类，但是一个类有一个父类！
       5、继承是单向的，不能相互继承
       6、继承有传递性 Person Student CollegeStuden只能是
     　　大学生继承学生，学生继承人类，那么大学生就具有学生和人类的所有属性和方法
       7、子类如果不满意父类的方法实现，可以重写。

　　　　7.1>重写的关键字:@Override

　　　　7.2>重写的方法必须与父类的一致，参数数量、类型、顺序，方法名、返回值所有信息都一致!

　　　　7.3>只有父类的实现，在重写方法中只有super

　　　　7.4>既有子类实现又有父类实现,先写super再写子类内部实现.

　　　　7.5>子类构造方法执行时，优先调用父类的无参构造方法

　　　　7.6>父类中如果存在有参的构造方法,子类在定义有参构造方法时,优先执行父类中的有参构造方法，来初始化公共的属性
　　　　　　然后再初始化自身独有的属性，从而完成所有属性的初始化.

父类中 name age
子类继承 id 
public Student(String name, int age, int id) {
    super(name, age);
    this.setId(id);
}

　　　　7.7>构造方法的作用是创建对象
　　　　　　有参构造方法：创建对象的同时为对象属性进行赋值

父类内部
public void sayHi() {
    System.out.println("你好");
}
子类继承之后
@Override
public void sayHi() {
    System.out.println("Hello");
}

　　　　7.8>如果子类没有重写父类中的方法，那么子类调用继承方法时，走的是父类中的实现

　　8、只有子类的实现，在重写方法中没有super

//创建一个父类水果类
public class Fruit {
    private String color;
    private String variety;//种类
    private double weight;
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getVariety() {
        return variety;
    }
    public void setVariety(String variety) {
        this.variety = variety;
    }
    public double getWeight() {
        return weight;
    }
    public void setWeight(double weight) {
        this.weight = weight;
    }
    public Fruit() {
        System.out.println("Fruit类的构造方法执行了");
    }
    public Fruit(String color, String variety, double weight) {
        super();
        this.color = color;
        this.variety = variety;
        this.weight = weight;
    }

//创建一个子类Apple子类
public class Apple extends Fruit{

    private double price;
    private String smell;//味道
    /*
         无参构造方法一定要提供
         当子类执行无参构造方法时，首先会去调用父类中的
         无参构造方法，当父类中提供了有参构造时无参构造
         就不会默认提供，而如果没有手动的书写无参构造，
         子类一旦继承就会报错！！
     */    
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public String getSmell() {
        return smell;
    }
    public void setSmell(String smell) {
        this.smell = smell;
    }
    public Apple() {
        super();
        System.err.println("Apple的构造方法执行了！");
    }
    /*public Apple(String color, String variety, double weight) {
        super(color, variety, weight);
        // TODO Auto-generated constructor stub
    }*/
    public Apple(String color, String variety, double weight, double price, String smell) {
        super(color, variety, weight);
        this.price = price;
        this.smell = smell;
    }

//测试类
public class InitialApple {
    public static void main(String[] args) {
        Apple apple = new Apple();
        Apple apple1 = new Apple("红色", "苹果", 1.1, 9.0, "甜");
        System.out.println(apple1);
    }

三、final关键字

　　  1、final修饰类，则该类不允许被继承
         2、final修饰方法，则该方法不允许被覆盖(重写)
         3、final修饰属性(成员变量)则该属性不会隐式的初始化
         （类的初始化属性必须有值）
         或者在构造方法内部进行初始化(但是两者选择其中一种为其给初值)
         4、final如果用来修饰变量，则该变量只能赋值一次，即变为常量。