Day6.9继承 重写 super 静态static

继承
1.我们通过关键字extends 建立子类与父类的继承关系，格式：子类extends父类
2.子类继承父类，相当于子类把父类的功能复制了一份
3.父类的私有资源不可用，因为被private修饰不可见
4.java只支持单继承，一个子类只能有一个父类，但一个父类可能有多个子类
5.继承具有传递性，爷爷的功能给爸爸，爸爸的功能给孙子
6.子类可以拥有自己特有的功能，实现功能的拓展
7.继承是 is a的关系，依赖性非常强，强耦合

8.所有的类默认继承Object
===================================================
1.super 是一个关键字
2.super代表的是一个父类的引用，可以看做是 Father super=new Father（）；
=====================================================
重写：继承后，子类对父类功能不满意，就可以重写
       重写的规则：两同两小
    方法名相同，形参列表相同
    子类方法抛出的异常<=父类方法抛出的异常
    子类方法的返回值类型<=父类的返回值类型
    权限修饰符>=父类的权限修饰符
TIPS 子类无权修饰父类的私有方法
======================================================
继承之变量
继承之构造方法
1.子类创建对象时，会优先调用父类的构造方法
2.在子类构造器中，第一行默认存在super空，表示调用父类的空参构造
3.当父类中没有无参构造时，需要通过super（带参数）；调用其他构造方法
4.构造方法不可以被继承
======================================================
静态 static
      static是一个关键字，
      可以用来修饰变量和方法，被修饰的资源就是静态资源
      静态资源的加载优先于对象，可以直接通过类名调用
      被静态修饰的资源可以直接通过类名调用
      静态的值只有一份
静态资源调用关系
 1.静态资源只能调用静态资源
 2.非静态资源可以调用静态资源与非静态资源

示例代码

继承

package cn.tedu.ectends;

import org.junit.jupiter.api.Test;

public class TestExtendsDemo {
    @Test
    public void test1() {
        Animal animal = new Animal();
        Cat cat = new Cat();
        MiaoMiao miaoMiao = new MiaoMiao();
        animal.eat();
        cat.eat();
        miaoMiao.eat();
        /*3继承具有传递性，爷爷的功能会传给爸爸，爸爸的功能会传给孙子*/
    }

}

//创建爷爷类
class Animal {

    int a = 10;
    private int b = 100;

    public void eat() {
        System.out.println("小动物是什么东西吃什么都行");
    }
}

//2.创建爸爸类 建立继承关系
/*1.我们通过extends关键字建立子类与父类的关系   子类extends父类
 * 2.java只支持单继承，一个子类只能有一个父类，但一个子类只能有多个父类*/
class Cat extends Animal {
    public Cat() {

    }

    /*3子类可以拥有自己的独有的方法，实现功能的拓展，青出于蓝而胜于蓝
     * 4子类继承了父类之后相当于把父类的功能进行了复制*/
    public void studyjava() {
        System.out.println(a);
        /*5父类的私有资源子类不可用，原因是私有不可见*/
        /*6继承是一种is a的关系，比如小猫是小动物 叮当是猫
        * 7要求子类必须是父类的一种继承结构，依赖性非常强，强耦合*/
        // System.out.println(b);//子类不可以使用父类的私有资源
    }

}

//3.创建孙子类
class DingDang extends Cat {

}

class MiaoMiao extends Cat {
}

package cn.tedu.ectends;

import org.junit.jupiter.api.Test;

/*本类用于测试继承中成员方法的使用*/
public class TestExtends2 {
    @Test
    public void test() {
        Father2 f = new Father2();

        Son2 s = new Son2();
        f.eat();
        s.eat();
        s.study();

    }
}

class Father2 {

    public void eat() {
        System.out.println("爸爸爱吃肉");
    }

}

class Son2 extends Father2 {


    /*OCP原则，面向修改关闭 面向扩展开放======只允许功能拓展，不允许修改源代码*/
    //修改父类原有的功能----不允许修改父类的源代码
    /*重写的规则
    * 和父类的方法签名保持一致【方法名&参数列表】
    * 然后去修改子类中的本方法实现，父类的功能并没有被改变
    * 方法修饰符>=父类的修饰符
    返回值类型<=父类的返回值类型
    * 重写时，子类必须拥有可以重写的权限，子类无权修饰父类的私有方法
     */


    @Override/*这是一个注解，可以理解为一个标签。用来标记此方法是不是一个重写的方法*/
    public void eat() {

        System.out.println("老虎不在家，猴子称霸王");
    }

    public void study() {
        System.out.println("包粽子");
    }
}

示例三

package cn.tedu.ectends;

import org.junit.jupiter.api.Test;

/*本类用于测试继承中成员变量的使用*/
public class TestExtends1 {
@Test
    public void test(){
    Son s = new Son();

    s.eat();
}
}

