Java小白StudyDay08--继承，super，重写与重载，static，Debug

一、继承

1.1基础理解

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

package cn.tedu.oopextends;
/*本类用于继承的入门案例*/
public class TestExtendsDemo {
    public static void main(String[] args) {
        //5.创建Animal类/Catlei/MiaoMiao类的对象
        Animal a = new Animal();
        Cat c = new Cat();
        MiaoMiao m = new MiaoMiao();
        //6.利用创建好的3个对象来调用Animal类中定义的eat()
        a.eat();
        c.eat();
        m.eat();
        /*3.继承具有传递性，爷爷的功能会传给爸爸，爸爸的功能会传给孙子*/
    }

}
//1.创建爷爷类Animal
class Animal{
    //4.定义爷爷类的普通方法
    public void eat(){
        System.out.println("小动物吃啥都行~");
    }
}
//2.创建爸爸类Cat，并与Aniaml类建立继承关系
/*1.我们通过extends关键字建立子类与父类的继承关系，子类 extends 父类*/
/*2.java只支持单继承：一个子类只能有一个父类，但一个父类可以有多个子类*/
/*7.继承是一种is a 的关系，比如小猫是小动物，DingDang是猫
 * 要求子类必须是父类的一种继承结构，依赖性非常强，强耦合*/
class Cat extends Animal{
    //7.定义属性--成员变量
    int a = 10;
    private int b = 100;
}
//3.1创建孙子类DingDang，并与Cat类建立继承关系
class DingDang extends Cat{
    /*4.子类可以拥有自己独有的方法，实现功能的拓展，青出于蓝而胜于蓝*/
    //8.定义孙子类自己特有的方法
    public void studyJava(){
        /*5.子类在继承父类以后，相当于把父类的功能进行了复制*/
        System.out.println(a);//子类可以使用父类的属性a
        /*6.父类的私有资源子类不可以使用，原因是私有资源不可见*/
        //System.out.println(b);//子类不可以使用父类的私有资源，这么写会报错
    }
}
//3.2创建孙子类MiaoMiao,并与Cat建立继承关系
class MiaoMiao extends Cat{

}

1.2成员变量的使用–super

super
1.super是一个关键字，而且位置必须是首行
2.super代表的是父类的一个引用，你可以把它看成是Father super = new Father();
3.如果子类与父类的成员变量同名时，可以使用”super.“进行指定

package cn.tedu.oopextends;
/*本类用于测试继承中成员变量的使用*/
public class TestExtends1 {
    //8.创建程序的入口函数main
    public static void main(String[] args) {
        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.进行指定
         * super也是一个关键字，super你可以理解成父类对象的引用
         *    比如：Father super = new Father();
         */
        System.out.println(super.sum);//指定的是父类的成员变量
        System.out.println(count);//没有重名，直接使用即可
    }
}

1.2继承中成员方法的使用–重写与重载

继承之方法
重写：继承后，子类对父类功能不满意，就可以重写
重写的规则：两同 两小 一大
方法名相同，参数列表相同
子类方法的返回值类型 <=父类方法的返回值类型
子类方法抛出的异常类型 <= 父类方法抛出的异常类型【还没学到，现在不用看】
子类方法的修饰符 >= 父类方法的修饰符
TIPS：子类无权修改父类的私有方法

package cn.tedu.oopextends;
/*本类用于测试继承中成员方法的使用*/
public class TestExtends2 {
    public static void main(String[] args) {
        //4.创建父类与子类对象进行测试
        Father2 f = new Father2();
        Son2 s = new Son2();
        f.eat();
        /**1.继承后，子类可以使用父类的所有非私有功能*/
        s.eat();
        s.study();
    }
}
//1.创建父类
class Father2{
    //3.创建父类中的方法
    public void eat() {
        System.out.println("粑粑爱吃肉~");
    }
    public void play() {
        System.out.println("喜欢做运动~");
    }
}
//2.创建子类,并与父类建立继承关系
class Son2 extends Father2{
    //5.创建子类特有的功能
    public void study() {
        System.out.println("快到端午了，想让你学包粽子~");
    }

    /**OCP原则：面向修改关闭，面向拓展开放
     *   只允许功能拓展，不允许修改原来的代码*/
    //6.修改父类原有的功能--不允许修改父类中的原代码
    //功能修改--方法的重写
    /**重写的规则：
     * 和父类的方法签名保持一致【方法名&参数列表】
     * 子类方法的修饰符 >= 父类方法的修饰符
     * 子类返回值类型 <= 父类的返回值类型
     * 然后去修改子类中本方法的实现，父类的功能并没有被改变
     * 重写时，子类必须拥有可以重写的权限，子类无权修改父类的私有方法*/
    @Override
    /**这是一个注解，可以理解成一个标签，用来标记此方法是不是一个重写的方法*/
    public void eat() {
        System.out.println("儿子爱吃炸鸡~");
    }
    public void play() {
        System.out.println("我爱打篮球~");
    }
}

1.3继承中构造方法的使用

