继承extends
关键字extends，语法：
public class 子类名 extends 父类{
}
子类继承了父类的成员（排除private修饰成员，以及父类的构造方法）
子类也叫派生类，父类也叫基类。java里面的继承属于单根继承，一个类只能继承一个类，所有的类都默认继承超级父类Object。子类可以有独有的成员变量和方法。
创建子类对象
1. 默认执行父类的无参构造
2. 执行子类的无参构造
创建子类对象的时候，先输出父类的无参构造，再输出子类的构造，如果在父类有static代码块时候，先走静态代码块，因为static是class加载的时候就被加载，所以在子类对象被创建的时候，先走父类的静态代码块，再走子类的静态代码块，再回到栈内存创建子类的对象，再走父类的无参构造，再走子类的无参构造
子类 对象名=new 子类();
//执行流程：父类class被加载-->父类静态代码块被加载-->子类class被加载-->子类static被加载-->父类构造-->子类构造
且子类需要通过set/get来访问父类继承到的私有属性。
demo1.setId(3);//给继承父类的id属性赋值
demo1.getId();//得到id
创建子类对象默认调用了父类的无参构造方法，但没有创建父类对象，因为没有new在堆内存开辟空间
public class Demo {
private int id;
public Demo() {
System.out.println("父类的无参构造this"+this);
}
static {
System.out.println("父类的staic代码块");
}
}
public class Demo1 extends Demo {
public Demo1() {
//默认调用了父类的无参构造，也就是默认存在super();
System.out.println("子类的无参构造this"+this);
}
static {
System.out.println("子类的staic代码块");
}
}
子类的所有构造方法里面默认调用了父类的无参构造，也就是默认存在super();，所以会先走super();执行父类的无参构造，再走子类构造的内容。
public static void main(String[] args) {
Demo1 demo1 = new Demo1();
demo1.setId(3);
System.out.println(demo1.getId());
System.out.println("创建的对象demo1"+demo1);
}
输出结果是
父类的staic代码块
子类的staic代码块
父类的无参构造thiscom.extendsdemo.Demo1@1540e19d
子类的无参构造thiscom.extendsdemo.Demo1@1540e19d
3
创建的对象demo1com.extendsdemo.Demo1@1540e19d
表示在继承关系下创建的子类对象，在父类中的this还是正在执行的对象，也就是子类对象。
子类代码：
public class Demo1 extends Demo {
private String name;
public Demo1() {
System.out.println("子类的无参构造this"+this);
}
public Demo1(String name,int id) {
//默认存在super();执行调用父类的无参构造
this.name=name;
this.setId(id);
}
}
父类代码：
public class Demo {
private int id;
public Demo(int id) {
this.id = id;
}
public Demo() {
System.out.println("父类的无参构造this"+this);
}
}
执行程序类：
public class test1 {
public static void main(String[] args) {
Demo1 demo1 = new Demo1("张三",36);
System.out.println(demo1.getId());
System.out.println(demo1.getName());
}
}
输出结果：
父类的无参构造thiscom.extendsdemo.Demo1@1540e19d
36
张三
这时候假如我把父类的无参构造删掉留下父类的有参构造，会出现什么现象？
Error:(16, 20) java: 无法将类 com.extendsdemo.Demo中的构造器 Demo应用到给定类型;
需要: int
找到: 没有参数
原因: 实际参数列表和形式参数列表长度不同
在子类的无参构造中调用父类的有参构造是没有意义的，所以正常开发中，几乎不存在子类的无参或少参数的构造调用父类的有参，子类的有参构造也不会调用父类的无参构造，因为子类的有参构造是用来赋值的，如果调用父类的无参，子类的有参构造的参数就没有赋到值，不会混合使用，也就是有参调有参，无参调无参。
当父类中没有无参构造方法时，子类需要加上super（参数）；
public class Demo1 extends Demo {
private String name;
public Demo1() {
super(28);//需要赋值，因为子类没有参数给传值
System.out.println("子类的无参构造this"+this);
}
public Demo1(String name){
super(36);;//需要赋值，因为子类没有参数给传值
}
public Demo1(String name,int id1) {
super(id1);//不需要赋值，这里有参数id1来传递参数给父类的有参构造
this.name=name;
// this.setId(id);父类无参构造删掉时候需要用super（id）代替这行操作
}
所以说，如果父类改变的时候子类也需要改变，是比较麻烦的，这时候可以利用工具来完成alt+ctrl，选中所有的构造方法，就可以完成子类的构造创建。
super
this和super的区别：
this是指当前执行的对象，可以调用属性和方法。
super只是一个父类引用的关键字，不是对象，假如把父类的无参构造删掉，需要加上super（子类继承的属性赋值）。
1. 在子类中，super可以访问父类成员变量和方法
子类属性跟父类属性相同时候，利用super来区分子类和父类的属性
父类代码：
public class Demo {
private int id=100;
public Demo() {
}
}
子类代码：
public class Demo1 extends Demo {
private int id=34;
public Demo1() {
super();//调用父类的无参构造，因为父类在这时没写有参，所以我这里子类也不写有参构造
}
public void fun(){
System.out.println("子类的id"+this.id);//34
System.out.println("父类的id"+super.getId());//100
}
/* public static void main(String[] args) {//执行程序
Demo1 demo1=new Demo1();
demo1.fun();
}*/
}
所以在子类和父类的属性定义名称时最好不要定义相同的，如果相同需要用super区分
2. 在子类构造中，利用super调用父类构造方法
方法重写
方法重载：方法名相同，形参不同，与修饰符和返回值无关。一般体现在工具类
方法重写：前提：有层级关系（继承，实现）
在子类中重写父类的方法
方法名和形参必须与父类的方法相同
父类代码：
@Setter
@Getter
public class Demo {
private int id=100;
public Demo() {
}
public void fun(){
System.out.println("父类的方法");
}
}
子类方法重写：alt+ctrl选择override
public class Demo1 extends Demo {
private int id=34;
public Demo1() {
super();
}
@Override//jdk提供的内置注解
public void fun(){//对父类的方法重写
super.fun();//加上这一行父类的方法也会执行，如果不加这一行父类的fun不会执行
System.out.println(getId()+"对父类的方法重写");
}
}
举例：重写超级父类object类的tostring方法
需要在父类代码中重写tostring方法：
public class Demo {
private int id=100;
public Demo() {
}
@Override
public String toString() {
return "Demo{" +
"id=" + id +
'}';
}
}
子类代码中的tostring会返回super.toString();因为他的父类是Demo，而Demo的父类才是object类，所以子类继承之前需要在父类中先重写超级父类中的方法：
public class Demo1 extends Demo {
private int id=34;
public Demo1() {
super();
}
@Override
public String toString() {
return super.toString();
}
}
在main中就可以直接将子类对象转换成字符串打印出来：
public static void main(String[] args) {
Demo1 demo1=new Demo1();
System.out.println(demo1.toString());
}
输出结果：
Demo{id=100}
子返回值类型要小于等于父类方法的返回值,访问权限修饰符要大于等于父类的访问权限修饰符
如果一个数据类型底层代码是final修饰，说明它是没有子类的。public>protected>默认>private 所以一般父类可以写成protected，可以只对子类友好。
父类方法用object类
private Object fun(){
return null;
}
那子类重写方法中返回值得小于父类方法的返回值
public String str(){
return null;
}
但是不推荐在子类中重写父类的方法：
在面向对象编程的设计中：
SOLID:
S:单一功能原则
O:开放闭合原则
L:里氏替换原则
I:接口隔离原则
D:依赖注入原则
里氏替换原则：
1. 父类出现的地方都可以使用子类替换
2. 不要随意更改父类结构，如果要重写方法可以用抽象方法/接口替换