继承和多态------java

最新推荐文章于 2025-12-08 09:18:56 发布

原创最新推荐文章于 2025-12-08 09:18:56 发布 · 256 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

今天我们来聊聊继承和多态，首先我们先来谈谈继承，那么继承是什么呢？继承就像是电视剧中，孩子将会继承也就是获得其父亲的家产，为获得家产，兄弟姐妹互相残杀，所以对于继承来说，谁继承，继承谁的，继承了什么格外重要。

继承分为单继承（家里独生子女）、多层继承（家产从祖宗那里一代代的传承下来【java中一般不希望出现3层以上的继承】）、不同类继承同一个类（家产分为好几份分给每个孩子）、多继承（java不支持）。在java中用extends关键字实现，继承的特点：子类继承了父类后，自动获得父类的属性（家产），且只能直接继承一个（只有一个亲生父亲）【单继承的特点】，子类不用在编写父类里原有的变量，可直接继承使用【代码复用的特点】，子类可以在新增自己的属性和方法【功能扩展的特点】，子类可以对父类方法进行重写以适应需求【方法重写的特点】，接下我们一起来看看接下来的代码，java中如何表示继承这种关系，如图：

 class Animal{
    String name;
    int age;
public Animal(String name,int age){//父类构造方法
    this.name=name;
    this.age=age;
public void eat(){
    System.out.println(this.name+"吃饭------");
}
}

  class Dog extends Animal{
    String color;//除了父类属性，子类自己本身的属性（功能扩展）
    public Dog(String name，int age，String color){
    super(name，age);
    this.color=color;
     
}
}
 
public void eat(){  //重写父类方法适应需求，
    System.out.println(name+"吃狗粮------");
}
    
}
public class Main{
    public static void main(){
    Dog dog=new Dog("单身狗"，2，"棕色");
    dog.eat();//会调用子类方法
}
}

那么如果一个类不想被其它类继承，可以使用final关键字修饰当前类，此种类叫密封类，final修饰方法时叫密封方法（不可以被重写但可以被调用），如图：

 class Animal{
    String name;
    int age;
public Animal(String name,int age){//父类构造方法
    this.name=name;
    this.age=age;
 final void do(){
    System.out.println("休息");//不可被重写但可被调用
}
public void eat(){
    System.out.println(this.name+"吃饭------");
}
}

  class Dog extends Animal{
    String color;//除了父类属性，子类自己本身的属性（功能扩展）
    public Dog(String name，int age，String color){
    super(name，age);
    this.color=color;
     super.do();
}
}
    final class Cat extends Animal{//此类不可被继承
        String color;

}
public void eat(){  //重写父类方法适应需求，
    System.out.println(name+"吃狗粮------");
}
    
}
public class Main{
    public static void main(){
    Dog dog=new Dog("单身狗"，2，"棕色");
    dog.eat();//会调用子类方法
}
}

被final修饰的方法和类可以被访问修饰符修饰，因为访问修饰符决定的是访问限定的权限，而final关键字对于方法是控制方法不能被重写，对于类来说是控制类不能被继承，两者权限并不冲突，继承就说到这里，接下来说一下多态。

多态，很多人单从字面理解多态多种状态，然而多态并非如此简单，其的定义是完成某个行为时，不同的对象去完成会产生不同的状态。例如三个人去买蛋糕，一个人开车去，一个人走路去，一个人坐公交去，三个人做同一件事但表现出不同行为不同------多态。那么多态实现条件是什么呢？1.必须在继承体系下实现；2.子类必须对父类方法进行重写，（重写不能是静态方法也不能是被final修饰的方法）；3.通过父类的引用调用重写方法。多态的体现在于，传递不同对象，会调用对于类中自己重写的方法。让我们回到实现多态的实现条件，在1的条件下，父类引用子类的对象后，调用子类与父类重写的方法叫动态绑定，而动态绑定涉及的父类引用子类对象叫向上转型，向上转型特点是不能调用子类特有的方法，因为父类引用虽然指向子类但编译时它只检查变量的声明类型中类是否声明了这个方法，如果是子类特有的则会编译报错。动态绑定写法共有三种，接下来我会在代码中给你展示此段内容，如图:

 class Animal{
    String name;
    int age;
public Animal(String name,int age){//父类构造方法
    this.name=name;
    this.age=age;
 final void do(){
    System.out.println("休息");//不可被重写但可被调用
}
public void eat(){
    System.out.println(this.name+"吃饭------");
}
}

  class Dog extends Animal{
    String color;//除了父类属性，子类自己本身的属性（功能扩展）
    public Dog(String name，int age，String color){
    super(name，age);
    this.color=color;
     super.do();
}
    public void eat(){
    System.out.println(name+"吃狗粮")
}
}

    final class Cat extends Animal{//此类不可被继承
        String color;
}
public void eat(){  //重写父类方法适应需求，
    System.out.println(name+"吃狗粮------");
}
    
}
public class Main{

