JAVA面向对象-----super关键字

JAVA面向对象—–super关键字

1:定义Father(父类)类

1:成员变量int x=1;
2:构造方法无参的和有参的,有输出语句

2:定义Son类extends Father类

1:成员变量int y=1;
2:构造方法无参和有参的。有输出语句this.y=y+x;

3:创建Son类对象

Son son=new Son(3);
        System.out.println(son.y); //4

class Father {
    int x = 1;
    Father() {
        System.out.println("这是父类无参构造");
    }
    Father(int x) {
        this.x = x;
        System.out.println("这是父类有参构造");
    }
    void speak() {
        System.out.println("我是父亲");
    }                  
}

class Son extends Father {
    int y = 1;
    Son() {
        System.out.println("这是子类的无参构造");
    }
    Son(int y) {
        this.y = y + x;
        System.out.println("这是子类的有参构造");
    }
    void run() {
        super.speak(); // 访问父类的函数
        System.out.println("我是儿子");
    }
}

class Demo6 {
    public static void main(String[] args) {
        Son s = new Son(3);
        System.out.println(s.y);// 4
    }
}
4:子类对象为什么可以访问父类的成员。
    1:this.y=y+x;有一个隐式的super super.x

5:super关键字作用
    1:主要存在于子类方法中,用于指向子类对象中父类对象。
    2:访问父类的属性
    3:访问父类的函数
    4:访问父类的构造函数
6:super注意

this和super很像,this指向的是当前对象的调用,super指向的是当前调用对象的父类。Demo类被加载,执行main方法,Son.class加载,发现有父类Father类,于是Father类也加载进内存。类加载完毕,创建对象,父类的构造方法会被调用(默认自动无参),然后执行子类相应构造创建了一个子类对象,该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用,不能在静态上下文使用。

2:子类的构造函数默认第一行会默认调用父类无参的构造函数,隐式语句super();
1:父类无参构造函数不存在,编译报错。

Son(int y) {
        //super();隐式语句
        this.y = y + x;
        System.out.println("这是子类的有参构造");
    }
3:子类显式调用父类构造函数

在子类构造函数第一行通过super关键字调用父类任何构造函数。如果显式调用父类构造函数,编译器自动添加的调用父类无参数的构造就消失。构造函数间的调用只能放在第一行,只能调用一次。super()
和this()不能同时存在构造函数第一行。

Son(int y) {
        super(y);// 子类显式调用父类构造函数
        this.y = y + x;
        System.out.println("这是子类的有参构造");
    }

Son(int y) {
        this();  //不能同时存在构造函数第一行 
        super(y);
        this.y = y + x;
        System.out.println("这是子类的有参构造");
    }
4:super思考

如果开发者自定义了一个类,没有显示的进行类的继承,那么该类中成员函数是否可以使用super关健健字?可以使用,继承了Object类,Object类是所有类的父类。

class Demo7 {
    public  void print(){
        System.out.println(super.toString());
    }
    public static void main(String[] args){
        new Demo7().print();
        System.out.println();
        }
}
5:继承练习

7:重写(Override)

1:定义Father类

1:姓名,吃饭方法,吃窝窝头。
2:定义Son类,继承Father

1:Son类中不定义任何成员,子类创建对象,仍然可以调用吃饭的方法。
2:父类的吃饭的方法,Son不愿吃。Son自己定义了吃饭的方法。

1:此时父类中有一个吃饭的方法,子类中有2个吃饭的方法,一模一样,只是方法体不一样。
2:一个类中两个函数一模一样,是不允许的。

1:编译运行,执行了子类的方法。
2:使用父类的方法,在子类方法中,使用super.父类方法名。

class Father {
    String name;

    void eat() {
        System.out.println("吃窝窝");
    }
}

class Son extends Father {

    public void eat() { // 继承可以使得子类增强父类的方法
        System.out.println("来俩小菜");
        System.out.println("来两杯");
        System.out.println("吃香喝辣");
            System.out.println("来一根");
    }
}

