继承
继承的本质是对某一批类的抽象。
关键字extends：扩展。子类继承父类，即子类是父类的扩展。Java只有单继承，没有多继承。
（1）继承是类与类之间的一种关系。除此之外，类与类之间还有依赖、组合、聚合等。
（2）继承关系的两个类：一个为子类（派生类），一个为父类（基类）。子类继承父类通常使用extends。
（3）子类与父类之间从意义上讲应该是“is a”的关系。
修饰符：public公共的，protected保护的，default默认的，private私有的。
例：父类：Person，子类：Student、Teacher
快捷键ctrl+H， 可以得到该类的继承关系，例如：Object->Person->Student
//Person 父类
public class Person {
//修饰符
private int money = 10_0000_0000;
public void say(){
System.out.println("说！");
}
//封装 get, set
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
//Student is Person : 子类，派生类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
//ctrl+H 得到该类的继承关系Object->Person->Student
}
//Teacher is Person : 子类，派生类
public class Teacher extends Person{
}
子类继承了父类，就会拥有父类的全部方法。所以Student类实例化的对象，可以拥有属性money，方法say：
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.getMoney());
}
运行结果：
说！
1000000000
Object类
在Java中所有的类都默认直接或间接继承object类。
//JAVA中，所有的类，都默认直接或间接地继承Object类
public class Person extends Object{
}
super
super的作用是调用父类。
注意点：
（1）super调用父类的构造方法的语句：super();，必须放在构造方法的第一行；
（2）super必须只能出现在子类的方法或者构造方法中；
（3）super和this不能同时调用构造方法。
与this相比较：this的作用是调用自身。
（1）代表的对象不同：
- super：代表父类对象的引用；
- this：本身调用者的对象；
（2）前提：
- super：只能在继承条件下才可以使用；
- this：没有继承关系也可以用；
（3）构造方法：
- super(); //调用父类的构造方法
- this(); //调用自身的构造方法
父类：Person
public class Person /*extends Object*/{
public Person() {
System.out.println("Person无参构造器");
}
protected String name = "大乔";
public void print(){
System.out.println("Person");
}
}
子类：Student
//Student is Person : 子类，派生类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {
//ctrl+H 得到该类的继承关系Object->Person->Student
//构造器
public Student() {
//隐藏代码：调用了父类的无参构造器
super();//必须放在子类构造器的第一行
//this();//调用自己的构造器，也必须放在自己的构造器的第一行
System.out.println("Student无参构造器");
}
//有参构造器
public Student(String name) {
this.name = name;
}
public String name = "小乔";
public void print(){
System.out.println("Student");
}
public void test(String name){
System.out.println(name);//传递的形参name
System.out.println(this.name);//Student的实例化对象的属性name
System.out.println(super.name);//继承的Person父类的属性name
}
public void test1(){
print();//当前类的print方法
this.print();//当前类的print方法
super.print();//继承的父类的print方法
}
}
main方法
public static void main(String[] args) {
Student student = new Student();
student.test("孙权");
student.test1();
}
运行结果：
Person无参构造器
Student无参构造器
孙权
小乔
大乔
Student
Student
Person
方法重写Override
重写都是方法的重写，与属性无关！
重写：需要有继承关系，然后子类重写父类的方法，必须是非静态方法。其中，子类的方法必须与父类一致，方法体不同。
注意点：
（1）方法名必须相同；
（2）参数列表（参数类型，参数名）必须相同；
（3）修饰符：范围可以扩大，public<protected<default<public；
（4）抛出异常：范围可以缩小，但不能扩大。
为什么需要重写？
因为父类的功能，子类不一定需要或者不一定满足。
快捷键：Alt+Insert-->Overried
重要例子！！！
父类：B
public class B {
//方法
public void test(){
System.out.println("B/test");
}
}
子类：A
public class A extends B{
//Override 重写只能是非静态方法，修饰符为public
//子类重写了父类的（非静态）方法
@Override//注解：有功能的注释
public void test() {
//默认调用父类的test()
//super.test();
System.out.println("A/test");
}
}
main方法
//A,B中test()方法是静态方法或非静态方法的结果不同
//1. A,B中test()方法是静态方法
//方法的调用只与左边定义的数据类型有关
//c.test();//B
//2.A,B中test()方法是非静态方法
A a = new A();
a.test();//静态A，非静态A
B b = new B();
b.test();//静态B，非静态B
//父类的引用指向子类
//B类的引用c指向了A类
B c = new A();
c.test();//静态B，非静态A