精华内容
下载资源
问答
  • 抽象类修饰词
    2021-03-12 19:22:57

    1.final:最终的、不可改变的------单独应用的机率小

    1)修饰变量:变量不能被改变

    2)修饰方法:方法不能被重写

    3)修饰类:类不能被继承

    2.static final:常量,应用率高

    1)必须声明同时初始化

    2)通过类名点来访问,不能被改变

    3)建议:常量名所有字母都大写,多个单词用_分隔

    4)编译器在编译时直接将常量替换为具体的值,效率高

    3.抽象方法:

    1)由abstract修饰

    2)只有方法的定义,没有方法具体的实现(连{}都没有)

    4.抽象类:

    1)由abstract修饰

    2)包含抽象方法的类必须是抽象类,不包含抽象方法的类也可以声明为抽象类-----我乐意

    3)抽象类不能被实例化

    4)抽象类是需要被继承的,子类:

    4.1)重写所有抽象方法--------一般常规的用法

    4.2)也声明为抽象类----------不常用

    5)抽象类的意义:

    5.1)封装子类共有的属性和行为-------------代码复用

    5.2)为所有子类提供一种统一的类型---------向上造型

    5.3)可以包含抽象方法,为所有子类提供统一的入口每个子类的实现不同,但入口是一致的

    5.接口:

    类和类-----------------继承extends

    接口和接口-------------继承extends

    类和接口---------------实现implements

    1)是一个标准、规范------------制定方

    遵守了这个标准,就能干某件事------------API后

    2)接口是一种数据类型(引用类型)

    3)由interface定义

    4)只能包含常量和抽象方法

    5)接口不能被实例化

    6)接口是需要被实现的,实现类: 必须重写接口中的所有抽象方法

    7)一个类可以实现多个接口,用逗号隔开,若又继承又实现时,应先继承后实现

    8)接口可以继承接口

    接口是完全抽象的抽象类-----正确的

    示例:

    new Inter1(); //编译错误

    Inter1 o1; //正确

    interface Inter1{

    public static final int NUM = 5;

    public abstract void show();

    int COUNT = 5; //默认public static final

    void test(); //默认public abstract

    double PI; //编译错误,常量必须声明同时初始化

    void say(){} //编译错误,抽象方法不能有方法体

    }

    我是初学者,如有更新不好的,欢迎这位大神指出,谢谢大家!

    更多精彩以后更新,转载注明!

    更多相关内容
  • 作用:给成员变量初始化 提取所有构造方法中重复的代码 4.1用法 { } 5.final关键字 可修饰对象:/成员变量/局部变量/成员方法 注意事项: 使用final修饰词,则成员变量一定要初始化 static final修饰变量,变量名全...

    前言

    提示:这里只有冰冷的知识点,和博主冰冷又绝望的每日感言


    前言

    提示:这里只有冰冷的知识点。


    一、抽象类

    1.1抽象类定义(abstract修饰的类)

    定义
    抽象⽅法:没有⽅法体的⽅法。
    抽象类:包含抽象⽅法的类。

    1.2abstract使用格式

    1.2.1抽象方法

    使用 abstract 关键字修饰方法,该⽅法就成了抽象方法,抽象方法只包含⼀个方法名,而没有方法体
    ⽅法体。

    定义格式:
    在这里插入图片描述

    1.2.2抽象类

    如果⼀个类包含抽象⽅法,那么该类必须是抽象类

    定义格式:
    在这里插入图片描述

    1.3 使用抽象的注意事项

    1.3.1抽象类:

    1. 使用abstract修饰的类,叫做抽象类

    2. 一个类可以存在多个抽象方法

    3. 抽象类不能用new对象(不能创建对象),就是不能实例 化,只能通过子类调用
    (理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。)

    4. 如果子类补充些父类的抽象方法,就必须自己变成抽象方法供想要使用的子类

    5. 抽象类也可以有构造方法,为了方便子类使用,初始化父类成员。
    (理解:⼦类的构造⽅法中,有默认的super(),需要访问⽗类构造⽅法。)

    6. 抽象类中,不一定包含抽象方法,但是有抽象方法一定是抽象类
    (理解:未包含抽象⽅法的抽象类,⽬的就是不想让调⽤者创建该类对象,通常⽤于某些特殊的类结构设计。)

    1.3.2 抽象方法:

    1. 使用abstract修饰的方法

    2. 抽象方法没有方法体;void add();

    3. 成员变量不可能是抽象的,因为都是具体的类型。

    1.4 抽象的使用

    继承抽象类的⼦类必须重写父类所有的抽象方法。否则,该⼦类也必须声明为抽象类。最终,必须有⼦类实现该⽗类的抽象⽅法,否则,从最初的⽗类到最终的⼦类都不能创建对象,失去意义。


    二、权限修饰符

    2.1 权限修饰符/访问修饰符一览

    1. public:公共的
    2. protected:受保护的
    3. private:私有的
    4. default(friendly):默认的(不加修饰符时自动使用)

    2.2 不同权限的访问能力

    在这里插入图片描述

    在这里插入图片描述


    三.static关键字

    3.1概述

    关于static关键字的使用,它可以用来修饰的成员变量和成员方法,被修饰的成员是属于类的,而是不是单单是属于某个对象的。也就是说,既然属于类,就可以不靠创建对象来调用了。
    在这里插入图片描述可以修饰:成员方法/成员变量/代码块/内部类

    3.2 定义和使用格式

    3.2.1类变量

    当 static 修饰成员变量时,该变量称为类变量。该类的每个对象都共享同⼀个类变量的值任何对象都可以更改该类变量的值也可以在不创建该类的对象的情况下对类变量进行操作
    在这里插入图片描述
    注意事项:

    1. 成员变量属于对象(通过对象名调用stu.name),静态成员变量属于类(通过类名调用Student.name),静态成员变量是所有实例化对象所共享的,每次修改都会修改所有对象的值。
    2. 静态成员变量只加载一次(和类加载一样(放在方法区)),随着类加载到方法区,都是在new以前就加载好了
    3. 用类名.变量名调用
    4. 静态块和静态成员变量的加载顺序与他们的位置有关,并没有严格的限制;

    3.2.2静态方法

    static 修饰成员方法时,该⽅法称为类⽅法。静态⽅法在声明中有 static ,建议使⽤类名来调⽤可以不需要创建类的对象(想创建也行)。调⽤⽅式非常简单。
    在这里插入图片描述
    注意事项

    1. 静态方法可以直接访问类变量和静态方法。
    2. 静态方法不能直接访问普通成员变量或成员⽅法。反之,成员⽅法可以直接访问类变量或静态方法。
    3. 静态方法中,不能使用this关键字。
    4. 静态成员方法中不能调用非静态的成员变量,也不能调用非静态的成员方法,但是普通成员变量可以调用静态成员变量(类加载已完毕所以可以调用)
    5. 用类名.方法名调用
    6. 如果父类中含有一个静态方法,且在子类中也含有一个返回类型、方法名、参数列表均与之相同的静态方法,那么该子类实际上只是将父类中的该同名方法进行了隐藏,而非重写。换句话说,父类和子类中含有的其实是两个没有关系的方法,它们的行为也并不具有多态性。
    7. 静态方法是可以重载的
    8. 静态方法首先执行,先父类静态代码块,后子类静态代码块,其次,执行构造代码块和构造方法,先父类代码块+构造方法,后子类,最后,执行子类的方法。
      在这里插入图片描述

    3.2.3静态代码块

    **定义:**定义在成员位置,使⽤static修饰的代码块{ }
    特点:

    1. 最先执行,且无论new几次都(或者不new)只做一次加载
    2. 优化代码,只执行一次
    3. 静态代码块可以有无数个
    4. 不能调用普通成员变量和成员方法
      位置:类中⽅法外。
      执行:随着类的加载⽽执行且执行⼀次,优先于main⽅法和构造⽅法的执行
      格式:
      在这里插入图片描述
      **注意事项:**静态代码块的特点是随着类的加载而执行,而且只执行一次!

    4.代码块

    代码块:
    1.执行在构造方法之前
    2.作用:给成员变量初始化
    提取所有构造方法中重复的代码

    4.1用法

     { }
    

    5.final关键字

    可修饰对象:类/成员变量/局部变量/成员方法
    在这里插入图片描述
    在这里插入图片描述
    注意事项:

    1. 使用final修饰词,则成员变量一定要初始化
    2. static final修饰变量,变量名全大写 static final int NUM=123;
    3. 重写被 final 修饰的⽅法,编译时就会报错。
    4. 修饰成员变量时,赋值有两种方式,直接赋值和构造方法初始化赋值

    总结

    抽象类是多态中常用的,记住抽象类和接口都可以有默认方法,不是非得只有抽象方法,权限修饰符建议配合方法重写食用更佳,static和final这俩关键字的适用范围以及修饰对象的适用范围一定要记牢了,比如普通方法不能初始化已经定义的static final修饰的变量,因为他优先级太高了,在类加载之前都挊进去了,至于接口和多态放下文了,累了,歇了。

    展开全文
  • 方法的重载(overload)与重写(override) 概念:  重载: 在同一个中,方法名相同,参数列表不同  重写: 子类重写父类的方法,方法名... 修饰词可以相同,或者权限比父类方法的权限大 访问权限控制修饰词 修...

    方法的重载(overload)与重写(override)

    概念:

         重载:  在同一个类中,方法名相同,参数列表不同

         重写:    子类重写父类的方法,方法名相同,参数列表相同

                     返回值类型可以相同,也可以是父类方法的返回值类型的子类

                     修饰词可以相同,或者权限比父类方法的权限大

    访问权限控制修饰词

    修饰的成员变量和方法

                                 本类中      同一包下     子类        其他

        public                true          true              true         true

        protected          true          true              true

        default              true          true

        private              true   

        

    final:

        (1)修饰类:不能被继承,意义在 减少随意扩展功能的可能性,减少对系统的危害

        (2)修饰变量:只能进行初始化,不能再被赋值

                成员变量: 初始化的时机有两种

                         声明时同时初始化

                         在构造器中初始化  

                局部变量:使用前初始化即可

        (3)修饰方法: 不能被重写,意义在于: 可以避免某些子类"不经意"的重写       

     

    static:英文含义:静态

    1、修饰成员变量

       (1)修饰的成员变量,不属于对象的数据结构

       (2)静态变量属于类的,通常使用类名去调用

       (3)静态变量与类的信息一起存在方法区中,只存在一份,是对象的公共资源

    2、修饰方法

       (1)通常的方法都是与具体对象有关系,即对象的方法(行为)

       (2)如果是static方法则与对象毫无关系,是类的方法,通常用类名去调用,常常与参数有关系

       (3)static方法内因为无法使用this关键字,因此不能直接访问非静态成员变量和方法

       (4)static方法的作用一般都用于设计成"工具方法"和"工厂方法"           

        如:   Arrays.sort(数组名);

               Math.random();

               Math.sqrt(参);

               Math.abs(参);

               Math.sin(参数);

     3、static修饰代码块

           static{

             代码逻辑

           }

                  静态块存储在方法区中,只加载一次,与对象无关。

                 执行时机为加载类的信息期间,可以理解为在实例化之前

          作用:通常用于加载程序中所需要的静态资源:如:图片,音频,视频等       

               非静态代码块与静态代码块,成员变量,方法都是类的成员

         {

         }

       运行时机:在实例化之前执行,每次实例化之前都会执行一次      

     

    常量

         一般都是一些特殊值。

         一般都使用成员变量,修饰词为public static final

          声明时必须初始化

         命名规则: 字母全都大写

           如:   Math.PI

     

    设计模式之单例模式

              需求:在程序中的任何地方,我们想要获取某一个类的唯一对象。

              我们称之为类的单例   

         Singleton

         (1)提供一个私有的静态的本类型的成员变量

         (2)构造器私有化

         (3)提供公有的静态的方法获取本类中创建的实例。

          饿汉写法:  加载期间就实例化对象

          public class Singleton{

          private static Singleton instance = new Singleton();

          private Singleton(){}

          public static Singleton getInstance(){

          return instance;

          }

         }

         懒汉写法:  调用方法时才创建对象

         public class Singleton{

          private static Singleton instance ;

          private Singleton(){}

          public static Singleton getInstance(){

          if(instance ==null){

          instance = new Singleton();

          }

          return instance;

          }

         }                           

     

    抽象类:

       因为继承的关系,子类的功能可以越来越具体,相对来说,父类

      更加一般化,通用化。因为父类封装了子类的共同行为,所以,

     在定义时,我们可以定义方法的逻辑。有的时候,在父类中无法完成

     子类的功能需求,此时,不如不写,即不写方法体,代码简单化。

     但是此方法必须使用abstract修饰,那么此类型也必须使用abstract

     修饰,即抽象类

     

    1、抽象方法与抽象类

      1)用abstract修饰的方法,不需要写方法体,但是得用分号来结尾

      2)有抽象方法的类,必须使用abstract声明(修饰)

    2、抽象类不能实例化

      1)  抽象类不能创建对象,没有意义

      2)  抽象类可以提供构造器

      3)  抽象类中可以没有抽象方法

      4)  abstract和final不能同时修饰一个类型

    3、继承抽象类

      1)若一个类继承了抽象类,那么这个类必须重写(实现)抽象类的所有抽象方法

      2)若一个类没有实现抽象类的所有抽象方法, 那么这个类必须使用abstract修饰

    4、抽象类的意义:

       1)给不同的子类定义一个父类

       2)抽象类可以封装子类的共同特征与共同行为

       3)虽然子类方法可能有不能的实现逻辑,但是

             方法的定义一致。

     

    静态方法不能直接访问非静态成员变量和方法



    非静态方法用对象调用,静态方法用类名调用

     

    单例模式

     

    加载类的信息期间执行代码块;

    加载类的信息期间执行静态代码块;

    每次实例化对象之前执行非静态代码块

    展开全文
  • 主要介绍了java 抽象类的实例详解的相关资料,希望通过本大家能理解掌握这部分内容,需要的朋友可以参考下
  • 是构造对象的模板,每个对象都是通过 new 语句创建的。通过关键字 class 定义一个的结构:类名(ClassName)通常首字母大写,多个单词用驼峰式(CamelCase)命名法。一个可以定义多个属性,多个构造函数,...

    Java 是个纯面向对象语言,不支持过程式编程,所有操作都是基于对象。

    一、类

    类是 Java 中的一种引用数据类型,引用数据类型值都存储在堆中。类是构造对象的模板,每个类对象都是类通过 new 语句创建的。通过关键字 class 定义一个类,类的结构:

    2465dd5aaed1f0f5605c8ae167a4142f.png

    类名(ClassName)通常首字母大写,多个单词用驼峰式(CamelCase)命名法。一个类可以定义多个属性,多个构造函数,多个行为方法。类和类中定义的属性方法都需要有访问权限控制,不受限的访问将会导致程序混乱,不可控制。下面是 Java 语言中定义的修饰符,如下(继承类也叫子类):

    d349a28e5a91b4968cfb8dae43ba546e.png

    说明:

    friendly:缺省值,没有修饰词。当 friendly 修饰类时,可以被本包中的类继承;当修饰方法时,继承类不能访问。

    public:公共的,所有类都能访问。

    protected:受保护的,同包中本类和继承类可以访问,继承类访问的是其继承过来的方法,不能访问基类的 protected 方法。不同包中继承类不可见。

    private:私有的,只有本类可以访问。

    其它修饰词很好理解,这里看下 protected 的示例:

    package p1;public class Base{protected void test(){}}---------------------------package p1;public class Son1 extends Base{}---------------------------package p11;import p1.Base;public class Son11 extends Base{}---------------------------// 测试package p1;import p11.Son11;public class Main{public static void main(String[] args){Son1 s1 = new Son1();Son11 s11 = new Son11();s1.test();s11.test();s1.clone(); // 报错,不能访问 Base 类中的 protected 方法s11.clone(); // 报错,不能访问 Base 类中的 protected 方法}}---------------------------package p11;import p1.Son1;public class Main{public static void main(String[] args){Son1 s1 = new Son1();Son11 s11 = new Son11();s1.test(); // 报错,不在同一包中,不能访问 protected 方法。下同s11.test(); // 报错s1.clone(); // 报错s11.clone(); // 报错}}

    除了访问控制修饰符,Java 还定义了一些非访问控制修饰符:

    b38b430035398fc06fbe5962c4326745.png

    说明:

    static:静态方法属于类,不需要构造对象访问。

    静态变量:也称类变量,无论实例化多个是个对象,静态变量只有一份数据,所以当静态变量值改变后,所有对象实例访问该静态变量都是新值。

    静态方法:方法中不能访问非静态变量。main 方法也是一个静态方法,不对任何对象进行操作。每个类可以有一个 main 方法,这样可以对类进行单元测试。

    final:表示最终状态。final 类不能被继承。final 方法可以被继承,但是不能被子类修改。final 属性不能被修改,所以必须显式的赋初始值,final 通常和 static 一起使用来定义常量。

    abstract:抽象类不能用来实例化,抽象类只是对一些公用行为进行抽象,等待继承类进行扩充。抽象类可以包含非抽象方法,含有抽象方法的类必须声明为抽象类,抽象方法必须在字类中完善。abstract 不能和 static、final 同时使用。

    synchronized:修饰的方法同一时间只能被一个线程访问。

    transient:当对象被序列化时会跳过 transient 修饰的属性,一些敏感信息就不会被序列化,这样当对象被反序列化后,transient 修饰的属性就不会被读取到,信息更加安全。

    volatile:每次线程访问时,都重新从共享内存中读取值,这样每次读取被 valatile 修饰的变量值都是最新的。

    二、构造函数/方法

    Java 规定与类同名(区分大小写)的方法就是该类的构造方法。一个类可以定义多个构造函数,只要保证方法签名不同即可。方法签名指包括方法修饰符、方法名称和方法入参在内的所有元素(不包括方法返回值),只要有一项不同则方法签名就不同。如果类没有定义构造函数,则系统会默认分配一个构造函数,属性值被设置成默认值。构造函数具有以下特点:

    1) 构造函数必须与类名相同。2) 构造函数没有返回类型,也不能设置 void 返回类型。构造函数用于构建对象,所以不需要返回值。3) 构造函数的修饰词必须是 public。4) 一个类可以定义多个构造函数,只要构造函数签名不同即可。

    定义一个 Person 类,多个构造函数:

    c34de17b08ed3fbe74767ec7a7d6c967.png

    这里构造器定义了多个,每个构造方法的入参不同。相同的方法名,不同的参数称为方法重载。给成员变量赋值时可以通过 this 关键字访问。

    如果提供了多个构造器,那么在一个构造其中可以通过 this 访问另一个构造器,如:

    d98fb5ffcdcb9b6a11d032b032e27221.png

    初始化块(initializationblock),由 {} 包括的代码块,还可以通过 static 关键字修饰为静态初始化块,块代码可以有多个。创建对象时会先执行静态初始化块中代码,再执行初始化块中的代码,最后执行构造方法。如:

    091d75db78bab836332afca7f78d75db.png

    Java 有自动垃圾回收器,不需要人工释放内存, 所以 Java 没有析构方法。对象资源需要被释放时可以定义 close 方法,来手动是否资源,close 方法被调用后对象关联的资源会被回收。

    三、类设计技巧

    类的设计通常应该遵循以下一些技巧:

    1. 保证数据私有,避免破坏封装性,导致数据被乱改。

    2. 一定要对数据进行初始化 。

    3. 不是所有的域都需要独立的域访问器和域更改器。

    4. 将职责过多的类进行分解。

    5. 类名和方法名要能够体现它们的职责。

    6. 优先使用不可变的类。

    0f4488e85bf8896435bbf0948c4b8331.png

    展开全文
  • java类修饰词和内部类详解控制属性:同一类内 同一包内 子类 所有类public 可 可 可 可protected 可 可 可 不可default 可 可 不可 ...
  • 接口的修饰符默认是 public abstract interface 接口的方法默认是public abstract 接口的变量默认是public static final 这些都可以省略不写 转载于:https://www.cnblogs.com/xiaobo520/p/10588611.html...
  • 深入理解Java抽象类

    2020-08-24 20:51:30
    主要介绍了Java抽象类的相关资料,帮助大家更好的理解和学习Java,感兴趣的朋友可以了解下
  • 本文主要介绍了C#中抽象类与接口的区别。具有很好的参考价值。下面跟着小编一起来看下吧
  • 在本篇文章里小编给大家整理了关于C#中成员的定义的修饰关键词知识点内容,有需要的朋友们可以参考下。
  • Java的抽象类和接口

    2021-03-09 18:10:32
    抽象类的规则:抽象类必须使用abstract修饰符来修饰抽象类不能被实例化,无法使用new关键字来创建实例,即使抽象类中没有抽象方法,也不可以创建实例。只能当做父类被其他子类继承。抽象类可以包...
  • 文章目录前言一、抽象类1.抽象类的概念2.抽象类的定义3.抽象类的注意事项4.抽象类的意义二、接口1.接口概念1.接口的定义2.接口中的方法和成员变量3.default关键字4.接口的使用5.实现多个接口6.接口的拓展7.接口使用...
  • 本文主要列举Java语言中抽象类和接口的区别,不详细讲解接口和抽象类抽象类和接口.png不知道大家有没有注意到,凡是问到某两个事物的区别,都会首先介绍它们的共同点,然后再介绍它们的区别,我们这里也不例外:1、...
  • Java基础——抽象类

    千次阅读 2021-03-22 21:03:43
    本编文章旨在对 Java 中的 抽象类 做总结一、抽象类1. 定义一个抽象类// 抽象类public abstract class Shape {// 可以有属性// private String color;// 可以有普通方法/* public void setColor(String...
  • 2022.8.5 一、方法、变量的修饰词,private、默认、protected、public的区别 private修饰后只能自己的方法访问; 默认无修饰词则还能给同包的子方法访问; protected修饰的则能被不同包的子类访问; public修饰的则...
  • 抽象是Java语言一个很重要的特性,可以通过两种方式来体现,其中一种方式就是抽象类。在Java类中,如果一个类没有包含足够的信息来描绘一个具体的对象,那么这样的类就是抽象类。本文根据对Java面向对象的学习理解,...
  • 抽象类语法规则:首先我们来看一段代码:class Shape{public void draw(){}}class Cycle extends Shape{@Overridepublic void draw(){System.out.println("⚪");}}class Rect extends Shape {@Overridepublic void ...
  • java基础之抽象类、接口 学习过抽象类和接口后,这两个概念一直傻傻分不清楚,抽象类和接口声明的方法都不实现,有时候对它们的...被abstract修饰类成为抽象类,被abstract修饰方法,称之为抽象方法。抽象方法只能...
  • **一、Android 抽象类、抽象方法**抽象方法:类的成员方法,只有声明,没有实现,把实现交给子类。抽象类:含有抽象方法的类。1.有抽象方法的类一定是抽象类,但抽象类里可以没有抽象方法(当然也可以抽象方法+一般...
  • 接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大...
  • 使用抽象方法即可满足该要求:抽象方法是只有方法签名,没有方法实现的方法抽象方法和抽象类抽象方法和抽象类必须使用abstract修饰符来定义,有抽象方法的类只能被定义成抽象类抽象类里可以没有...
  • java抽象类和接口详解

    千次阅读 2021-03-01 10:24:12
    抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似,甚至可以互换,但是也有区别。一、抽象类我们都知道在面向...
  • JAVA的修饰词(3)----abstract 抽象类

    千次阅读 2017-02-12 15:35:35
    1.引入概念:狼和狗,两个类,抽取他们所属的共性:犬科。 犬科都有吼叫行为,具体是汪...定义了抽象函数的类也要被abstract修饰,即抽象类。 用法和继承类似。 举例:abstract class 犬科(){ abstract void 叫();
  • 抽象类知识点

    2021-12-13 20:56:08
    抽象类 面向对象编程的核心就是面向抽象编程,一般在开发过程中依赖抽象,不依赖具体 public class A{ public void pp(Pig pig){}//如果使用具体类,则不具备灵活性。如果需要Cat,则只能修改源代码 } public ...
  • 1、抽象方法: 1-1、由关键字abstract修饰 1-2、只有方法定义,没有方法实现(没有方法体) public abstract void fn();...2-5、抽象类需要被继承,子类必须重写抽象类中的所有抽象方法,子类也
  • Java中的继承、抽象类

    2021-08-19 22:58:26
    继承以后 子类也可以在本当中声明自己的属性和方法 也可以重写父类的方法 5.子类只能继承一个父类 但是java可以多层继承 爷爷--父亲--儿子 6.继承的优点 和缺点 优点: 提高了代码的复用性 提高了代码的可...
  • 抽象类、抽象函数/抽象方法详解

    千次阅读 2018-06-13 23:55:23
    抽象类、抽象函数/抽象方法详解 ...抽象类 —— 修饰词 : abstract 抽象父类中的 抽象函数 是不完整的,只有方法名和参数,并没有方法体 任何继承于抽象类的子类,都需要重 写父类(抽象类) 中的所有 抽象函数/抽象方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,346
精华内容 6,938
关键字:

抽象类修饰词