java——继承和覆写

继承

最大特征是解决代码的重用问题

使用extends关键字完成

class 子类 extends 父类{}

子类被称为派生类，父类称为基类（超类，supper slass）

public class Main {
    public static  void main(String args []) {
        Emp1 emp=new Emp1();
        emp.setName("张三");
        emp.setAge(3);
        emp.setId(001);
        System.out.println(emp.getInfo());
        
    }
}

class Preson{
    private String name;
    private int age;
    private int id;

    public void setName(String name) {
        this.name = name;
    }
    public String getName(){
        return this.name;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }

    public void setId(int id) {
        this.id = id;
    }
    public int getId(){
        return this.id;
    }

    public String getInfo(){
        return this.name+"今年"+this.age+"岁，他的编号是"+this.id;
    }

}

class Emp1 extends Preson{}

Emp1类中没有写任何方法，由于继承了Preson类，可直接使用Preson类中的方法。

如果需要，也可以直接在Emp1中定义新的方法。

 

继承的限制：

不允许多层继承

错误实例：

class A{}
class B{}
class C extends A,B{}

正确实例：

class A{}
class B extends A{}
class C extends B{}

C类是A类的孙子类，在多层继承中，没有层次的限制，但从开发的角度来看不要超过三层

 

所有属性都可以被继承：

私有属性只能是进行私有属性的访问，隐士继承。

其余属性是显示继承

子类对象构造前一定会默认调用父类的构造（默认使用无参构造），以保证父类的对象先实例化，而后再实例化子类对象

public class Main {
    public static  void main(String args []) {
        B b=new B();
    }
}

class A{
    public A(){
        System.out.println("A类的构造方法");
    }
}

class  B extends A{
    public B(){
        System.out.println("B类的构造方法");
    }
}


输出：
A类的构造方法
B类的构造方法

super()和this()不能同时出现，子类构造调用前一定会先执行父类的构造，父类对象初始化后才轮到子类对象初始化

覆写

方法的覆写：

当子类定义了与父类方法名称，参数类型，个数及返回值相同的方法就成为覆写；

public class Main {
    public static  void main(String args []) {
        B b=new B();
        b.fun();
    }
}

class A{
    public void fun(){
        System.out.println("A类的方法");
    }
}

class  B extends A{
    public void fun(){
        System.out.println("B类的方法");
    }
}

覆写的使用原则：

发现父类中的方法名称功能不足（不适用于本子类），但是又必须使用该方法名称的时候，就需要采用覆写这一概念的实现。

被子类覆写的方法不能拥有比父类更严格的访问控制权限。

当父类中的方法使用private方法的时候，此方法对子类不可见，无法覆写；

在子类中this与super的区别：

super.方法()——明确不查找子类中是否有此方法，而实直接调用父类中的指定方法

this.方法()——调用子类中的方法，若子类中没有此方法则调用父类中的此方法

 

重载（overloading）与覆写（override）的区别：

区别	重载（overloading）	覆写（override）
发生范围	同一个类或者具有继承关系的两个类中	发生在继承关系中
定义	方法名称相同，参数的类型，个数不同（返回值可以不同，但尽量相同）	方法名称相同，参数的类型，个数相同方法返回值相同
权限	没有权限限制	被覆写的方法不能拥有比父类拥有更为严格的访问控制权限

 

子类的覆盖：

使用private进行了封装，实际意义不大

 

 

数组操作：

public class Main{
    public static void main(String args []){

        ReverseArray arr=new ReverseArray(3);
        System.out.println(arr.add(10));
        System.out.println(arr.add(16));
        System.out.println(arr.add(15));
        System.out.println(arr.add(2));
        System.out.println(arr.add(100));
        int temp []=arr.getData();
        for (int x=0;x<temp.length;x++){
            System.out.println(temp[x]);
        }

    }
        }


class Array{
    private int data[];
    int foot;
    public Array(int len){
        if (len>0){
            this.data=new int [len];
        }else {
            this.data=new int[1];
        }
    }
    public boolean add(int num){
        if (this.foot<this.data.length){
            this.data[foot++]=num;
            return true;
        }
        return false;
    }
    public int [] getData(){
        return data;
    }
}

class SortArray extends Array{            //继承
    public SortArray(int len){
        super(len);                      //调用父类
    }
    public int [] getDate(){                          //覆写
        java.util.Arrays.sort(super.getData());        //排序
        return super.getData();                       //真正的内容在父类当中
    }
}

class ReverseArray extends Array{           //发转
    public ReverseArray(int len){
        super(len);
    }
    public int [] getData(){              //覆写
        int center=super.getData().length/2;
        int head=0;
        int tail=super.getData().length-1;
        for (int x=0;x<center;x++){
            int temp=super.getData()[head];
            super.getData()[head]=super.getData()[tail];
            super.getData()[tail]=temp;
            head ++;
            tail--;
        }
        return super.getData();
    }
}