类之间继承

继承

继承的一些性质

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

• extends的意思是"扩展"。子类是父类的扩展。

• JAVA中类只有单继承，没有多继承。

• 继承是类和类之间的一种关系.除此之外，类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extend来表示。

• 子类和父类之间，意义上来讲有"子类 is 父类"的关系。

• 子类可以继承父类的所有方法(但是父类私有的变量和方法无法被继承)

语法

子类 extends 父类

SUPER

• super可以和this一起进行学习，this表示调用当前的类的属性，super表示调用父类的属性

//例子---------------------------------------------------------------------------------------------------------------------------


package Demo01;
//父类
public class School {
    protected String name="xiaoming";   //对School里面的name常量赋值
}


package Demo01;
//子类
public class Student extends School{
    private String name="xiaojing";    //对Student类里面的name常量赋值
    public  void behaviour(String name){
        System.out.println(name);     //此处调用形参里面的name
        System.out.println(this.name);    //此处调用Student类里面的name
        System.out.println(super.name);    //此处调用父类School里面的name
    }
}


package Demo01;
import java.util.Scanner;
//测试类
public class Application {
    public static void main(String[] args) {
        Student p=new Student();     //创建对象Person(),p作为引用变量
        p.behaviour("lihua");     //引用Student类里面的方法behaviour,并给予实参“lihua”
    }
}



/*输出结果为:
  lihua
  xiaojing
  xiaoming
  */

• 同样的,super还可以调用父类的一些方法

//----------------------------例子---------------------------------------------------------------------------------------------


package Demo01;
//父类
public class School {
    protected String name="lin";
    public void behaviour2(String name){
        System.out.println(name);
    }
}




package Demo01;
//子类
public class Student extends School{
    private String name="wei";
    public  void behaviour(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
        super.behaviour2("Optimus");      //此处调用父类的behaviour2方法
    }
}




package Demo01;
import java.util.Scanner;
//测试类
public class Application {
    public static void main(String[] args) {
        Student p=new Student();
        p.behaviour("nan");
    }
}




/*输出结果为:
  lihua
  xiaojing
  xiaoming
  Optimus
  */

• 如果单单只执行Student的构造器，且Student作为School的子类的时候，程序会先执行的不会是Student的构造器，而是父类School的构造器

​ 原因如下:

package Demo01;
//父类
public class School {
    public School(){             //创建School构造器
        System.out.println("我是第一个输出的");
    }
}




package Demo01;
//子类
public class Student extends School{
    public Student(){           //创建Student无参构造器
        /*super();        ←这个super引用是程序隐藏的，我们看到的可能是只执行Student的构造器,
        实际上是先执行父类School，且这个super()必须在Student构造器第一句执行语句之前，
        否则会报错，其次使用this()调用其他该类的构造器时，也必须在第一句，所以只能super和this之间二选一*/
        System.out.println("我是第二个输出的");
    }
}



package Demo01;
import java.util.Scanner;
//测试类
public class Application {
    public static void main(String[] args) {
        Student p=new Student();
    }
}

/*
输出结果:
我是第一个输出的
我是第二个输出的
*/

Super的注意点&This区别总结

super的注意点:

• super调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或者构造方法中
• super和this不能同时调用构造方法

与this的区别:

• 两者代表的对象不同:

  • this:调用的是当前类
  • super:代表父类对象的应用

• 前提:

  • this:没有继承也能够使用
  • super:只能在继承条件才可以使用

• 构造方法

  • this();表示本类的构造
  • super();表示父类的构造

方法的重写

• 重写必须需要有继承关系，

• 方法调用的代码例子

package Demo01;
//父类
public class School {
    public static void  test(){
        System.out.println("Optimus");
    }
}


package Demo01;
//子类
public class Student extends School{
    public static void test(){
        System.out.println("Megatron");
    }
}


package Demo01;
import java.util.Scanner;
//测试类
public class Application {
    public static void main(String[] args) {
        //方法的调用只和定义的数据类型有关
        Student a=new Student();
        a.test();
        School b=new Stundet();    //父类的引用指向了子类
        b.test();
    }
}

• 方法的重写(Override):

  • 其二者的方法名相同，和重载类似

  • 参数列表必须相同

  • 重写的方法修饰符的范围只能从小到大而不能从大到小;public>protected>default>private

  • 与重载不同，重载是在一个类里面实现的，而重写是在父子类之间实现的

  • 关系是:子类重写父类的方法

  • 注解@Override是一个有功能的注释

  • 方法重写抛出的异常:可以从大到小而不能从小到大

  • IDEA中的方法重写快捷键:Alt+Insert

• 代码例子:

package Demo01;
//父类
public class School {
    public  void  test(){            
        System.out.println("Optimus");
    }
}



package Demo01;
//子类
public class Student extends School{
    @Override            //注解:相当于有功能的注释
    public void test() {
        System.out.println("Megatron");        //将父类方法test()重写为"Megatron"
    }
}



package Demo01;
import java.util.Scanner;
//测试类
public class Application {
    public static void main(String[] args) {
        Student a=new Student();
        a.test();              //a引用Student类的方法
        School b=new Student();         
        b.test();                //父类的引用b引用了父类的方法，但是父类的方法在子类中被重写，因此输出的是子类中重写的方法内容
    }
}
//目前个人理解:父类方法在被使用的时候是需要Student的方法先进行调用的，因此父类的方法先在Student类里面被继承，进行重写后只会输出重写后的内容

• 重写的意义:
  • 如果父类的方法功能过多或者过少，子类在调用的时候可以进行重写，重写后可以挑取或者增添自己所需要的功能

结束