JAVA语言 面向对象之 继承, 覆写, 多态性

1.继承

在Java 中,继承使用 extends 关键字来实现:

class 子类 extends 父类

继承的对应举例:

class Person{
    private String name;
    private int age;
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
}
class Student extends Person{
   private int num;
   public int getNum(){
       return num;
   }
   public void setNum(int num){
       this.num = num;
   }
}
public class Test {
    public static  void  main(String[] args) {
      Student student = new Student();
      student.setName("huihui");
      student.setAge(20);
      student.setNum(0001);
      System.out.println("Name:"+student.getName()+" "+"Age:"+student.getAge()+" "+"num:"+" "+student.getNum());
    }
}

如上可以得知,子类可以继承父类的操作,同时也可以进行功能扩充.

子类对父类进行实例化前,一定会先实例化父类对象,先调用父类构造方法,在调用子类方法.

对应代码如下:

class Person{
   public Person(){
       System.out.println("这是父类构造方法");
    }
}
class Student extends Person{
   public Student(){
       System.out.println("这是子类构造方法");
   }
}
public class Test {
    public static  void  main(String[] args) {
        Student student = new Student();
    }
}

对应证明结果为:

 

总结:1.Java 是单继承

        2.子类继承父类所有结构,但是否可以查看,取决于访问权限控制符

        3.实例化对象时,先调用父类构造方法,然后调用自身构造方法

2.覆写

定义:子类定义了与父类相同的方法或者属性,称为覆写.但子类没有父类的严格的访问控制标识符 

覆写的代码介绍:

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

}
class Student extends Person{
   public void print(){
       System.out.println("Student 类的方法");
   }//子类覆写父类的方法
}
public class Test {
    public static  void  main(String[] args) {
        Student student = new Student();
        student.print();
    }
}

注:当调用某个方法时,如果该方法被覆写,调用的一定是覆写过得方法:

如图: 

注:在覆写时,被覆写不能够拥有比父类更加严格的访问控制权限.   private < default < protected < public 

特殊情况:若父类方法为私有属性,则表示该方法只可以被父类使用,子类无法使用.

(1)super关键字

代码介绍如下:

class Person{
   public void print(){
       System.out.println("父类");
   }

}
class Student extends Person{
    public void print(){
        super.print();//关键字的使用
        System.out.println("子类");
    }

}
public class Test {
    public static  void  main(String[] args) {
        new Student().print();

    }
}

对应结果如下:

如上图可知,想要访问父类方法,可以采用 super. 方法.

(2)final 关键字

final:被称为终结器

1.final修饰类,方法,属性

2.final成员变量必须在声明是初始化

3.final定义的类不存在子类

4.final修饰的类,所对应的所有方法默认会加上final修饰 

3.多态性

方法的多态性:1.方法的重载

                       2.方法的覆写

对象的多态性:1.对象的向上转型

                       2.对象的向下转型

举例代码如下:

class Person{
   public void print(){
       System.out.println("父类");
   }

}
class Student extends Person{
    public void print(){
        super.print();
        System.out.println("子类");
    }
    public void fun(){
        System.out.println("子类独有");
    }

}
public class Test {
    public static  void  main(String[] args) {
        Person person = new Student();//向上转型
        person.print();
        Student student = (Student) person;//向上转型
        student.fun();
    }
}

注:并不是所有父类对象都可以向下转型,若想转型,一定要先发生向上转型.

向下转型存在隐患,可以采用:instanceof,先进行判断,否则会出现异常.

子类对象 instanceof 类,返回为 boolean 类型

 对应代码如下:

Person person = new Student();//向上转型
       if(person instanceof Student){//判断
           Student student = (Student)person;//转型
           student.fun();
       }

注:两个没有关系的类对象是不能够进行转型的,会产生可编译不运行异常.