继承的格式
在继承的关系中，“子类就是一个父类”也就是说，子类可以被当作父类看待。
例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系is-a
定义父类的格式：（一个普通的类定义）
public class 父类名称{
//。。。。。
}
子类的格式：
public class 子类名称 Extends 父类名称{
//…
}
public class demo01Extends {
public static void main(String[] args) {
//创建了一个子类对象
teacher th=new teacher();
//teacher类当中虽然什么都没有写，但是会继承来自父类的method方法。
th.method();
//创建另一个子类
Assistant assistant=new Assistant();
assistant.method();
}
}定义一个子类Assistant来继承Employee，内容当中为空
public class Assistant extends Employee{
}在定义一个子类teacher来继承Employee，内容同样为空
package demo01;
//定义一个讲师子类
public class teacher extends Employee{定义一个父类为Employee
package demo01;
//定义一个父类
public class Employee {
public void method(){
System.out.println("员工类方法执行！");
}运行结果创建的三个对象都能执行，说明三个子类都继承了来至父类的方法
继承中成员变量以及成员方法访问的特点
在父子类的继承关系当中，如果成员变量重名，则创建子类对象是，访问有两种方式；
直接通过子类对象访问成员变量：
等号左边是谁就优先使用谁，没有则往上找。
间接访问通过成员方法访问成员变量：
方法属于谁就优先使用谁，没有则往上找。
public class demo01ExtendsField {
public static void main(String[] args) {
Fu fu=new Fu();
System.out.println(fu.numFu);//父类只能使用父类中的对象，不能使用子类之中的对象。
Zi zi=new Zi();
System.out.println(zi.numFu);//子类继承了父类，所以可以为使用父类，也可以使用子类的对象。
System.out.println(zi.numZi);
//等号左边是谁，就优先用谁
System.out.println(zi.num);//优先子类。100
//System.out.println(fu.bas);如果父类也没有就报错
zi.MethodZi();//这个方法是子类的，优先使用子类的，没有往上找
zi.MethodFu();//这个方法是在父类中定义的，所以在父类中找
}
}定义一个父类名为Fu
public class Fu {
int numFu=10;
int num=200;
public void MethodFu(){
System.out.println(num);//会使用本类中的，不会向下找子类的num
}
}定义一个子类，名为Zi继承Fu
public class Zi extends Fu {
int numZi=20;
int num=100;
public void MethodZi(){
System.out.println(num);//因为本类中有num，所以不会找父类的。优先用自己的
}
}在父子类的继承关系当中创建子类对象访问成员的规则：
创建的对象是谁就优先用谁，如果没有就往上找
注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类。
方法重写概念：在继承关系中，方法的名称一样，参数列表也一样。
继承中三种重名的区别方法
局部变量：直接写
本类的成员变量：this.成员变量名
父类的成员变量：super。成员变量名
public class demo01ExtendsField {
public static void main(String[] args) {
Zi zi=new Zi();
zi.method();
}
}定义一个父类名为Fu
public class Fu {
int num=10;
}定义一个子类名为Zi继承父类
public class Zi extends Fu{
int num=20;
public void method(){
int num=30;
System.out.println(num);//30局部变量
System.out.println(this.num);//20,本类成员变量
System.out.println(super.num);//10,父类成员变量
}
}关于重写学习
方法重写设计原则：对于已经投入使用的类，尽量不要进行修改。推荐定义一个新的类来重复利用其中共性内容，并且添加改动新的内容
方法重写概念：在继承关系中，方法的名称一样，参数列表也一样。
重载overload：方法的名称一样，参数列表【不一样】。覆盖或者覆写
重写override：方法的名称一样，参数列表【也一样】
覆盖重写的注意事项：
1.必须保证父子类之间的方法的名称相同，参数列表也相同。
@override：写在方法前面用来检测是不是覆盖重写
这个注解就算不写，只要满足要求也是正确的方法覆盖重写。
2.子类方法返回值必须【小于等于】父类方法返回值范围。
前提：java.lang.Object类是所有类的公共最高父类，java.lang.String就是Object的子类。
3.子类方法的权限必须大于等于父类方法的权限修饰符。
小扩展提示public>protected>(default)>private[(default)不是关键字default，而是什么都不写，留空
public class demo01phone {
public static void main(String[] args) {
phone phone=new Newphone();
phone.call();
phone.send();
phone.show();//只有一项显示号码
System.out.println("===========");
Newphone newphone=new Newphone();
newphone.show();//新的show中有三项显示姓名，显示号码，显示头像
newphone.call();
newphone.send();
}
}定义一个phone父类
父类中包含手机的三项基本功能，然而手机的发展保留了三项基本功能，并且添加了一些新的功能，以show方法为例。添加显示名称，显示头像，两项，显示号码保留。因此我们可以用方法重写来添加新的内容
public class phone {
public void call(){
System.out.println("打电话");
}
public void send(){
System.out.println("发短信");
}
public void show(){
System.out.println("显示号码");
}
}定义一个子类为newphone继承phoen，通过方法重写来扩张show的类容
public class Newphone extends phone {
@Override
public void show() {
//System.out.println("显示号码");在父类中已经有显示号码了，所以我们可以不用写显示号码，可以直接用super.show表示
super.show();
System.out.println("显示姓名");
System.out.println("显示头像");
}
}继承中构造方法的访问特点
继承关系中，父子构造方法的访问特点
子类构造方法当中有一个默认隐含的super（）调用，这个隐含的super（）构造是无参构造，所以一定是先调用父类，后执行的子类构造。
2.子类构造可以通过super关键字来调用父类重载构造。
3.super的父类构造调用必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：子类必须调用父类构造方法，不写则赠送super（），写了则用写的指定的super调用，super只能有一个，而且必须是第一个
public class demo01Constructor {
public static void main(String[] args) {
Zi zi=new Zi();
}
}定义一个父类Fu
public class Fu {
public Fu(int num){
System.out.println("有参构造使用");
}
public Fu(){
System.out.println("父类无参构造方法调用");
}
}定义一个子类Zi继承Fu
public class Zi extends Fu{
public Zi(){
//super():被隐藏，这是无参构造，如果父类中为有参构造，那么就必须在super（参数）才能使用
super(10);//有参super和无参super只能有一个被使用，不能同时使用
System.out.println("子类构造方法调用");
}
/* public void method(){错误写法！只有子类构造方法才能调用父类构造方法。
super():
}*/
}super关键字的用法
super关键字的用法有三种：
1.在子类的成员方法中，访问父类的成员变量。
2.在子类的成员方法中，访问父类的成员方法。
3.在子类的构造方法中，访问父类的构造方法。
public class demo01Super {
public static void main(String[] args) {
Zi zi=new Zi();
}
}定义父类Fu
public class Fu {
int num=10;
public void method(){
System.out.println("父类方法调用");
}
}定义一个子类方法Zi
public class Zi extends Fu{
int num=20;
public Zi(){
super();//不写也会存在，这是子类构造体访问父类构造体
//super.method();
}
public void methodZi(){
System.out.println(super.num);//10,如果输入的是num那么输出的就是本类中的20
}
public void method(){
super.method();
System.out.println("子类方法");
}
}this关键字的三种用法
super关键字用来访问父类内容，儿this关键字用来访问本类内容。用法也有三种
1.在本类的成员方法中，访问本类的成员变量。
2.在本类的成员方法中，访问本类的另一个成员方法。
3.在本类的构造方法中，访问本类中另一个构造方法。
A。在第三种用法中要注意：this（。。。）调用也必须是构造方法的第一个语句，也是唯一一个，不能再调用其他的构造方法
B。super和this两种构造调用，不能同时进行使用。
定义一个父类Fu
public class Fu {
int unm=30;
}定义一个子类Zi继承父类
public class Zi extends Fu{
int num=20;
public Zi(){//这是无参构造方法
//this();这是自己调用自己
this(123);//这是无参构造调用本类中的有参构造
//this(123,234);错误的，只能调用一个，不能再调用
}
public Zi(int n){
}
public Zi(int n,int m){
}
public void showNum(){
int num=10;
System.out.println(num);//局部变量
System.out.println(this.num);//本类当中的成员变量
System.out.println(super.unm);//父类中成员变量
}
public void methodA(){
System.out.println("AAA");
}
public void methodB(){
this.methodA();//调用本类中的成员方法methodA，this起强调的作用
System.out.println("BBB");
}
}java继承的三个特点:java语言是单继承的，意思是说一个类的父类只能有唯一一个，例如：
class A{}
class B extends A{}//正确
class C{}
class D extends A，C{}//错误
但是Java语言可以多级继承。比如我有父亲，我的父亲还有他的父亲，也就是爷爷。例如：
class A{}
class B extends A {}//正确
class C extends B {}//正确
java.lang.Object是所有父类的起始。
一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类。例如：
class A{}
class B extends A{}//正确
class C extendsA{}//正确
