黑马程序员java学习—继承

时间:2021-07-17 00:43:25

       在java中,通过继承可以简化类的定义,扩展类的功能。在java中支持类的单继承和多层继承,但是不支持多继承,即一个类只能继承一个类而不能继承多个类

1:继承的基本概念

继承格式:class 子类名 extends 父类名

继承好处:提高了代码的复用性,让类与类之间产生了关系。 

                 将对象中的共性内容不断地向上抽取,就形成了关系,就有了继承,有了子父类。

                 提高了代码的复用。

继承特点:java中只能单继承,多继承的机制被java语言改良了。

                 java不直接支持多继承:原因:会产生调用的不确定性。 当多个父类中定义了相同功能。当功能内容不同时,不确定要运行哪一个。但是java保留这种机制,并用另一种体现形式来完成表示:多实现。

                 java支持多层继承。这样就出现了继承体系。

示例:class Person

               {

                                      String name;

                         int aga

                  }//声明一个名为Person的类,里面有name和age两个属性。

                 class Student extends Person

                  {

                        String school;

                  }//声明了一个名为Student的类,并继承自Person类。

                 public class TestPersonStudentDemo

                 {

                        public static void main(String[] args)

                       {

                              Student s= new Student( );

                              s.name="张三";

                              s.age=25;

                              s.schoole="北京";

                              System.out.println("姓名:"+s.name+“,年龄:”+s.age+“,学校:”+s.school);

                       }//声明并实例化了一个Student类的对象s

                   }

                   运行结果:姓名:张三,年龄:25,学校:北京

2:super关键字的使用:

     功能:完成子类调用父类中的内容,也就是调用父类中的属性和方法。

     super:代表的是父类。用法和this相似。

              this代表本类对象的引用。

              super代表父类所属的空间。 

示例:
              class Person
              {
                         String name;
                         int age;
                         public Person(String name,int age)
                         {                        
                                    this.name = name;
                                    this.age = age;
                          }
             } //父类的构造方法


              class Student extends Person
              {

                      String school;//子类构造方法
                      public Student()
                       {
                       super("张三",25);//调用父类中的构造方法
                       }
               }

               public  class TestStudentDemo
              {
                   public static void main(String[] args)

                   {

                          Student s = new Student( );

                          s.school="北京";

                          System.out.println("姓名:"+s.name+",年龄:"+s.age+",学校:"+s.school);

                   }
              }


 

     继承中成员函数的特点:

       当子父类中出现一模一样的方法时,会发生一个函数的特性:覆盖(复写,重写) override。当子类继承父类,沿袭了父类的功能到子类中。但是子类虽具备该功能,但是功能的内容和父类不一致,这时没有必要定义新功能,而是使用覆盖特性。保留父类的功能定义,并重写功能内容。

     覆盖注意事项:

          1:子类覆盖父类时,必须要保证覆盖方法的权限大于等于被覆盖的方法的权限.

          2:覆盖方法有静态修饰时,静态只能覆盖静态,或者被静态覆盖。在写法注意这个事项。

    

3:子父类中的构造函数。

       在对子类对象进行初始化时,父类的构造函数也会运行。那是因为在子类的所有构造函数中的第一行,默认多有一条隐式的语句。就是 super( );也就说子类的构造函数默认都会访问父类中空参数的构造函数

       为什么子类的构造函数都要去默认访问父类的构造函数呢?

       因为子类继承了父类,可以访问父类中的已有的一些属性。 在子类进行实例化的时候必须要为父类中的属性分配空间。 并要进行初始化,所以必须要访问一次父类的构造函数,看看父类是如何对其属性进行初始化的。所以子类要实例化对象时,必须要先看父类的初始化过程。

       结论:父类的构造函数,既可以给本类对象初始化,也可以给子类对象初始化。

       注意:如果父类中没有空参数的构造函数,子类的构造函数中必须手动用super来指定

 要访问的父类中的构造函数。 或者用this来指定访问本类中的构造函数。this和super调用构造函数只能定义构造函数的第一行。不能同时出现。为什么都定义在第一行啊?因为初始化的动作要先执行。 

 

4:继承弊端:打破了封装性。

         解决方式:一个关键字final 最终的。

         final关键字的特点:

         1:final是一个修饰符,既可以修饰类,又可以修饰方法,还可以修饰变量。

         2:final修饰的类不可以被继承。

         3:final修饰的方法不可以被覆盖。

         4:final修饰的变量是一个常量,只能赋值一次。

           为了将固定的一些数据方便使用,会给这些起一个容易阅读的名称,

           为了防止名称存储的数据改变。用final修饰。