多态

最新推荐文章于 2023-04-24 23:05:17 发布

原创最新推荐文章于 2023-04-24 23:05:17 发布 · 122 阅读

CC 4.0 BY-SA版权

本文详细介绍了Java中的继承特性，包括成员变量的访问规则、构造方法的调用、继承的优点与特点。同时，解释了final关键字的作用，用于修饰类、变量和方法。此外，阐述了方法重写和重载的区别，以及多态的概念、实现条件和好处。文章还通过实例展示了如何在实际编程中运用这些概念，如抽象类、抽象方法、多态以及final关键字在基本类型和引用类型上的应用。

1.继承中成员变量访问问题(父类成员变量名称和子类成员变量名称一致)
       继承中:父类成员变量名称和子类成员变量名称一致
           遵循"就近原则"
           1)先在子类局部位置查找,如果存在,就使用
           2)如果不存在,在子类的成员位置查找,如果存在,就使用
           3)如果子类的成员位置不存在,在父类的成员位置中找,有就使用
           4)如果父类成员位置没有,就没有这个变量,报错!

2.子类继承父类,如何访问构造方法?如果父类没有无参构造方法,如何访问

       继承中,构造方法不能被继承的;子类的所有的构造方法都默认访问父类的无参构造方法 :super() ;

       如果父类没有给出无参构造方法,子类的构造方法都会报错
       解决方案:
           1)手动给出父类的无参构造方法
           2)间接通过访问父类的有参构造方法,让父类进行数据初始化; super(xx) ;
           3)只要子类中的构造方法的一个能够让父类初始化即可!

           可以先通过本类的无参构造方法,间接访问本类的有参构造方法:this(xx),
           在通过本类的有参构造方法 :访问父类的有参构造方法:super(xx)

3.继承的好处以及特点有什么
       继承的好处:
               1)提高了代码的复用性
               2)提高了代码的维护性
               3)类与类之间产生继承关系,是"多态"的前提条件

       继承的特点:
               1)在Java中,只支持单继承,不支持多继承
               2)虽然不支持多继承,可以多层继承!

4.final关键字的特点有哪些
   final:状态修饰符,可以修饰类:该类不能被继承

   可以修饰变量,此时这个变量是常量,只能被赋值一次,不能再次更改了!
           成员位置:
                   public static final int xx = 值; 传统方式定义常量       普通格式(编译时期常量)
                   public final Student s = new Student() ; //实例(创建对象)变量 (运行时期常量)

   修饰方法,此方法不被重写!

5.this和super的区别
       this:代表当前类的对象地址值引用
       super:代表父类空间标识(父类对象的地址值引用)

   this.变量名; 访问的本类的成员变量
   super.变量名; 访问的是父类的成员变量

   this.方法名() ;访问本类的成员方法
   super.方法名() ; 访问的父类的成员方法

   this() ; 访问本类的无参构造方法
   super() ;访问父类的无参构造方法

   this(xxx) ;访问本类的有参构造方法
   super(xxx);访问的父类的有参构造方法

6.方法重写和方法重载的区别
                           public String eat() {
                               return "xx" ;
                           }

                           public String eat(){

                           }
       Override:继承关系中,子类出现了父类一模一样的方法声明,子类的方法将父类的方法覆盖掉了,
                                                                                       使用子类的功能!
       Overload:定义多个方法的时候,这个方法(功能)可以提高代码的扩展性,可以针对同一个功能,传递不同类型的参数
               方法名相同,参数列表不同,和返回值无关!
                           参数类型不同,
                           参数个数不同
                           参数类型顺序...

什么是抽象类？
* 在现实世界存在真实事物,本身就是概括性的事物,这个时候,为了将具体的事物的功能给出具体体现,那么当前概括性的事物中
* 加入抽象-----abstract,并且它里面的一些功能仅仅只是声明,并不给出具体体现!

什么叫抽象方法?
* 抽象方法就是没有方法体的方法;
* public abstract 返回值类型方法名(形式参数);
*
* 抽象类有一个特点:
* 抽象类不能实例化-----不能 new
*
* 抽象类的子类:
* 1)是抽象类,也不能实例化!
* 如果仅仅存在父类,和子类,这个子类还是抽象类---毫无意义! new 不了!
*
* 2)研究的具体类: 可以实例化的!
* 对象的创建还是子类创建的!
*
* 抽象的父类名对象名 = new 子类名() ; //抽象类多态
*
* 抽象类的本质---->就是强制子类必须要将父类的中抽象功能,重写!

多态
* 一个事物在不同时刻体现的不同形态(内存中的变化)

