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