class Demo8 {

    public static void main(String[] args) {
        Son s = new Son();
        //执行子类的方法
        s.eat();

    }
}

3:该现象就叫做重写(覆盖 override)

1: 在继承中,子类可以定义和父类相同的名称且参数列表一致的函数,将这种函数
称之为函数的重写.

4:前提

1:必须要有继承关系

5:特点

1:当子类重写了父类的函数,那么子类的对象如果调用该函数,一定调用的是重写过后的函数。
可以通过super关键字进行父类的重写函数的调用。
2: 继承可以使得子类增强父类的方法

6:细节

1: 函数名必须相同
2:参数列表必须相同
3: 子类重写父类的函数的时候,函数的访问权限必须大于等于父类的函数的访问权限否则编译报错
4:子类重写父类的函数的时候,返回值类型必须是父类函数的返回值类型或该返回值类型的子类。不能返回比父类更大的数据类型: 如子类函数返回值类型是Object

1:定义 A B  C 类 B extends A  
    2:Father类中定义A getA();
    3:Son 类中重写getA(); 方法,尝试将返回值修改为B,C ,Object
        1:B编译通过
        2:C 编译失败 ,没有继承关系
        3:Object编译失败,比父类的返回值类型更大
class A {

}

class B extends A {

}

class C {

}
class Father {
    String name;

    void eat() {
        System.out.println("吃窝窝");
    }

    // 定义一个函数,获取A类的对象,
    A getA() {
        return new A();
    }

}

class Son extends Father {

    public void eat() { // 继承可以使得子类增强父类的方法
        System.out.println("来两杯");
        System.out.println("来俩小菜");
        super.eat();
        System.out.println("来一根");
    }

    // B类是A类的子类
    B getA() {
        return new B();
    }
}

class Demo8 {

    public static void main(String[] args) {
        Son s = new Son();
        s.eat();

    }
}

7:子类对象查找属性或方法时的顺序:

原则:就近原则。
如果子类的对象调用方法,默认先使用this进行查找,如果当前对象没有找到属性或方法,找当前对象中维护的super关键字指向的对象,如果还没有找到编译报错,找到直接调用。

8:重载和重写的不同

1:重载(overload):

1:前提: 所有的重载函数必须在同一个类中
2:特点:函数名相同,参数列表不同,与其他的无关(访问控制符、返回值类型)
3:不同:个数不同 、 顺序不同、 类型不同

2:重写(override):

1:前提: 继承
2:特点:
函数名必须相同、参数列表必须相同。
子类的返回值类型要等于或者小于父类的返回值

9:重写练习

描述不同的动物不同的叫法
1:定义动物类
有名字,有吃和叫的方法
2:定义狗继承动物重写父类吃和叫的方法
3:定义猫继承动物重写父类吃和叫的方法

class Animal{
    int x=1;
    String name;
    void eat(){
        System.out.println("吃东西");
    }
    void shout(){
        System.out.println("我是动物");
    }
}

class Dog extends Animal{


    void eat(){
        System.out.println("啃骨头");
    }
    void shout(){
        System.out.println("旺旺");
    }
    void eat(String food){
        System.out.println("吃:"+food);
    }
}
class Cat extends Animal{

    void eat(){
        System.out.println("吃老鼠");
    }
    void shout(){
        System.out.println("喵喵");
    }
}

class Demo9{

    public static void main(String[] args){
        Dog d=new Dog();
        d.shout();
        d.eat();

        Cat c=new Cat();
        c.shout();
        c.eat();
        System.out.println();
        }
}

【正在看本人博客的这位童鞋,我看你气度不凡,谈吐间隐隐有王者之气,日后必有一番作为!下面有个“顶”字,你就顺手把它点了吧(要先登录CSDN账号哦 )】


—–乐于分享,共同进步!
—–更多文章请看:http://blog.csdn.net/duruiqi_fx

相关文章
相关标签/搜索