继承：
多个类中存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多个类就无需再定义这些属性和行为，只要继承那个累就可以。
继承的格式：
通过extends关键字可以实现类与 类之间的继承；
class 子类名 extends 父类名 {}
单独的这个类就是父类，基类或者超类；多个类就可以称为子类或者派生类；
继承的思想：
就是将所有子类中的共性功能，向上抽调到父类当中，实现代码的复用性和代码的维护性。
public class Student extends Person{
public void study(){
System.out.println("学习");
}
}
public class Teacher extends Person{
public void teache(){
System.out.println("教书");
}
}
public class Person {
String name;
int age;
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
}
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.name="张三";
student.age=19;
System.out.println(student.name+"==="+student.age);
student.sleep();
student.eat();
student.talkLove();
System.out.println("-----------------");
Teacher teacher = new Teacher();
teacher.name="老师";
teacher.age=10;
System.out.println(teacher.name+"==="+teacher.age);
teacher.sleep();
teacher.eat();
teacher.teache();
}
}
结果：
张三===19
睡觉
吃饭
学习
-----------------
老师===10
睡觉
吃饭
教书继承的好处：
a.提高了代码的复用性；
b.提高了代码的维护性；
c.让类与类产生了关系，是多态的前提；
继承的缺点：
增加了类的耦合性；
开发的原则是：高内聚，低耦合；
耦合：类与类的关系；
内聚：就是自己完成某件事情的能力；
继承的特点：
java中类的继承只支持单继承，也可以多层继承；
继承的注意事项：
a.子类不能继承父类中的私有成员（成员变量、成员方法）；
b.子类不能继承父类中的构造方法，但可以使用super关键字去访问父类中的构造方法；
c.没有必要为了部分功能而去继承；
继承中成员变量的关系：
- 1.子类中的成员变量和父类中的成员变量名称不相同；
- 2.子类中的成员变量和父类中的成员变量名称一样的时候，子类中访问一个变量的顺序（采用的是就近原则）。
- a.在子类的方法的局部范围内找，有就使用。
- b.在子类的成员范围内找，悠久使用；
- c.在父类的成员范围内找，有就使用；
- d.如果在子类和父类中都找不到就报错。
继承中成员方法的关系：
- 1.当子类的方法名和父类的方法名不一样时候；
- 2.当子类的方法名与父类的方法名一样的时候。通过子类的调用方法为：
- a.先查找子类中有没有该方法，如果有就使用；
- b.在父类中查找该方法，如果有就使用；
- c.如果在父类和子类中都找不到就报错；
继承中构造方法的关系：
- 构造方法不参与继承；
- 子类中所有的构造方法默认都会访问父类中的无参构造方法；
a.当有了继承关系之后，要初始化子类时，因为子类要使用父类中的数据，所以必须先要父类的初始化；
b.在完成父类的初始化时，每个类的构造方法的第一行都会默认的使用super（）语句来调用父类中的无参构造；
继承中构造方法的注意事项：
- 父类中没有明确构造方法的参数一般默认为无参构造；
- 如果父类中没有无参构造方法，子类会执行：
- 1.在父类中添加一个无参构造方法；
- 2.子类使用super（）语句去显示调用父类中的其他的带参构造方法
public class MyTest {
public static void main(String[] args) {
//Zi zi = new Zi();
//Zi zi = new Zi(1009);
//假如在父类里面没有提供无参构造
//1.那子类可以去调父类有参构造
//2.先用this(参数)本类的有参构造，然后调用的那个构造又去调用父类的有参构造
//System.out.println(zi.num);
Zi zi = new Zi();
}
}
class Fu{
int num=10;
public Fu() {
super();
System.out.println("父类的空参构造执行了");
}
public Fu(int num) {
super();
this.num = num;
System.out.println("父类的有参构造执行了");
}
}
class Zi extends Fu{
int num=100;
public Zi() {
super(10);
// this(10000);
System.out.println("子类的空参构造执行了");
}
public Zi(int num) {
super(num);
System.out.println("子类的有参构造执行了");
}
}
结果：
父类的有参构造执行了
子类的空参构造执行了
