关于java继承的学习

继承的格式

在继承的关系中，“子类就是一个父类”也就是说，子类可以被当作父类看待。
例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系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{}//正确