java学习笔记——第九章 继承、重载、接口和构造器（一）

9.1类的继承
类的继承：是新的类从已有的类中取得已有的特性。
类的派生：是从已有的类产生新类的过程，这个已有的类称为基类或父类。
父类和子类
在java中，通常把子类称为父类的直接子类，把父类称为子类的直接超类。
例如类A继承了类B的子类，则必须符合下面的要求。

• C是B的子类，A是C的子类，则A是B的子类；
• 一个类只能有一个父类，extends前只能有一个类，不支持多重继承。

例子：

//定义类是jitwo
class jitwo {
    String name;
    int age;
    long number;
//构造方法
    jitwo(long number, String name, int age) {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("手机：" + number);
    }
}

class super2b extends jitwo {
    super2b(long number, String name, int age, boolean b) {
        super(number, name, age);
        System.out.println("喜欢电竞吗" + b);
    }
}

public class jione1 {
    public static void main(String args[]) {
        super2b abc1 = new super2b(15150555, "王工", 18, false);
    }
}

输出：

姓名：王工
年龄：18       
手机：15150555 
喜欢电竞吗false

上述代码，类super2b继承了父类jitwo的属性和方法。
补充：
构造方法的名字必须与定义它的类名完全相同，没有返回类型，甚至没有void。
普通方法不能和类名一样，但要有返回值或者void。

调用父类的构造方法
在java中，一个子类可以访问构造方法，格式如下:

super(参数);

例如：

public class Newgou {
    String bname;
    int bid;
    int bprice;

    Newgou() {
        bname = "<父类中的>";
        bid = 322221;
        bprice = 42;
    }

    Newgou(Newgou a) {
        bname = a.bname;
        bid = a.bid;
        bprice = a.bprice;
    }

    Newgou(String name, int id, int price) {
        bname = name;
        bid = id;
        bprice = price;
    }

    void print() {
        System.out.println("名字：" + bname + "序号：" + bid + "价格：" + bprice);
    }
}

class Newgou1 extends Newgou {
    String Newgou;

    Newgou1() {
        super();
        Newgou = "作家出版社";
    }

    Newgou1(Newgou1 b) {
        super(b);
        Newgou = b.Newgou;
    }

    Newgou1(String x, int y, int z, String aa) {
        super(x, y, z);
        Newgou = aa;
    }
}

class text1 {
    public static void main(String args[]) {
        Newgou1 a1 = new Newgou1();
        Newgou1 a2 = new Newgou1("<结果是啥>", 343006, 45, "中国新世界出版集团");
        Newgou a3 = new Newgou(a2);
        System.out.println(a1.Newgou);
        a1.print();
        System.out.println(a2.Newgou);
        a2.print();
        a3.print();
    }
}

结果如下：

作家出版社
名字：<父类中的>序号：322221价格：42
中国新世界出版集团
名字：<结果是啥>序号：343006价格：45
名字：<结果是啥>序号：343006价格：45

访问父类的属性和方法
在java中，一个类的子类可以访问父类中的属性和方法，具体语法格式如下：

Super.[方法和全局变量];

例如：

class supertwo1 {
    int a = 11;
    int b = 29;
}

class supertwo2 extends supertwo1 {
    int a = 56;
    int b = 89;

    supertwo2(int x, int y, int z, int q) {
        super.a = x;
        super.b = y;
        a = z;
        b = q;
    }

    void print() {
        System.out.println("" + super.a);
        System.out.println("" + super.b);
        System.out.println("" + a);
        System.out.println("" + b);
    }
}

public class text2 {
    public static void main(String args[]) {
        System.out.println("我的身价走向趋势");
        supertwo2 a1 = new supertwo2(110, 220, 230, 240);
        a1.print();
    }
}

输出结果

我的身价走向趋势
110
220
230
240

多重继承
假如B继承了A，类C又继承了B，这种情况就叫做多重继承。
例子：

class duolei {
    String bname;
    int bid;
    int bprice;

    duolei() {
        bname = "羊肉串";
        bid = 14002;
        bprice = 45;
    }

    duolei(duolei a) {
        bname = a.bname;
        bid = a.bid;
        bprice = a.bprice;
    }

    duolei(String name, int id, int price) {
        bname = name;
        bid = id;
        bprice = price;
    }

    void print() {
        System.out.println("小吃名：" + bname + "  序号" + bid + "  价格" + bprice);
    }
}

class Badder extends duolei {
    String badder;

    Badder() {
        super();
        badder = "沙县小吃";
    }

    Badder(Badder b) {
        super(b);
        badder = b.badder;
    }

    Badder(String x, int y, int z, String aa) {
        super(x, y, z);
        badder = aa;
    }
}

class Factory extends Badder {
    String factory;

    Factory() {
        super();
        factory = "成都小吃";
    }

    Factory(Factory c) {
        super(c);
        factory = c.factory;
    }

    Factory(String x, int y, int z, String l, String n) {
        super(x, y, z, l);
        factory = n;
    }
}

public class zero {
    public static void main(String args[]) {
        Factory a1 = new Factory();
        Factory a2 = new Factory("希望火腿", 92099, 25, "沙县蒸饺", "金华小吃");
        Factory a3 = new Factory(a2);

        System.out.println(a1.badder);
        System.out.println(a1.factory);
        a1.print();
        System.out.println(a2.badder);
        System.out.println(a2.factory);
        a2.print();
        a3.print();
    }
}

