从零开始学Java-Day08

继承

1. 继承的关键字extends 格式：子类 extends 父类
2. 子类继承父类，相当于子类复制了父类的功能
3. 父类的私有资源，子类无法使用，因为private修饰不可见
4. Java制作支持单继承，一个子类只能由一个父类，一个父类可以有多个子类
5. 继承具有遗传性
6. 继承是一种 is a 的管辖，比如小猫是小动物，ricwshower是赛马娘，要求子类必须是父类的一种继承结构，依赖性非常强，强耦合
7. 在java中，子类是更强大的，子类不仅继承了父类的功能，自己还可以定义自己的功能
8. 子类不能继承父类的构造器：子类有自己的构造器(没有争议)
9. 子类对象优先使用子类已有的方法

继承的特点：

1. 单继承： 一个类只能继承一个直接父类
2. 多层继承：一个类可以间接继承多个父类(C继承B,B继承A)
3. 一个类可以有多个子类（C继承B，D也继承B，B就有了C,D两个子类）
4. 一个类要么默认继承了Object类，要么间接继承了Object类，Object类是Java中的祖宗类

package cn.tedu.oppextends;
//本类用于测试继承中成员变量的使用
public class TestExtends1 {
    public static void main(String[] args) {
        hotFood h1 = new hotFood();
        h1.eat();
    }
}

/**
 * 在子类中想要使用父类的sum资源，需要使用super，进行指定
 * super也是一个关键字，super可以理解成 Food super = new Food();
 */
class Food{
    String name = "food";
    double kg = 10.5;
    int sum = 1;
}
class hotFood extends Food{
    int sum = 1000;

    public void eat(){
        int sum = 10;
        System.out.println("局部内sum：" + sum);
        System.out.println("成员sum：" + this.sum);
        System.out.println("父类的sum：" + super.sum);
    }
}

构造方法在继承中的用法、super

package cn.tedu.oppextends;
//本类用于测试继承中构造方法的使用
public class TestExtends3 {
    public static void main(String[] args) {
        //School school = new School("教高中生的");
        HighSchool highSchool1 = new HighSchool();
        System.out.println("===============================");
        HighSchool highSchool = new HighSchool("圣雷森");
        System.out.println("===============================");
        SOSSchool sosSchool = new SOSSchool();
        sosSchool.eat();
    }
}

class School{
    int teacherNums;
    int StudentNums;
    String type;
    public School(){
        System.out.println("暗杀教室");
    }
    public School(String type){
        System.out.println("这是" + type + "学校");
    }
    public void eat(){
        System.out.println("rice");
    }
}
//在子类的构造方法中，默认存在super();表示父类的无参构造
//在创建子类对象是，会取调用子类的构造方法，继承父类后，会优先i奥永父类的无参构造方法
//再去调用子类的构造方法
//构造方法无法被继承，构造方法必须与类同名
/**
 * 当父类中没有无参构造时，调用的是父类的含参构造
 * 当父类中有无参构造时，创建子类时会优先调用父类的无参构造
 * 子类第一行默认有super(),表示调用父类的无参构造
 * 当父类中没有无参构造时们需要通过super(参数);调用其他构造方法
 * 构造方法无法被继承
 */
class HighSchool extends School{
    String name;
    double price;

    public HighSchool(){
        System.out.println("杀老师不是怪物是好老师");
    }
    public HighSchool(String name){
        super("教3年E班的");
        System.out.println("这是" + name + "高中");
    }
    public void eat(){
        super.eat();
        System.out.println("humbger");
    }
}

class SOSSchool extends HighSchool{
    public SOSSchool(){
        System.out.println("yearh~!");
    }
    public void eat(){
        super.eat();
        System.out.println("kicten");
    }

}

重写

方法重写的规范：

子类重写方法的名称和形参列表必须与父类被重写方法一样
子类重写方法的返回值类型声明要么与父亲一样，要么比父类方法返回值类型范围更小
子类重写方法的修饰符权限应该与父类被重写方法的修饰符权限相同或者范围更大
子类重写方法申明抛出的异常应该与父类被重写方法申明抛出的异常一样或者范围更小

