继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持,我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

继承 多态 抽象类 接口等学习内容总结

AI人工智能视频入门
关注TA
已关注
手记 330
粉丝 93
获赞 396

一:
继承:
1.概念:将多个类抽取位一个独立的类,让独立的类和多个类产生继承关系

  1. 继承 的关键字:extends
    3.格式:
    class 子类名 extends 父类名{
    ...
    }
    4.继承的好处:
    1>提供了代码复用性,解决了代码的臃肿
    2>它是多态的前提(多态的前提是必须有继承关系
    5.继承的特点:
    子类继承父类,是继承了父类所有的东西(成员变量,成员方法,包括私    有),但是子类不能使用私有的东西,只能通过父类的公共的访问间接的让子类访问它.

    4>匿名内部类的本质:是继承了该类或者实现了该接口子类对象...
    面试题??
    匿名内部类面试题:
    按照要求,补齐代码
    interface Inter { void show(); }
    class Outer { //补齐代码 }
    class OuterDemo {
    public static void main(String[] args) {
    Outer.method().show();
    }
    }
    要求在控制台输出”HelloWorld”

                                        interface Inter3{                                        void show() ;//public abstract                                     }                                    class Outer7{                                        //补齐代码                                        public static Inter3 method() {                                            //返回的是接口:当前并不提供接口的子实现类,所以只能用匿名内部类                                            return new Inter3() {                                                public void show() {                                                    System.out.println("helloworld");                                                }                                            };                                        }                                    }                                    //测试类                                    public class Test {                                        public static void main(String[] args) {                                    //      Outer.method().show();                                            //Outer7.method() :当前这个method方法是静态方法                                            //Outer.method().show(); //Outer.method()---->返回一个对象.show()                                            //由于show()方法是一个接口中的方法,返回值是一个接口类型                                            Outer7.method().show();                                        }                                    }                                               10)形式参数的问题:     1>形式参数是引用类型:        a>引用类型:是一个抽象类            b>形式参数是一个抽象类:此时这块需要的是该抽象类的子类对象   (抽象类多态11)形式参数是引用类型                                     1>形式参数是一个接口                                  2>形式参数的问题:                                                                            形式参数是基本类型,对实际参数没有影响(简单)                                                                            形式参数是引用类型:                                                                                    类(普通类)                                                                                        抽象类                                                                                    接口  12)返回值:    1>如果返回值基本类型:用对应的基本类型去接收数据即可!    2>引用类型:                        类(具体类): 需要的是该类的对象                        抽象类                        接口       3>如果返回值基本类型:用对应的基本类型去接收数据即可!4>引用类型:    类(具体类): 需要的是该类的对象    抽象类:那么返回需要的结果是需要当前抽象类的子类对象 抽象类多态    接口        接口和抽象类的区别:

    区别问题????
    A) 成员的区别
    1>成员变量:
    抽象类:既可以常量,也可以是变量
    接口:只能是常量,默认的修饰符:public static final
    2>构造方法:
    抽象类:有构造方法,无参/有参 (给对象进行初始化的)
    接口:没有构造方法
    3>成员方法:
    抽象类:可以有抽象方法,也可以有非抽象方法
    接口:只能是抽象方法 :默认的修饰符:public abstract

                                    B)类与类/类与接口关系的区别                                    1>类与类之间的关系:                                                继承关系,只支持单继承,不支持多继承,但是可以多层继承                                    2>类与接口的关系:                                                实现关系,一个类继承另一个类的同时,还可以实现多个接口...                                    3>接口与接口的关系:                                                是一种继承关系,既可以单继承,也可以多继承...                                                接口1 extends 接口2,接口3...                                C)设计原则的 区别                                    1>抽象类: 是有继承关系---->体现的是一种"is a"的关系   (A是B的一种或者B是A的一种)                                    2>接口:类和接口:实现关系--->体现的是一种" like a"的关系(扩展功能)  :跳高猫 像猫
    1. 继承的另外一个特点:
      1>在Java中,继承只支持单继承,不支持多继承(子类名 extends 父类名1,父类名2,...)
      2>但是,Java是可以支持多层继承...
      3>类和类之间的关系:继承关系
      4>类和接口之间的关系:实现关系
      7.继承中的注意事项:
      1>构造方法不能被继承,但是通过super关键字去访问
      2>私有的可以间接的去访问
      3>什么时候使用extends?
      假设:有一个A类
      class A{
      public void show1(){}
      public void show2(){}
      }

                                                  有一个B类                                                class B{                                                        public void show1(){}                                                        public void method(){}                                                }    4>按照正常的情况:发现A类和B类中有共同的show1()方法,根据继承的概念,---->让B类继承A类                                            class B extends A{                                                                public void method(){}                                                        }

      没有问题,但是继承了A类,show1(),show2()也继承过来了,可能show2()并不是我想要的功能;对于这种情况不要使用继承
      5>继承体现的是一种"is a"的关系:
      6>如果A是B的一种或者B是A的一种,这个可以使用继承!      
      在继承中,成员变量的名称问题
      注意事项:
      1>  当前子类继承父类的时候,子类和父类中的成员变量名称不一致的情况,非常简单,分别输出就可以了;
      2>当子类和父类中的成员变量名称一致的情况:
      a)先到子类的局部位置找,如果找到了,就输出
      b)没有找到,到子类的成员位置找,有就输出,
      c)在类的成员位置还没有找到,直接父类的成员位置找,有就输出
      d)如果还没有,就保存了,不存在这个变量
      二:
      关于继承的成员的问题?
      构造方法:
      1>子类继承父类,都会默认的访问父类的无参构造方法
      2>假设数据还没有被初始化完毕,所以应该先让父类进行初始化,然后             在让子类初始化--->分层初始化
      ?问题思考?
      如果父类的无参构造没有提供?怎么办?      
      解答:如果没有无参构造就会报错
      解决方法:1>提供一个无参
      2>子类通过super()对父类的有参进行访问对其进行初始化
      3>还可以在子类中通过this(),访问本类中的有参构造,间接的去访问父类带参构造
      4>子类的构造方法必须有一个(有参构造/无参构造),让父类进行初始化!
      三:
      继承中成员方法的问题?
      1)子类继承父类,访问成员方法名不一致的情况,分别调用!
      2)当子类中的成员方名和父类中的成员方法名一致的情况:
      3)先在子类的成员位置找,如果有就调用
      4)如果没有找到,在父类的成员位置找,有就调用
      四:
      关于继承的用法:
      1)父类中被private修饰的,是可以继承,但是只能间接的去访问私有的..
      2)父类被private修饰 成员属性,子类不不能直接访问的

      补充:
      1>子类继续父类,父类先进行初始化,然后子类进行初始化,这就是继承中分层初始化
      2>类名 对象名  = new 类名() ; 这句话,创建了对象,通过构造方法进行初始化(默认初始化,显示初始化)

      一:1)多态的概念:               多态就是事物在同一个时刻,体现出来的不同状态;2)多态的好处:  1>可以提供代码的复用性:继承保证    2>可以提高的代码的扩展性:由多态保证...  (父类的引用指向子类对象)3)多态的弊端:            1>父类引用指向子类对象,            2>通过父类的引用调用子类特有功能,不能调用....            3>不能访问子类特有功能  4>将父类的引用强制转换子类的引用  ,向下转型使用不当,会出现一个异常:属于运行时期异常:ClassCastException            二:               1):                 方法重写:    1>由于子类继承父类的时候,提供一摸一样的方法声明,然后会将父类该方法覆盖掉(重写,复写)   2>有时候(具体的需求),不需要子类重写父类的功能,针对这种情况,Java提供了一个关键字:final  最终的,终态的意思                2)                 final关键字:                    1> final:表示最终,终态(不能被更改的)                    2>它可以修饰类,那么该类不能继承                    3>它可以修饰成员方法,成员方法不能被重写                    4>它可以修饰变量,此时这个变量是一个常量                    5>常量的分类:                            字面值常量:                            字符串常量,字符常量,,,,        3)        1>final不仅可以修饰基本数据类型  2>还可以引用类型        3>如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...        4>如果final习俗的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以变得

      5>final的初始化时机在使用之前进行初始化,赋值(在构造方法之前赋值) (非静态的...)
      三:
      代码块叙述:
      1)用{}括起来的代码,统称为代码;
      根据其位置以及声明不同:分为??
      1>构造代码块:在一个类中的成员位置中,用{}括起来,
      作用:可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化.    在每次执行构造方法之前,先执行构造代码块.
      2>静态代码块:在一个类的成员位置,也是用{}包起来,但是他被static修饰
      作用:一般情况 它的作用给类进行初始化
      面试题?
      构造代码块,构造方法,静态代码的优先级?
      1>静态代码块>构造代码块>构造方法
      注意:
      1>静态代码:只能执行一次
      2>构造代码块在每次执行构造方法之前都会被执行.

                      -------------------------------------------------------------------------------------一:    抽象类概念:            Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类

      1)
      关键字:abstract  抽象的意思
      2)
      抽象类的特点:
      抽象类不能直接实例化!(不能创建对象)       接口也不能实例化
      3)关于抽象类:
      1>如果一个类中有抽象方法,那么这个类是一定是一个抽象类
      2.>抽象类必须有抽象方法吗? 抽象类中不一定都是抽象方法
      4)
      抽象类的子类:
      1>如果子类是抽象类,没有意义,因为都不能实例化,对象如何创建
      2>子类具体类,那么子类必须实现父类中的抽象功能.
      5)
      6)抽象类的成员特点:
      1>成员变量:
      可以是变量,也是一个常量
      2>构造方法:可以有无参,可以有有参,作用:给对象进行初始化的.
      3>成员方法:可以有抽象方法,还可以有非抽象方法...
      二:
      abstract和哪些关键字是冲突的,不能共有?
      1>abstract 和private
      2>abstract 和final
      3>abstract和static

      一:
      1) 接口的概念:
      接口:体现的是事务的扩展×××(额外动作,后天经过学习等等)
      2)接口格式(标识符:类,接口:见名知意)
      interface  接口名{
      //抽象功能
      public abstract void jump() ;

                                                              }    3)接口的特点:不能实例化    4)接口的子实现类:实现类 (具体的实现类)                                                                class 类名+impl implements 接口名{                                                                }

      5)接口的子类如果是抽象类:没有意义,不能实例化
      6)用处???                    
      接口多态(最多)
      抽象类多态(比较多)
      具体对象的创建(经常会使用)
      二:
      接口成员的特点:
      1)成员变量:是一个常量,不能更改,并且默认的修饰符
      public static final:
      2)构造方法:接口不存在构造方法
      3)成员方法:都是抽象方法
      默认的修饰符:public abstract
      4)  接口和接口之间的关系:继承关系                            
      三:
      实际开发中,接口作为形式参数的问题?
      1>如果形式参数是接口:
      传统的方式:  
      1>提供给接口的子实现类
      2>内部类的方式(不需要提供子实现类)
      四:
      1)内部类的问题:
      内部类:在B类内部定义A类,A类就属于B的内部类
      2)内部类访问外部类的特点:
      它可以直接访问外部了的成员,包括私有
      3)外部类如何访问内部类的成员?
      通过创建内部类对象的方式间接访问...
      4)内部类的分类:
      1>成员内部类:在外部类的成员位置
      2>局部内部类:在外部类的局部位置      
      5)成员内部类:
      1>可以直接外部类的成员,包括私有  
      2>外部类要访问内部类(非静态的内部类)的成员方法:
      3>格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象
      6)
      关于成员内部类的修饰符:
      1>private:  作用:保证数据的安全性!
      2>static修饰:可以把静态内部类看成是外部类的成员.
      3>特点:静态成员内部类访问外部类的数据,该数据必须static修饰                    7)局部内部类:
      1>可以访问外部类的成员包括私有...                
      2>在外部类的局部位置去访问内部类的show(),需要在局部位置创建内部了对象,通过对象去访问
      8)面试题?
      为什么这个局部变量必须用final修饰?  
      因为生命周期的问题,方法中的局部变量,方法结束后这个变量就要被释放掉,final保证这个变量始终指向一个对象.
      9)匿名内部类
      1>前提是有一个类或者接口
      2>这个类可以是具体类也可以是抽象类
      3>              new 类名或者接口名{
      方法重写();
      }

打开App,阅读手记
0人推荐
发表评论
随时随地看视频慕课网APP