黑马程序员java学习—继承

       在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修饰。