（java总结）继承 extends

package Demo6;
//定义一个父类 员工
public class Employee {
    public void method(){
        System.out.println("方法执行");
    }
}

package Demo6;
//定义一个员工的子类 讲师
public class Teacher extends Employee {
}

package Demo6;
//定义员工的另一个子类 助教
public class Assistant extends Employee {
}

package Demo6;
/*
在继承的关系中，子类也可以被看作子类
定义父类的格式：（一个普通的类）
public class 父类名称{
       ...
 }
定义子类的格式：
public class 子类名称 extends 父类名称{
        ...
  }
 */
public class DemoExtends {
    public static void main(String[] args) {

        //创建一个主类对象
        Teacher teacher = new Teacher();

        //Teacher类中什么也没写，但是继承来自父类的method方法
        teacher.method();

        //创建另一个子类助教的对象
        Assistant assistant = new Assistant();
        assistant.method();
    }
}

package Demo6;

public class Fu {
     int numFu = 10;
     int num = 100;

     public void methodFu(){
         //使用的是本类当中的，不会向下找子类
         System.out.println(num);
     }
}

package Demo6;

public class Zi extends Fu {

    int numZi = 20;
    int num = 200;
    public void methodZi(){
        //本类有，用的是本类的
        System.out.println(num);
    }
}

package Demo6;
/*
在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式
直接通过子类对象访问成员变量
        等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量
        方法属于谁就优先用谁，没有则向上找
 */
public class DemoExtendsField {
    public static void main(String[] args) {

        Fu fu = new Fu();//创建父类10
        System.out.println(fu.numFu);//只能使用父类的东西，没有任何子类的东西

        Zi zi = new Zi();
        System.out.println(zi.numFu);//10
        System.out.println(zi.numZi);//20
        System.out.println("============");

        // 等号左边是谁，就优先用谁，
        System.out.println(zi.num);//优先用子
//      System.out.println(zi.abc);//都没有，编译报错！
        System.out.println("===============");

        //方法是子类的，优先用子类的，没有向上找
        zi.methodZi();//200
        //
        zi.methodFu();//100
    }
}

package Demo7;

public class Fu {
    int num = 10;
}

package Demo7;

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,父类的成员变量

    }
}

package Demo7;
/*
局部变量：         直接写成员变量名
本类的成员变量：    this.成员变量名
父类中的成员变量：   super.成员变量名
 */
public class DemoExtendsField {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}

package Demo8;

public class Fu {
    public void methodeFu(){
        System.out.println("父类方法执行！");
    }
    public void method(){
        System.out.println("父类重名方法执行！");
    }

    public Object method1(){
        return null;
    }

    public String method2(){
        return null;
    }
}

package Demo8;

public class Zi extends Fu {
    public void methodZi(){
        System.out.println("子类方法执行");
    }
    public void method(){
        System.out.println("子类重名方法执行！");
    }

    //是object的子类，所以不报错
    @Override
    public String method1(){
        return null;
    }

    //是String的父类，所以报错
//    public Object method2(){
//        return null;
//    }

}

package Demo8;
/*在子类的继承关系中，创建子类对象，访问成员方法规则
创建的对象是谁，就优先用谁，如果没有就向上找

 */
public class DemoExtendsMethod {
    public static void main(String[] args) {

        Zi zi = new Zi();

        zi.methodeFu();
        zi.methodZi();

        //创建的是子类对象，所以优先用子类方法
        zi.method();
    }
}

package Demo8;
/*
重写：(override)
概念： 在继承关系中，方法的名称一样，参数列表也一样
重写(Override): 方法的名称一样，参数列表【也一样】,覆盖，覆写
重载(Override): 方法的名称一样参数列表【不一样】。

方法覆盖重写的注意事项：
1、必须保证父子类之间方法的名称相同，参数列表也相同
@Override: 写在方法前面，用来检测是不是有效的正确覆盖重写
2、子类方法的返回值必须小于等于父类方法的返回值范围
3、子类方法的权限必须【大于等于】父类方法的权限修饰符
提示 ： public > protected > (default) > private
备注：(default)不是关键字，而是什么都不写，留空。
 */
public class DemoOverride {
}

package Demo9;
//老款手机
public class Phone {
    public void call(){
        System.out.println("打电话");
    }
    public void send(){
        System.out.println("发短信");
    }
    public void show(){
        System.out.println("显示号码");
    }

}

package Demo9;
//新款手机
public class NewPhone extends Phone {

    @Override
    public void show(){
        //把父类的show方法拿过来重复利用
        super.show();
        //子类在添加自己的功能
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}

package Demo9;

public class DemoPhone {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.call();
        phone.send();
        phone.show();
        System.out.println("=============");

        NewPhone newPhone = new NewPhone();
        newPhone.call();
        newPhone.send();
        newPhone.show();


    }
}

package Demo10;

public class Fu {

    public Fu(){
        System.out.println("父类无参构造");
    }

    public Fu(int num){
        System.out.println("父类有参构造");

    }
}

package Demo10;

public class Zi extends Fu{


    public Zi(){

    //    super();//隐含自带的
        super(10);//在调用父类重载的构造方法
        System.out.println("子类构造方法");
    }

    public void method(){
        //super();//错误写法！只有子类构造方法，才能调用父类构造方法
    }
}

package Demo10;
/*
继承关系中，父类构造方法的访问特点：
1、子类构造方法中有一个默认隐含的"super()"调用，所以一定是先调用父类，后调用子类构造方法
2、子类构造可以使用super关键字来调用父类重载构造。
3、super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：
子类必须调用父类构造方法，不谢则赠送super();写了则用指定的super， super只能用第一个，还必须是第一个
 */
public class DemoConstructor {
    public static void main(String[] args) {
        Zi zi = new Zi();


    }
}