继承（java基础）

继承

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

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

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

• 继承是类和类之间的关系。初次之哇哦，类和类之间的关系还有以来、组合、聚合等

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

• 子类和父类之间，从意义上讲应该具有“is a”的关系

• 实例

//人 父类
package oop.dome4;
public class Person {
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("说话！！！");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

//学生  is 人 子类（派生类）
package oop.dome4;
//子类继承了父类，就会拥有父类的全部方法
//在JAVA中，所有的类，都直接或间接继承object public class Student extends Object{}
public class Student extends Person{

}

//老师  is 人  子类（派生类)
package oop.dome4;
public class Teacher extends Person{
}

//应用类
package oop;
import oop.dome4.Student;
public class Application {
    public static void main(String[] args) {
        //调用学生类，学生类继承了父类的方法，所以也可以调用到父类的方法
        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());
    }
}

• 总结

  • public 公共的
    private 私有的 (私有的方法和类可以被继承，但无法访问)
    default 默认的（可不写）
    protected 受保护的

  • 子类继承了父类，就会拥有父类的全部方法
    在JAVA中，所有的类，都直接或间接继承object (***public class Student extends Object{}***)

Super

• 注意点：
  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中
  3. super和this不能通知调用构造方法
  4. 代表的对象不同：
     • this：本身调用这个对象
     • super：代表父类对象的应用
  5. 前提：
     • this：没有继承也可以使用
     • super：只能在继承条件才可以使用
  6. 构造方法：
     • this() ；本类的构造
     • super()；父类的构造
• 实例

//父类
package oop.dome4;
public class Person {
    protected String name = "姚小锅";		//父类中受保护的类

    public void print(){				 //父类中的方法
        System.out.println("Person");
    }
}

//子类
package oop.dome4;
public class Student extends Person{
    private String name = "小锅";			//子类中私有的类
    public void test(String name){		  //子类的方法
        System.out.println(name);	      //打印形参name----姚明
        System.out.println(this.name);	  //打印当前类（子类的name）----小锅
        System.out.println(super.name);   //打印父类的name----姚小锅
    }
    public  void print(){
        System.out.println("Student");
    }

    public void test1(){
        print();		//调用当前类的print()方法
        this.print();	//调用当前类的print()方法
        super.print();	//调用父类的print()方法
    }

}

//应用类
package oop;
import oop.dome4.Student;
public class Application {
    public static void main(String[] args) {
        Student student = new Student();	 //通过new关键字创建对象
        student.test("姚明");				  //调用子类中的test（）并传参
        student.test1();				   //调用子类中的test1（）
    }
}

方法重写

• 重写都是方法的重写，与属性无关

• 重写只与非静态方法有关

• 静态方法和非静态方法的区别巨大

• 重写的关键词只能是public

• 静态方法实例

package oop.dome4;
//父类
public class  B{
    public static void test(){
        System.out.println("B=>test()");
    }
}

package oop.dome4;
//子类
public class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
}

//应用类
package oop;

import oop.dome4.A;
import oop.dome4.B;

public class Application {
    public static void main(String[] args) {
        //方法的调用只和左边的定义的数据类型有关
        A a = new A();
        a.test();   //结果   A=>test()

        //父类的引用指向了子类
        B b = new A();
        b.test();   //结果   B=>test()
    }
}

• 非静态方法实例

  package oop.dome4;
  //父类
  public class  B{
      public  void test(){
          System.out.println("B=>test()");
      }
  }
  
  package oop.dome4;
  //子类
  public class A extends B{
      public  void test(){
          System.out.println("A=>test()");
      }
  }
  
  //应用类
  package oop;
  
  import oop.dome4.A;
  import oop.dome4.B;
  
  public class Application {
      public static void main(String[] args) {
          //方法的调用只和左边的定义的数据类型有关
          A a = new A();
          a.test();   //结果   A=>test()
  
          //父类的引用指向了子类
          B b = new A();	/*子类重写了父类的方法，相当于
          					    @Override  //注解：有功能的注释！
                             		 public void test() {
                                     System.out.println("A=>test()");
                                    }*/
          b.test();   //结果   A=>test()
      }
  }
  
  

• 总结

  • 重写需要有继承关系
  • 方法名必须相同
  • 参数列表必须相同
  • 修饰符：范围可以扩大但不能缩小 public>protected>default>private
  • 抛出异常：范围可以被缩小，但不能扩大 ClassNotFoundException （小） >Exception(大)
  • 重写，子类的方法必须与父类的方法一致，方法体不同
  • 为什么需要重写？
    • 父类的功能，子类不一定需要，或者不一定满足
    • 快捷键 Alt + insert + override