Java第九课_继承

3.面向对象的编程_继承

• 继承

  public class Practice {
  
      public static void main(String[] args) {
          /*
              继承/extends : 子类继承父类后,子类可以获取父类中所有的非私有的成员;
              子类 : 被抽取共同成员的类,通常是多个类 , Student  Worker
              父类 : 共同成员所在的类,通常是少的一方 , Person
  
              Java中的类与类之间的继承是 : 单继承--只能有一个父类, 支持多层继承--父类也可以有父类, 其成员也会被最终的子类继承.
  
              Object类 : 上帝类 , 是所有类的父类.
              Java中如果一个类没有声明自己的父类,那么这个类默认继承 Object 类
  
              体系学习 :先学习父类，再学习子类，只需要关注子类特有功能即可．
           */
          Student s1 = new Student("lisi", 20);
  
          s1.sleep();
          s1.study();
  
          Worker w1 = new Worker("zs", 20);
          w1.sleep();
          w1.work();
      }
  }
  
  public class Person {
      String name;
      int age;
  
      public void sleep(){
          System.out.println(name + "躺着睡....");
      }
  }
  
  public class Worker extends Person{
  
      public Worker(String name, int age) {
          this.name = name;
          this.age = age;
      }
  
      public void work(){
          System.out.println("工人工作....");
      }
  }
  
  public class Student extends Person {
  
      public Student(String name, int age) {
          this.name = name;
          this.age = age;
      }
  
      public void study(){
          System.out.println(name + "学生学习....");
      }
  }
  

• 继承时的重写

  public class Practice {
      public static void main(String[] args) {
          Zi zi = new Zi();
  
          zi.m1();
          zi.show();
      }
  }
  
  public class Fu {
  
      int num = 110;
  
      public void m1(){
          System.out.println("Fu m1");
      }
  
      void m2(){
  
      }
  
      public Number m3(){
          return 9527;
      }
  
      public void m4() throws Exception {
          System.out.println("Fu m4");
      }
  }
  
  public class Zi extends Fu{
      /*
          重载/overload : 同一类中,允许存在同名函数,但是参数列表必须不同.
          重写/override : 当子类与父类中存在一模一样的函数时,子类函数会覆盖父类函数的功能.
  
          @OverRide : 重写的声明
          快捷键: Ctrl + O
          重写时注意点 :
              1.子类函数的权限必须大于等于父类函数的权限(m2)
                  private < default(默认) < protected < public
              2.子类函数的返回值可以是父类函数返回值类型的子类类型(m3)
                  Number
                      Integer
              3.子类声明的异常必须和父类相同,或者是父类声明异常的子类(m4)
                  Throwable : 所有异常或错误的父类
                      Exception : 异常
                          RuntimeException : 运行时异常
       */
      int num = 120;
  
      @Override
      public void m1(){
          System.out.println("Zi m1");
      }
  
      @Override
      public void m2(){
  
      }
  
      @Override
      public Integer m3(){
          return 9527;
      }
  
      @Override
      public void m4()throws RuntimeException{
  
      }
  
      public void show(){
          int num = 130;
          System.out.println("局部变量num = " + num); //同名变量,就近原则
          System.out.println("Zi成员变量num = " + this.num); //this.成员名, 调用类成员
          System.out.println("Fu的成员变量num = " + super.num); // super.成员名, 调用父类成员, 用法同 this
      }
  }
  

• 继承时的构造

  public class Practice {
  
      public static void main(String[] args) {
          
          Zi zi = new Zi(110);
      }
  }
  
  public class Fu {
  
      public Fu(String s) {
  
      }
  }
  
  public class Zi extends Fu{
  
      /*
          1.每个子类构造器的第一条语句默认为 super()
              类构造器互相调用时需要this()语句,this()语句也必须放在第一条.
                  因此子类构造器只能是super()或this(). 但因为需求父类才创建的子类, 因此子类构造器不存在调用this()的情况, 只能选择对应的super()语句.
          2.如果父类没有空参构造器(默认有),那么子类必须通过具体的super() 来指明要访问父类中的哪个构造器
  
      */
  
      public Zi() {
          super("lisi");
          System.out.println("Zi 空参构造器");
      }
  
      public Zi(int num){
          super("3306");
  
      }
  
      // 类间成员的访问等级. 不同包需要先导入包
      /*
                      同一个类        同一个包下两个类之间      不同包下有继承关系的两个类   不同包下没有继承关系的两个类
              private     ok          no                      no                      no
  
              default     ok          ok                      no                      no
  
              protected   ok          ok                      ok                      no
  
              public      ok          ok                      ok                      ok
  
      */
  }
  

• final修饰符

  public class Practice {
  
      public static void main(String[] args) {
          /*
              final : 是一个修饰符, 表示最终的,不可变的.
                  1.可以用来修饰类 函数 变量(C.PAI)
                  2.修饰的类是最终的类,不能再被继承(B)
                  3.修饰的函数是最终的函数,不能被重写,但可以被调用(A.m1)
                  4.修饰的变量是常量,只能赋值一次(num)
                  5.在局部内部类中,只能访问由final修饰的局部变量
           */
          // 局部变量
          final int num = 321; // 声明时必须初始化, 初始化后就不能再被改变.
  
          C c1 = new C();
          System.out.println(c1.NUM2);
  
          C c2 = new C(555);
          System.out.println(c2.NUM2);
          System.out.println(c1.NUM2);
      }
  }
  
  public class A {
      public final void m1(){
          System.out.println("A.m1");
      }
  
      public void m2(){
          System.out.println("A.m2");
      }
  }
  
  public final class B extends A{
  
      public void m2(){
          super.m1();// 调用父类函数时加上 super.函数名, 方便理解
          m1();
      }
  }
  
  public class C {
  
      public static final double PAI = 3.1415926;// 修饰属性时, 因为不可更改, 毫无疑问应该和static组合使用.
      public static final double PI;// 修饰变量时, 理应一起初始化, 但如果在构造代码块和构造器中有赋值操作, 则不会报错
      static {
          PI = 3.14;
      }
  
      final double NUM;
      {
          NUM = 9527;
      }
  
      final double NUM2;
      public C() {
          NUM2 = 3306;
      }
  
      public C(double NUM2) {
          this.NUM2 = NUM2;
      }
  }