//1.先创建父类
class Father {
    //3.定义父类的属性 -------成员变量
    int sum=1000;
    int count =100;

}
//2.先创建子类
class Son extends Father {




    //4.定义子类中的属性
    int sum=100;
    //5.定义子类中的普通方法
    public void eat(){
        //6.定义子类中的局部变量
        int sum=10;
        //7.测试变量的打印结果
        System.out.println(sum);//10  就近原则
        System.out.println(this.sum);//100 使用this关键字打印本类的成员变量
        /*
        在子类中使用父类的sum资源，需要使用super.进行指定，相当于父类的对象的引用，比如：Father super=new Father

        * */
        System.out.println(super.sum);//有重名的时候通过super.来调用
        System.out.println(count);//没有重名的时候直接进行调用
    }

}

示例四

package cn.tedu.ectends;

import org.junit.jupiter.api.Test;

/*
 * 本类用来测试继承中构造方法的使用*/
public class TestExtends {
    @Test
    public void test(){
        Son1 son = new Son1();

    }

}
//1创建父类
class Father1 {
   /* public Father1() {
        System.out.println("我是父类的无参构造");
    }*/
    public Father1(String a) {
        System.out.println("我是父类的有参构造");
    }

}
//2创建子类
class Son1 extends  Father1{
    //创建子类无参构造
    /*在子类的方法中默认存在super();表示调用父类的无参构造
    * 也就是说，在创建子类对象时，会调用子类的构造方法，继承后，先去调用父类的构造方法，再去调用子类的构造方法
    * 当父类中没有无参构造时，调用的是父类的含参构造
    * 子类不关心具体调用得是父类的那个构造器
    * 只是必须强调父类的的一个构造器而已
    * 父类构造器不允许被继承  原因：因为构造方法的语法要求，构造方法必须与类同名，天然不符合构造要求♩♩
    * */
    public Son1() {
        super("我是你爸爸");
        System.out.println("我是Son1的无参构造");
    }
}

示例五Debug

package cn.tedu.ectends;

import org.junit.jupiter.api.Test;

/*本类用于debug练习*/
/*我们可以在目标代码前面，行号后面添加断点，在按一次取消断点
* 2.Debug断点调试的时候，需要以DeBug."TestDebug.main()"的方式启动*/
/*
3.弹出来有两个窗口
Debugger ：这个是Debug模式用于查看执行情况，比如变量当前值得窗口
Console---这个是我们之前常用的控制台，会显示程序执行的效果
 */
/*
4.按f8进行下一步，想结束Debug就按红色方块按钮结束程序
Debug只会在断点处停下来，不断点的位置不会停，要学会合理设置断点位置
 */
public class TestDebug {
    @Test
    public void test(){
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
}

示例六静态static

package cn.tedu.oopstatic;

import org.junit.jupiter.api.Test;

/*
本类用来测试静态的调用关系
alt +7查看结构
 */
public class TestStatic2 {
@Test
    public void t(){
    Teacher.sleep();
}

}

class Teacher {
    String name;
    static int age;

    public void test() {
        /*普通资源可以调用静态资源*/
        System.out.println(age);
        eat();

        System.out.println("正在授课");
    }

    public void teach() {
        System.out.println("老师机");
    }

    public static void eat() {
        /*2.静态资源不可以调用非静态资源
         * 静态资源可以调用静态资源*/
        //System.out.println(name);//编译时异常：Non-static field 'name' cannot be referenced from a static context
        System.out.println("你真能吃");
    }

    public static void sleep() {
        System.out.println("累了困了喝乐虎");
        System.out.println(age);
        eat();

    }
}

示例七

package cn.tedu.oopstatic;

import org.junit.jupiter.api.Test;

/*本类用于测试静态的入门案例*/
public class TestStatic1 {
@Test
    public void test(){
    System.out.println(Student.name);
    Student.speak();
    Student student = new Student();
    System.out.println(student.name);
    student.study();
    student.name="小乔";
    Student student1 = new Student();
    System.out.println(student1.name);
    System.out.println(student.name);

}

}

class Student {
    /*可以通过static将普通方法资源修饰成静态资源
    * 2.static可以用来修饰成员变量和方法  一般写在修饰符的后面
    * 3.静态资源可以通过类名直接调用，无需创建对象
    * 4.静态资源优先于对象进行加载的，随着类的加载而加载
    *     比对象优先加载到内存，没对象时也可以通过类名直接调用
    * 5.静态资源被全局所有对象共享，值只有一份*/

  static   String name;
    int son;

    public  void study() {
        System.out.println("我不想学java,满脑子都是端午");
    }

    public static void speak() {
        System.out.println("我不想说话");
    }

}