多态

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("灯泡可以发亮");
    }
}