java基础 ---- 继承，super，this，抽象类

java基础 ---- 继承，super，this，抽象类

继承的理解概述：

多个类中存在相同属性和行为时，将这些内容抽取到单独一个父类中，那么多个类无需再定义这些属性和行为，只要继承那一个父类即可，一方面提高代码的复用性，另一方面梳理了类与类的逻辑关系之一-------"类a与类b...都是类c"；“类a是类b,类b是类c,所以，类a是类c”粗易例如：推销员类和收营员类都是员工类；推销员类是超市员工类，超市员工类是零售业人力资源类，所以推销员类是零售业人力资源类。

继承的使用概述：

子类通过extends关键字继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为 。

---

super，this关键字的理解概述：

子类创建对象申请的堆内存空间因为具有继承关系又分出一块专门存放父类内容的内存空间，super可视为引用变量指向这块空间的内存地址，就像对象名作为引用变量指向对象的对内存空间。this也可视为引用变量指向指向当前对象super外内存空间的内存地址（父类中无super区域，this和父类名等效）。

super,this关键字的使用概述：

父子类成员变量（成员方法）重名时，用super关键字修饰父类成员变量（成员方法）以区分父子。另外因为构造方法与类同名，子类构造方法必须先用super（...）;调用父类构造方法，才能完成父类成员变量的初始化。子类成员变量与形参同名时，用this关键字修饰当前类的成员变量。为了加强辨识度，this还可用于在本类的成员方法中，访问本类的另一个成员方法； 在本类的构造方法中，访问本类的另一个构造方法。

---

方法重写的理解概述：

对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法，那么当子类中出现与父类一模一样的方法时（返回值，方法名，参数列表都一样），就会覆盖父类方法只执行子类该方法。

方法重写的使用概述：

在子类重写方法权限大于父类权限的前提下，重写父类方法先用super关键字继承父类方法，再重写其他内容，达到增强扩展的效果。

---

抽象类的理解概述:

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了，所以把没有方法主体的方法称为抽象方法 。 Java 语法规定，包含抽象方法的类就是抽象类 。

 

抽象类的使用概述:

abstract关键词修饰抽象类，抽象方法，其中抽方法只写方法要素声名（权限，返回值类型，方法名，参数列表）而不写方法体；抽象类不一定包含抽象方法，包含抽象方法一定是抽象方法。 继承抽象类的子类 必须重写父类所有的抽象方法， 否则，该子类也必须声明为抽象类。

---

 

 

继承，方法重写，方法重载，super关键字，this关键字最终测试代码：

    class Fu {
        //分别用私有成员变量和公开成员变量作代码测试
        private String signFu;
        int num = 10;
        //
        Fu(){
            setStringFu("fu");
        }
        Fu(String signFu){
            setStringFu(signFu);
        }
        //
        public void setStringFu(String signFu) {
            this.signFu = signFu;
        }

        public String getSignFu() {
            return signFu;
        }
        //
        public void method() {
            System.out.println(num);//10
        }
        //
        public void methodFu(){
            System.out.println("Fu: "+ this.getSignFu());
            //System.out.println("Fu: "+signFu);错于signFu是私有变量，虽然在父类可以直接访问，在继承父类的子类中访问为空
        }
    }
    class Zi extends Fu {
        //class Zi01 extends Fu,Fu02{}错于一个子类不能有多个父类
        //class Zi01 extends Fu{} class Fu extends Fu02{} 中Zi01继承了Fu,Fu02
        //
        //子类num变量于父类num变量同名
        int num = 20 ;
        private String signZi;
        //
        Zi(){
            //子类的每个构造方法中均有默认的super()，调用父类的空参构造。
            setSignZi("zi01");
        }
        Zi(String sign){
            super(sign);//手动调用父类构造会覆盖默认的super();
            setSignZi("zi01");
            //super(sign);错于调用父类构造方法只能写在第一句，并且只能写一次
        }
        Zi(String sign1, String sign2){
            this();
            //Zi01();错于不能直接用同名调用构造方法
            //super();错于不能在同一个构造方法里同时调用父子的构造方法，因为两者都得在第一句执行
        }
        //
        public void setSignZi(String signZi) {
            this.signZi = signZi;
        }

        public String getSignZi() {
            return signZi;
        }
        //
        //子类对父类方法重写
        @Override //用来检测是不是有效的正确覆盖重写,只要符合重写要求不写这个也行
        public void method() {
            //private double method();错在方法重写的权限要大于等于原方法，返回值范围要小于等于原方法范围
            int num = 30;
            System.out.println(num);//30
            System.out.println(this.num);//20
            System.out.println(super.num);//10
            //super.method();  10   方法重写调用父类方法，在实际应用中实现子类方法
            //System.out.println(super.sighFu)错在父类中私有关键字不能直接访问，另外不重名的变量不用super
        }
        //
        //子类对父类方法重载
        public void method(int num) {
            method();
            //this.method();
            System.out.println(num);
        }
        //
        public void methodZi(String signZi){
            setSignZi(signZi);
        }
    }


    public class inheritTest {
        public static void main(String[] args) {
            Fu fu = new Fu();
            Zi zi = new Zi("f_u");
            fu.method();    //父类被重写的非静态方法只能同过父类对象再调用
            //
            zi.method();
            //
            //子类可以向上调用父类的方法
            fu.methodFu(); //fu
            zi.methodFu(); //f_u
            //fu.methodZi();错于父类不能向下调用子类的方法
        }
    }

 

---

 

抽象类，抽象方法最终测试代码：

//含有抽象方法的类必须声明为抽象类
abstract class Fu {
    private String signFu;
    //
    public void setStringFu(String signFu) {
        this.signFu = signFu;
    }

    public String getSignFu() {
        return signFu;
    }
    //
    public abstract void method(String signFu);
    //public void abstract method(String signFu);错于abstract修饰词的位置有固定规定
    //public void abstract method(String signFu){}错于方法体为空也算是有方法体
    //
    //抽象类中也可以包含非抽象方法
    public void method(){
        setStringFu("fu");
        System.out.println(getSignFu());
    }
}
//
//不含抽象方法的类也可以声明为抽象类，目的就是不让调用者创建对象
abstract class Fu02{
    int num = 10;
    public void print(){
        System.out.println(num);
    }
        }
 //
 // 子类继承抽象父类必须对所有抽象方法重写
class Zi extends Fu {
    public void method(String signFu){
        setStringFu("f_u");
        System.out.println(getSignFu());
    }
//
//子类不对抽象父类的抽象方法进行重写必须也声明为抽象类
abstract class Zi02 extends Fu{
        public abstract void method(String signFu);
}
}
//
public class AbstractCode {
    public static void main(String[] args) {
        Zi zi = new Zi();
        //Zi01 zi = new Zi01();错于抽象类不能创建对象
        zi.method("f_u");//f_u
    }
}