Java初学6.3

Java初学6.3-继承

代码复用性差时可使用继承来提高代码的复用性问题。

当多个类存在相同的属性和方法时，可以从这些中从抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过关键字extends来声明继承父类即可。

格式：
class a extends b{

a(子类)会自动拥有b中的属性和方法。

}

package ExtendsTest;


public class Extends001 {
    public static void main(String[] args) {
        Extends003  x = new Extends003();
        x.name="于江坤";
        x.age=2024;
        x.setScore(59);
        x.Show001();
        x.Show();
        Extends004  d = new Extends004();
        d.name="勺子长";
        d.age=2023;
        d.setScore(58);
        d.Show002();
        d.Show();
    }
}
class Extends002 {//父类
    public String name;
    public int age;
    private int Score;
    //公共方法3个
    public int getScore() {
        return Score;
    }
    public void setScore(int score) {
        this.Score = score;
    }
    public void Show(){
        System.out.println("Age: " + age+", Score: " + Score);
    }
}
//子类
class Extends003 extends Extends002 {
    //特有的方法
    public void Show001(){
        System.out.println("------");
        System.out.println("小帅哥: " + name);
    }

}
class Extends004 extends Extends002 {
    //特有的方法
    public void Show002(){
        System.out.println("------");
        System.out.println("大帅哥："+name);
    }
}

子类继承了所有的属性和方法，但是私有的属性和方法不能在子类中直接访问，需要提供公共的方法访问。

package ExtendsTest;

public class ExtendsAccess {
    public static void main(String[] args) {
        //创建子类对象
        ExtendsAccess002 E = new ExtendsAccess002();
        E.test002();
        //输出时同时也调用了父类的构造器，并且先调用父类。即子类必须调用父类的构造器，完成父类的初始化。
        /*ExtendsAccess002 E1 = new ExtendsAccess002(1);//此时会再次调用父类的无参构造器
        ExtendsAccess002 E2 = new ExtendsAccess002(1,2);*/
    }
}

//父类
class ExtendsAccess001{
    int a = 1;
    public int b = 2;
    protected int c = 3;
    private int d = 4;
    //私有属性d的公共方法
    public int getD() {
        return d;
    }
    //当出现多个构造器时，需要显示的调用。
    public ExtendsAccess001(){//无参构造器
        System.out.println("无参构造器！！！");
    }
    /*public ExtendsAccess001(String z){//无参构造器
        System.out.println("一个参数的构造器！！！");
    }
    public ExtendsAccess001(String z,int x){//无参构造器
        System.out.println("两个参数的构造器！！！");
    }*/
    void AA(){
        System.out.println("AA");
    }
    public void BB(){
        System.out.println("BB");
    }
    protected void CC(){
        System.out.println("CC");
    }
    private void DD(){
        System.out.println("DD");
    }
    public void DD001(){
        DD();
    }
}

//子类
class ExtendsAccess002 extends ExtendsAccess001{
    public ExtendsAccess002(){//无参构造器
        //隐藏了super();默认调用父类的无参构造器，当然也可以显示的写出来
        //注意！！！！！！super必须写在第一行，否则会出现错误！！！！！！和this一样
        //super("zxc");
       // super("asd",18);
        System.out.println("哈哈哈哈哈哈哈哈！");
    }
    //在创建子类对象时，无论使用的是哪个构造器，默认情况下总会调用父类的无参构造器
   /*public ExtendsAccess002(int a){//ExtendsAccess002 E1 = new ExtendsAccess002(1);调用有参构造器
        //super("zxc");
        // super("asd",18);
        System.out.println("嘻嘻~");
    }*/
    /*public ExtendsAccess002(int a,int b){//ExtendsAccess002 E2 = new ExtendsAccess002(1,2);调用有参构造器
        //super("zxc");
        //super("asd",18);
        System.out.println("嘻嘻~");
    }*/
    public void test002(){
        System.out.print("a:" + a + " b:"+ b + " c:"+ c);
        //System.out.println("d:"+d);
        //对于私有属性只能调用公共的方法来访问
        System.out.println(" d:"+getD());
        AA();
        BB();
        CC();
       // DD();
        //对于私有的方法DD只能通过公共的方法访问
        DD001();
    }
}

连续的继承（无参构造器）：

package ExtendsTest;
//继承继承继承继承继承！！！
//子类最多只能继承一个父类，即单继承机制。
public class ExtendsInheritance {
    public static void main(String[] args) {
        ExtendsInheritance004 E = new ExtendsInheritance004();
        E.ExtendsInheritance004();
    }
}
class ExtendsInheritance001{
    public void ExtendsInheritance001(){
        System.out.println("ExtendsInheritance001");
    }
}
class ExtendsInheritance002 extends ExtendsInheritance001 {
    public void ExtendsInheritance002(){
        super.ExtendsInheritance001();
        System.out.println("ExtendsInheritance002");
    }
}
class ExtendsInheritance003 extends ExtendsInheritance002{
    public void ExtendsInheritance003(){
        super.ExtendsInheritance002();
        System.out.println("ExtendsInheritance003");
    }
}
class ExtendsInheritance004 extends ExtendsInheritance003{
    public void ExtendsInheritance004(){
        super.ExtendsInheritance003();
        System.out.println("ExtendsInheritance004");
    }
}

连续继承（有参构造器）；

package ExtendsTest;

public class ExtendsInheritance0001 {
    public static void main(String[] args) {
        ExtendsInheritance04 E = new ExtendsInheritance04("123",18,20.0, 30.0);
    }
}
class ExtendsInheritance01 {
    public ExtendsInheritance01() {
        super();//调用Object中的无参构造器。
        System.out.println("ExtendsInheritance01");
    }
}

class ExtendsInheritance02 extends ExtendsInheritance01 {
    public ExtendsInheritance02(String number) {
        super();
        System.out.println("ExtendsInheritance02");
    }
}
class ExtendsInheritance03 extends ExtendsInheritance02{
    public ExtendsInheritance03(String number, int i) {
        super("1");
        System.out.println("ExtendsInheritance03");
    }
}
class ExtendsInheritance04 extends ExtendsInheritance03{
    public ExtendsInheritance04(String number, int i, double d, double v) {
        super("1",1);
        System.out.println("ExtendsInheritance04");
    }
}

小思考：

package ExtendsTest;

public class ExtendsNature {
    public static void main(String[] args) {
        Third third = new Third();
        System.out.println(third.name);
        //此时返回three，若出现private时，报错。若Third中没有name，则输出two。以此类推。
        System.out.println(third.age);
        System.out.println(third.sex);//由于存在继承，所以可以返回。
        System.out.println(third.score);
    }
}
class First{
    String name="one";
    int age=10;
    double score=100;
}
class Second extends First{
    String name="two";
    int age=20;
    int sex=1;
}
class Third extends Second{
    String name="three";
    int age=30;
}