要使用多态,要遵循它的前提条件:
* 1)必须存在继承关系 (没有继承关系,不谈多态!)
* 2)必须有方法重写 (子类继承父类,需要将父类的功能覆盖掉)
* 使用子类的功能;
* 3)必须存在父类引用指向子类对象("向上转型")
* class Fu{}
* class Zi extends Fu{}
* 之前:Zi zi = new Zi() ;
* 现在:多态: Fu f = new Zi() ;
*
*
* 在多态中,的成员访问特点:
* Fu f = new Zi() ;
* 非静态
* 成员变量:编译看左,运行看左
* 成员方法:编译看左,运行看右 :由于存在子类重写父类的功能,所以使用的子类的功能
* 静态方法: 静态的东西都是跟当前类有关系:优先进内存(随着类的加载而加载)
* 静态方法--算不上方法重写:编译看左,运行看左
*
* 构造方法:父类先初始化,然后子类在进行初始化

多态的好处是什么?
* 1)可以提高代码的复用性 (是由继承保证的)
* 2)可以提高代码的扩展性(多态完成:父类引用指向子类对象:Fu f = new Zi()) ;

多态的弊端:
* 不能访问子类的特有功能!
*
* 向上转型:父类引用指向子类对象
*
* 如果能够使用子类型,就可以访问它的功能!
*
* 解决方案:
* 1)子类引用指向自己本身:子类对象
* 虽然可以访问,但是多态中,不推荐,因为重新new 对象,消耗堆内存空间
*
* 2) 将父类引用强制转换为子类引用 :向下转型 ,前提:必须存在向上转型
* Fu f = new Zi() ;//向上转型
* Zi z = (Zi)f ; //向下转型
*
* 推荐2) :不会重新在堆内存中开辟空间,结束内存空间!

ClassCastException:类转换异常:属于运行时期异常!

public class DuoTaiDemo4 {
    public static void main(String[] args) {
            //多态创建对象
        Animal2 a = new Cat2() ; //堆内存中猫的实例 (猫是动物)
        Cat2 c = (Cat2)a ; //将猫还原了  (猫是猫)  向下转型

        a = new Dog2() ;//堆内存中是狗的实例(狗是动物)
        Dog2 d = (Dog2)a; //还原成狗了

     //  Cat2 c2 = (Cat2)a; //ClassCastException:类转换异常:属于运行时期异常!


    }
}

final关键字修饰基本类型/引用类型的区别
*
*
* final:本身:最终的,无法更改的状态修饰符
*
* 当final修饰基本数据类型,基本数据类型的值不能再改变,只能赋值一次!
*
* 开发中,定义基本数据类型的常量:
* 在一个类的成员位置:
* public static final int xxx = xx ;
*
* 当final修饰引用数据类型,引用数据类型的地址值不能在改变!

成员方法的分类:
* 是否存在返回值,是否带参
*
* 根据具体需求然后定义相对应的功能!
* 参数类型:
* 基本类型/引用类型
* 返回值类型:
* 基本类型/引用类型

继承中成员方法的访问问题:
* 如果子类和父类的成员方法名称不一致,分别访问即可!
*
* 子类和父类的成员方法名称一致,
* 子类中存在,访问子类的;
* 如果不存在,访问父类,如果父类没有,报错!

有一个台灯:Lamp ,台灯有开灯的功能on,
* 它里面有一个灯泡属性bubble ,灯泡有发亮的功能,红灯泡,绿灯泡分别可以发红光,可以发绿光,
*
* 使用面向编程方式去设计这个程序

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


        //创建台灯类对象
        Lamp lamp = new Lamp() ;
        //父类引用指向子类对象
        Bubble bubble = new RedBubble() ;
        lamp.on(bubble);
        Bubble bubble2 = new GreenBubble() ;
        lamp.on(bubble2);
        System.out.println("-----------------");

        lamp.on(new RedBubble()) ;

        lamp.on(new GreenBubble()) ;
    }
}
public class RedBubble extends  Bubble {

        //发亮:发红光
        public void shine(){
            System.out.println("灯泡可以发红光...");
        }


}public class Lamp {

    //灯泡属性
    private Bubble bubble ;//灯泡属性


    //开灯的功能
    public  void on(Bubble bubble){ //开灯,灯泡要发亮
            bubble.shine();
    }
}public class GreenBubble extends Bubble {

    @Override
    public void shine() {
        System.out.println("灯泡可以发绿光了...");
    }
}public class Bubble {


    //发亮的功能
    public void shine(){
        System.out.println("灯泡可以发亮");
    }
}