继承 继承中各种情况

继承

1.是面向对象一个特点

2.从已有的类中派生出新的类，子类能够继承父类的属性和行为（除了私有的）

3.子类可以增加新的数据和功能，也可以用父类的功能，但是不能选择性地继承父类/超类/基类

4.使得复用以前的代码非常容易，能够缩短开发周期，减低费用

 

 public class C6 {

    public static void main(String[] args) {
        Dog g = new Dog();
        g.eat();
        System.out.println(g.money);
        //System.out.println(g.a);不能继承私有
        LitteDog lg = new LitteDog();
        lg.eat();//子类LitteDog能够调用Animal类的方法，子类继承爷爷类 ---继承具有传递性
    }
}
//1.父类 提取共性
class Animal{
    public void eat(){//提高代码复用性
        System.out.println("吃啥都行");
    }
    double money = 100;
    private int a =10;
}
//4只支持单继承
class Dog extends Animal{//子类 继承（extends） 父类

}

class LitteDog extends Dog{//小狗类继承狗类，也继承动物类

}


注意：子类不能继承父类的私有资源  +  构造方法

成员变量的使用
public class C2     public static void main(String[] args) {        Son1 s1 = new Son1();        s1.test();    }

}
class Father1{
    int money = 100;
    String name ="mike";
}

class Son1 extends Father1{
    String name ="jack";

    public void test(){
        //Father1 f = new Father1();
        System.out.println(money);//子类使用父类的变量(不同名，直接使用)
        System.out.println(name);//jack，使用子类的成员变量

       //1, 当子类的成员变量名  和父类的成员变量名相同时时,  通过super关键字来调用父类的成员变量
　　　　//相当于super在底层帮你创建了父类对象 , 如: Fu2 super = new Fu2();
　　　　//2, super表示父类对象的引用, ,,,用来 在子类中 调用 父类的的成员

        //super表示父类对象的引用，让子类中 调用父类的成员变量
        System.out.println(super.name);//mike，使用父类的mike
        

        int age  = 10;
        System.out.println(age);//10
        System.out.println(super.money);
        //使用父类的成员变量
        String name = "rose";
        System.out.println(name);//就近 原则，局部变量rose
        System.out.println(this.name);//使用this关键字 子类的成员变量jack

    }
}

---成员变量
总结
1子类 可以用父类的所有功能（除了私有的）.
2.子类 还可以用自己扩展的方法
3.子类 可以改写 继承来的方法  --方法重写@overrride
4.什么时候重写    子类继承父类，想修改时
5.重写的要求      子类和父类的声明一样  + 子类有足够的权限 >=父类
6.开发过程中，避免改源码     不然一堆Bug。。。

super关键字
--1,特点
--super表示父类对象的一个引用
--super在子类里调用 父类的功能
--super关键字如果出现在  构造方法里  必须是第一条语句(类似this)

方法的重写Override
--1,特点
--是指发生了 继承关系后 的现象
--在子类中,想要修改 继承来的方法 --就是 方法重写
--语法要求: 子类的方法声明和 父类的一样 .只是改方法体.
--语法要求: 子类重写时要有足够的权限

public class C5 {
    public static void main(String[] args) {
        Zi3 z3 = new Zi3();
        z3.eat(); //重写前, 用父类的方法体... 重写后,用子类的方法体...
        z3.sleep();
        //使用了 自己特有的扩展方法
        z3.coding();
    }
}


class F3{
    public void eat(){
        System.out.println("eat");
    }
    public void sleep(){
        System.out.println("sleep");
    }
}

// 父类的方法可以被子类继承
//子类还可以扩展自己的方法
class Zi3 extends F3{
    //当继承了所有父类的方法后 , 发现想改 -- 方法重写的现象 : 子类的方法声明和父类一样  + 有权限
    @Override//标志着这个方法是重写方法
    public void eat() {
        super.eat();//对于父类原有的功能 没有一点影响的 !!!
        System.out.println("don't eat");
    }

    public void coding(){
        System.out.println("conding");
    }
}

--构造方法的使用
总结:
1, 创建子类对象时,父类对象有没有? -- 有,先有的父类对象,再有子类对象
2, 触发构造方法时, 什么顺序? -- 先执行父类的  再执行 子类的
3, 为什么先执行父类的 构造方法? -- 因为子类的构造方法里  默认第一行就隐藏着super()

public class C6 {
    public static void main(String[] args) {
        new Zi4();
    }
}

class F4{
    public F4(){}
    public F4(int a){
        System.out.println("父类构造");
    }
}

class Zi4 extends F4{
    public Zi4(){
        //1, 在子类的构造方法里, 隐藏着super() ,调用父类 的构造方法
        //3, super关键字如果出现在 构造方法里  必须是第一条语句 !!!
        //super(); //4, 当父类只提供了含参构造时,无参构造就没了....super()就找不到无参构造了报错.
        super(10); //5, 当父类没有无参 构造时,,,,只能调用 含参构造....
        System.out.println("子类的  构造方法");
    }
}