继承之构造方法
1.子类创建对象时，默认会先调用父类的构造方法
2.在子类中第一行默认存在super()表示调用父类的无参构造
3.当父类中没有无参构造时，需要通过super(带参数);调用其他的构造方法
4.构造方法不可以被继承

package cn.tedu.oopextends;
/*本类用于测试继承中构造方法的使用*/
public class TestExtends3 {
    public static void main(String[] args) {
        //3.创建子类对象进行测试
        Son3 s = new Son3();
    }
}
//1.创建父类
class Father3{
    /*构造方法可以被继承吗？--不可以！！！！
     * 原因：由于构造方法的语法要求，构造方法必须与类同名
     * 不能在子类有一个父类名字的构造方法，天然不符合要求
     * */
    //5.提供父类的无参构造
//    public Father3(){
//        System.out.println("我是父类的无参构造~");
//    }
    public Father3(String s){
        System.out.println("父类的含参构造"+s);
    }
}

//2.创建子类,并建立子类与父类的继承关系
class Son3 extends Father3{
    /*在子类的构造方法中，默认存在super()；表示调用父类的无参构造
     * 也就是说，在创建子类对象时，会去调用子类的构造方法，继承后，
     * 会先去调用父类的构造方法，再去调用子类的构造方法
     * */
    //4.创建子类的无参构造
    public Son3(){
        //super();//表示调用父类的无参构造
        super("什马");//表示调用父类的含参构造
        /*当父类中没有无参构造时，调用的是父类的含参构造
         * 子类不关心具体调用的是父类的哪个构造函数
         * 只是必须调用一个父类的构造函数而已*/
        System.out.println("我是Son3的无参构造~");
    }
}

二、static

1.1 static入门案例

静态 static
1.static是一个关键字
2.static可以修饰成员变量和方法，被修饰的资源就是静态资源
3.静态资源优先于对象加载，随着类的加载而加载
4.被静态修饰的资源可以通过类名直接调用
5.静态资源全局共享(被所有对象共享)，值只有一份
静态的调用关系：
1.静态资源只能调用静态资源*****
2.非静态资源既可以调用静态资源，也调用非静态资源

package cn.tedu.oopstatic;
/*本类用于测试静态的入门案例*/
public class TestStatic1 {
    public static void main(String[] args) {
        /*3.静态资源可以通过类名直接调用，无需创建对象*/
        /*4.静态资源是优先于对象进行加载的，随着类的加载而加载
         * 比对象优先加载到内存，没对象时也可以通过类名直接调用
         * */
        //5.3我们可以通过类名调用资源
        System.out.println(Student.name);
        Student.speak();
        //4.创建本类对象进行测试
        Student s = new Student();
        Student s2 = new Student();
        System.out.println(s.name);
        s.study();
        //6.测试给静态属性name赋值
        s.name = "妖姬";
        System.out.println(s2.name);
        s2.name = "泰坦";
        /*5.静态资源被全局所有对象共享，值只有一份*/
        System.out.println(Student.name);
        System.out.println(s.name);
        System.out.println(s2.name);
    }
}
//1.通过抽象封装形成一个学生类
class Student{
    //2.创建属性--成员变量--无需手动初始化
    /*1.可以通过static将普通资源修饰成静态资源*/
    /*2.static可以用来修饰成员变量和方法，一般写在修饰符的后面*/
    //5.1 将name修饰成静态
    static String name;//姓名
    int sno;//学号
    //3.创建行为--方法
    public void study(){
        System.out.println("我想过端午，我很真实~");
    }
    //5.2将speak方法修饰成静态
    public static void speak(){
        System.out.println("我想大声告诉你~");
    }
}

1.2 静态的调用关系

package cn.tedu.oopstatic;
/*本类用于测试静态的调用关系*/
public class TestStatic2 {
}
//1.抽象封装形成老师类
class Teacher{
    //2.定义普通资源
    //2.1定义普通属性
    String name;
    //2.2定义普通方法
    public void teach(){
        /*1.普通资源能否调用静态资源？--可以！！！*/
        System.out.println(age);//普通资源可以调用静态属性
        eat();//普通资源可以调用静态方法
        System.out.println("正在发光ing...");
    }
    //3.定义静态资源
    //3.1定义静态属性
    static int age;
    //3.2定义静态方法
    public static void eat(){
        /*2.静态资源能否调用普通资源？--不可以！！！*/
        //System.out.println(name);//静态资源不可以调用非静态属性
        //teach();//静态资源不可以调用非静态方法
        System.out.println("扶我起来，还能再战~");
    }
    public static void sleep(){
        /*3.静态资源能否调用静态资源？--可以！！！*/
        System.out.println(age);//静态方法可以调用静态属性
        eat();//静态方法可以调用静态方法
        System.out.println("累了就睡吧~~");
    }
}

三、Debug

Debug可以帮我们解决很多的问题，程序按照顺序执行，我们可以通过Debug来清晰的看到程序运行到哪，是哪一部分有偏差，我在这里分享一下怎么使用，记得使用的软件是IDEA，方法仅供参考。

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