输出结果：

沙县小吃
成都小吃
小吃名：羊肉串  序号14002  价格45
沙县蒸饺
金华小吃
小吃名：希望火腿  序号92099  价格25
小吃名：希望火腿  序号92099  价格25

重写父类
大多数情况下，子类总是以父类为基础，然后增加新的属性和方法。但是，例如鸵鸟属于鸟类，但是不会飞，需要改一下鸵鸟子类的属性。
例子：

//feiniao.java
public class feiniao {
    public void fly() {
        System.out.println("我会飞...");
    }
}

//tuoniao.java
public class tuoniao extends feiniao {
    public void fly() {
        System.out.println("我只能在地上跑");
    }

    public void calloveridedmethod() {
        super.fly();
    }

    public static void main(String args[]) {
        tuoniao os = new tuoniao();
        os.fly();
        os.calloveridedmethod();
    }
}

输出结果：

我只能在地上跑
我会飞...

上述子类包含父类同名方法fly的现象被称为重写，也被称为方法覆盖（Override)
子类覆盖父类要遵循“两同两小一大”的原则。两同：方法名相同、形参列表相同。两小：子类方法返回值类型比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法更小或相等。一大：子类方法的访问权限比父类方法更大或相等。
覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法，不能一个类一个实例。

9.2重写和重载
重写
重写实际就是重写子类、重新编写父类方法达到自己的需求。
例如：

public class chonxgie 
{
    void print()
    {
        System.out.println("父类的方法");
    }
}
class Chongxieone extends chonxgie
{
    void print()
    {
        System.out.println("子类，重写了父类的方法");
    }
}

虽然不输出，虽然父类中有void print方法，通过在子类中重写此方法来达到子类需要的要求。

例子：

class cxie {
    String sname;
    int sid;
    int snumber;

    void print() {
        System.out.println("公司名" + sname + "  序号" + sid + "公司人数" + snumber);
    }

    cxie(String name, int id, int number) {
        sname = name;
        sid = id;
        snumber = number;
    }
}

class cxietwo extends cxie {
    String sdder;

    cxietwo(String x, int y, int z, String aa) {
        super(x, y, z);
        sdder = aa;
    }

    void print() {
        System.out.println("公司类型" + sname + "  股票号码" + sid + "  员工人数" + snumber + "  地址" + sdder);
    }
}

public class gongsi {
    public static void main(String args[]) {
        System.out.println("XX集团的基本信息是");
        cxietwo a1 = new cxietwo("独角兽", 11010, 2700, "XX大厦");
        a1.print();
    }
}

结果：

XX集团的基本信息是
公司类型独角兽  股票号码11010  员工人数2700  地址XX大厦

在java中，重写有自己的规则：

1. 父类中的方法不是在任何时候都可以重写的，当父类中的方法控制修饰符为private时，该方法只能被自己的类访问，不能被外部访问，不能被子类重写。 。
2. 如果父类定义为public，在子类中绝对不定义为private。

重载

在java中，同一类可以有两个或多个方法具有相同的方法名 ，只要他们的参数不同即可，这就是方法的**参数决定了重载方法的调用。如果是int参数调用，则调用自带int方法，如果是double参数调用方法，则调用自带double的重载方法。
例如：

public class czai {
    String ename;
    int age;

    void print() {
        System.out.println("姓名：" + ename + "  年龄" + age);
    }

    void print(String a, int b) {
        System.out.println("姓名：" + a + "  年龄" + b);
    }

    void print(String a, int b, int c) {
        System.out.println("姓名：" + a + "  年龄" + b + "  当前身价" + c);
    }

    void print(String a, int b, double c) {
        System.out.println("姓名：" + a + "  年龄" + b + "  当前身价" + c);
    }

    public static void main(String args[]) {
        czai a1 = new czai();
        a1.ename = "老大";
        a1.age = 65;
        System.out.println("继承人信息：");
        a1.print();
        a1.print("老二", 63);
        a1.print("老三", 58, 10025);
        a1.print("老四", 55, 20.1);
    }
}

结果如下：

继承人信息：
姓名：老大  年龄65
姓名：老二  年龄63
姓名：老三  年龄58  当前身价10025
姓名：老四  年龄55  当前身价20.1

联合使用重写和重载
例如：

import jdk.internal.icu.impl.Punycode;

class cfang {
    int a = 101;
    int b = 902;

    int print() {
        return a + b;
    }

    int print(int a, int b) {
        return a + b;
    }
}

class cfang1 extends cfang {
    int print() {
        return a;
    }

    double print(int a, double b) {
        return a + b;
    }
}

public class textyo {
    public static void main(String args[]) {
        cfang a1 = new cfang();
        cfang1 a2 = new cfang1();
        a1.a = 1;
        a1.b = 2;
        System.out.println("X集团财产继承分配方案公布，被分成4分，具体金额：");
        System.out.println(a1.print() + "港币");
        System.out.println(a1.print(13, 22) + "港币");
        a2.a = 4;
        a2.b = 5;
        System.out.println(a2.print() + "港币");
        System.out.println(a2.print(33, 22) + "港币");
    }
}

输出结果：

X集团财产继承分配方案公布，被分成4分，具体金额：
3港币
35港币
4港币
55港币