    public  static void fun(Animal am2)
{
    am2.eat();//调用子类方法
}
public static Animal fun2(){//在主方法中调用fun方法，fun属于类的必须要是静态方法，否则必须实例 
                                化对象，对对象的访问进行调用
    Dog dog3=new Dog("旺旺"，3，"彩色");
    return dog3;
}
 
    public static void main(String [args]){
    Dog dog=new Dog("单身狗"，2，"棕色");
    dog.eat();//会调用子类方法
    Animal am1=new Dog("拉拉"，2，"白色");//第一种向上转型的方法
    am1.eat();//此时会调用子类的方法
    Dog dog2=new Dog("西西"，3，"黄色");
    fun(dog2);//第二种向上转型的方法，将子类对象作参传过去，以父类对象接收
    Animal am4=fun2();//第三种向上转型的方法，返回子类对象
    am4.eat();
}
}

除了向上转型还有向下转型，父类转子类存在风险需要强转，关键点在于父类是否引用了子类的对象，引用了才有可能会强转成功，强转的子类还必须是子类类型的变量接收，有两种方法如图：


 class Animal{
    String name;
    int age;
public Animal(String name,int age){//父类构造方法
    this.name=name;
    this.age=age;
 final void do(){
    System.out.println("休息");//不可被重写但可被调用
}
public void eat(){
    System.out.println(this.name+"吃饭------");
}
}

  class Dog extends Animal{
    String color;//除了父类属性，子类自己本身的属性（功能扩展）
    public Dog(String name，int age，String color){
    super(name，age);
    this.color=color;
     super.do();
}
    public void eat(){
    System.out.println(name+"吃狗粮")
}
}

    final class Cat extends Animal{//此类不可被继承
        String color;
}
public void eat(){  //重写父类方法适应需求，
    System.out.println(name+"吃狗粮------");
}
    
}
public class Main{

    public  static void fun(Animal am2)
{
    am2.eat();//调用子类方法
}
public static Animal fun2(){//在主方法中调用fun方法，fun属于类的必须要是静态方法，否则必须实例 
                                化对象，对对象的访问进行调用
    Dog dog3=new Dog("旺旺"，3，"彩色");
    return dog3;
}
 
    public static void main(String [args]){
    Dog dog=new Dog("单身狗"，2，"棕色");
    dog.eat();//会调用子类方法
    Animal am1=new Dog("拉拉"，2，"白色");//第一种向上转型的方法
    am1.eat();//此时会调用子类的方法
    Dog dog2=new Dog("西西"，3，"黄色");
    fun(dog2);//第二种向上转型的方法，将子类对象作参传过去，以父类对象接收
    Animal am4=fun2();//第三种向上转型的方法，返回子类对象
    am4.eat();
    Animal am3=new Dog("哈哈"，1，"白色");
    Dog dog5=（Dog）am3;//向下转型第一种方法
    dog5.eat();//向下转型成功后可以掉用子类自己的方法（包括子类独有的方法）
    Animal am6=new Dog("咪咪"，6，"绿色");
    if(am6 instanceof Dog){//instanceof用于判断am6是否引用Dog这个对象
     Dog dog7=(Dog)am6;//第二种向下转型的方法
     dog7.eat();
    }
}
}

多态降低了代码的圈复杂度【代码中条件语句与循环语句出现的个数】，避免使用了大量的if-else语句，多态使用可以充分体现引用对象不同，调用同一个方法，表现现象不同的思想。以上就是我对继承和多态的理解，若有误麻烦指出，谢谢！！！(小编建议写代码时一个文件一个类)。