package cn.tedu.oppextends;
//本类用于测试继承中成员方法的使用
public class TestExtends2 {
    public static void main(String[] args) {
        WhiteHair girl1 = new WhiteHair();
        WhiteSnow whiteSnow = new WhiteSnow();
        girl1.hairColor();
        whiteSnow.hairColor();
        WhiteHair girl2 = new WhiteSnow();
        girl2.hairColor();
        WhiteSnow.lover();
    }
}

class WhiteHair{
    String name;
    String bornPlace;
    public void hairColor(){
        System.out.println("她们的头发是白色的");
    }
}

class WhiteSnow extends WhiteHair{
    int age;
    /*
     * OCP原则：面向修改关闭，面向拓展开放
     * 只允许功能拓展，不允许修改原来的代码
     */
    /**
     * 重写的规则：
     * 和父类的方法签名保持一致【方法名&参数列表】
     * 然后取修改子类中本方法的实现，父类的功能并没有被改变
     * 方法的修饰符 >= 父类方法的修饰符
     * 返回值类型 <= 父类的方法修饰符
     * 子类抛出异常的类型 <= 父类抛出异常的类型e
     * 重写是，子类必须拥有可以重写的权限，子类无权修改父类的私有方法
     *
     */
    @Override   // 一个注解，理解成标签，标记是否是重写的方法
    public void hairColor(){
        System.out.println("她的头发是苹果的颜色");
    }
    public static void lover(){
        System.out.println("千");
    }

}

小结：

1. 方法重写是子类重写一个与父类申明一样的方法覆盖父类的方法
2. 方法重写要加@override 注解
3. 方法重写的核心要求：方法名称，参数列表必须与被重写方法一致！

扩展：

• 静态方法和私有方法是否可以被重写？

答：都不可以，加上@override会报错

静态修饰符的用法

有static修饰的成员变量称为静态成员变量，也叫类变量，属于类本身，直接用类名访问即可

有static修饰的成员方法称为静态方法，也叫类方法，属于类本身的，直接用类名访问即可

无static修饰的成员变量称为实例成员变量，属于类的每个对象的，必须用类的对象来访问

无static修饰的成员方法称为实例方法，属于类的每个对象的，必须用类的对象来访问

package cn.tedu.oppstatic;
//静态的入门案例
public class TestStatic1 {
    public static void main(String[] args) {
        Student student = new Student();
        Student student1 = new Student();
        student.study();
        System.out.println(student.sno);
        System.out.println(Student.name);
        Student.speak();
        Student.name = "superClick";
        student.name = "goldTheShip";
        student1.name = "grassWonder";
        System.out.println(Student.name);
        System.out.println(student.name);
        System.out.println(student1.name);
    }

}
class Student{
    /*可以通过static将普通资源修饰成静态资源/可以直接通过 类.xxx 调用
    * 一般写在修饰符的后面
    * 优先于对象加载
    * 比对象优先加载到内存*/
    static String name;
    int sno;

    public void study(){
        System.out.println("我在暗杀教室当学生");
    }
    public static void speak(){
        System.out.println("杀老师是世界上最好的老师");
    }
}

package cn.tedu.oppstatic;
//本类用于测试静态的调用关系
public class TestStatic2 {
    public static void main(String[] args) {

    }
}

class Fruit{
    String name;
    /*
    普通资源可以调用静态资源
     */
    public void tasty(){
        System.out.println(nums);
        bornPlace();
        System.out.println("It's tasty well");
    }
    static int nums;;
    /*
    静态资源不能调用普通资源
    静态资源可以调用静态资源
     */
    public static void bornPlace(){
        buy();
        System.out.println("生长在异世界");
    }
    public static void buy(){
        System.out.println(nums);
        System.out.println("10万元1个");
    }
}