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.x5：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账号哦 ）】

---

—–乐于分享，共同进步！

—–更多文章请看：

---