精华内容
下载资源
问答
  • private能否修饰顶层类
    千次阅读
    2011-10-16 11:22:02
     

     对于顶层类(外部类)来说,只有两种修饰符:public和默认(default)。

    因为外部类的上一单元是包,所以外部类只有两个作用域:同包,任何位置。

    因此,只需要两种控制权限:包控制权限和公开访问权限,也就对应两种控制修饰符:public和默认(default)。

    但是private可以修饰class的,只不过该类不能使顶层类,可以是内部类
    内部类的上一级是外部类,那么对应的有四种访问控制修饰符:本类(private),同包(default),父子类(protected),任何位置(public)。
    当一个内部类使用了private修饰后,只能在该类的外部类内部使用

    更多相关内容
  • private不能用于修饰顶层类: 原因: 对于顶层类(外部类)来说,只有两种修饰符:public和默认(default)。 因为外部类的上一单元是包,所以外部类只有两个作用域:同包,任何位置。 因此,只需要两种控制权限:包控制...

    private不能用于修饰顶层类:

    原因: 对于顶层类(外部类)来说,只有两种修饰符:public和默认(default)。
    因为外部类的上一单元是包,所以外部类只有两个作用域:同包,任何位置。
    因此,只需要两种控制权限:包控制权限和公开访问权限,
    也就对应两种控制修饰符:public和默认(default)。
    但是private可以修饰class的,只不过该类不能使顶层类,
    可以是内部类 内部类的上一级是外部类,那么对应的有四种访问控制修饰符:本类(private),同包(default),父子类(protected),任何位置(public)。
    当一个内部类使用了private修饰后,只能在该类的外部类内部使用

    展开全文
  • 表中的类仅限于顶层类,而不包括内部类。内部类是指定义在类或方法中的类。 修饰符 类 成员方法 构造方法 成员变量 局部变量 abstract Y Y - - - static - Y - Y - pubic Y Y Y Y - protected - Y Y Y ...

    Java基础知识笔记-5-Java语言中的修饰符

    5 Java语言中的修饰符

    表中的类仅限于顶层类,而不包括内部类。内部类是指定义在类或方法中的类。

    修饰符成员方法构造方法成员变量局部变量
    abstractYY---
    static-Y-Y-
    pubicYYYY-
    protected-YYY-
    private-YYY-
    finalYY-YY

    从上表可以看出:修饰顶层类的修饰符包括:abstract,public,final,而static,protected,private不能修饰顶层类。成员方法和成员变量可以有多种修饰符,而局部变量只能用final来修饰。

    1 访问控制修饰符

    面向对象的基本思想之一是封装实现细节并且公开接口。java语言采用访问控制符来控制类,以及类的方法和访问权限,从而向使用者只暴露接口,但隐藏实现细节,访问控制分四种级别:

    • 公开级别:用public修饰,对外公开
    • 受保护级别:用protected修饰,向子类及同一个包中的类公开
    • 默认级别:没有访问控制修饰符,向同一个包中的类公开
    • 私有级别:用Private修饰,只有类本身可以访问,不对外公开
    访问级别访问控制修饰符同类同包子类不同的包
    公开publicYYYY
    受保护protectedY-Y-
    默认YY--
    私有PrivateY---

    成员变量,成员方法和构造方法可以处于4个访问级别中的一个:公开,受保护,默认或者私有。顶层类只可以处于公开或默认访问级别,因此顶层类不能用private和protected来修饰,以下代码会导致编译错误:

    private class Sample{...};

    2 abstract 修饰符

    如果自下而上在类的继承层次结构中上移,位于上层的类更具有通用性,甚至可能更加抽象。从某种角度看,祖先类更加通用,人们只将它作为派生其他类的基类,而不作为想使用的特定的实例类。例如,考虑一下对Employee类层次的扩展。一名雇员是一个人,一名学生也是一个人。下面将类Person和类Student添加到类的层次结构中。

    为什么要花费精力进行这样高层次的抽象呢?每个人都有一些诸如姓名这样的属性。学生与雇员都有姓名属性, 因此可以将getName法放置在位于继承关系较高层次的通用超类中。

    现在,再增加一个getDescription方法,它可以返回对一个人的简短描述。例如:

    an employee with a salary of $50,000.00
    a student majoring in computer science

    在Employee类和Student类中实现这个方法很容易。但是在Person类中应该提供什么内容呢?除了姓名之外,Person类一无所知。当然,可以让Person.getDescription()返回一个空字符串。然而,还有一个更好的方法,就是使用abstract关键字,这样就完全不需要实现这个方法了。

    public abstract String getDescription();
    // no implementation required

    为了提高程序的清晰度,包含一个或多个抽象方法的类本身必须被声明为抽象的。

    public abstract class Person {
        public abstract String getDescription();
    }

    除了抽象方法之外,抽象类还可以包含具体数据和具体方法。例如,Person类还保存着姓名和一个返回姓名的具体方法。

    public abstract class Person {
        private String name;
        public Person(String name) {
            this.name = name;
        }
        public abstract String getDescription();
            public String getName() {
                return name;
        }
    }

    抽象方法充当着占位的角色,它们的具体实现在子类中。扩展抽象类可以有两种选择。一种是在抽象类中定义部分抽象类方法或不定义抽象类方法,这样就必须将子类也标记为抽象类;另一种是定义全部的抽象方法,这样一来,子类就不是抽象的了。

    例如,通过扩展抽象Person类,并实现getDescription方法来定义Student类。由于在Student类中不再含有抽象方法,所以不必将这个类声明为抽象的。

    类即使不含抽象方法,也可以将类声明为抽象类。

    抽象类不能被实例化。也就是说,如果将一个类声明为abstract,就不能创建这个类的对象。例如,表达式

    new Person("Vinee Vu")

    是错误的,但可以创建一个具体子类的对象。

    需要注意,可以定义一个抽象类的对象变量,但是它只能引用非抽象子类的对象。例如,

    Person p = new Student("Vinee Vu", "Economics");

    这里的p是一个抽象类Person的变量,Person引用了一个非抽象子类Student的实例

    abstract修饰符可用来修饰类和成员方法;

    • 用abstract修饰的类表示抽象类,抽象类位于继承树的抽象层,抽象类不能被实例化,既不允许创建抽象类本身的实例。
    • 用abstract修饰的方法表示抽象方法,抽象方法没有方法体,抽象方法用来描述系统具有什么功能,但不提供具体的实现,没有用abstract修饰的方法称为具体方法,具体方法具有方法体。

    abstract类和abstract方法

    用关键字abstract修饰的类称为abstract类(抽象类)

    如:

    abstract class A {
    }

    用关键字abstract修饰的方法称为abstract方法(抽象方法),例如

    abstract int min(int x,int y);

    对于abstract方法,只允许声明,不允许实现(没有方法体),而且不允许使用abstract和final同时修饰一个方法和类。

    使用abstract修饰符需要遵守以下语法规则

    1.抽象类中可以没有抽象方法,但包含了抽象方法的类必须被定义为抽象类。如果子类没有实现父类中所有的抽象方法,那么子类也必须定义为抽象类,否则编译会出错。

    2.没有抽象静态方法,static和abstract关键字不可在一起使用。

    3.抽象类中可以有非抽象的构造方法,创建子类的实例可能会调用这些构造方法。抽象类不能被实例化,然而可以创建一个引用变量,其类型是一个抽象类,并让他引用非抽象的子类的一个实例。

    4.抽象类及抽象方法不能被final修饰符修饰,abstract修饰符与final修饰符不能连用,因为抽象类只允许创建其子类,他的抽象方法才能被实现,并且只有他的具体子类才能被实例化,而用final修饰的类不允许拥有子类,用final修饰的方法不允许被子类方法覆盖,因此两者连用,会自相矛盾。

    抽象类的一个重要特征是不允许实例化,比如苹果香蕉是具体类,而水果是抽象类一样。在自然界中并不存在水果类本身的实例,只存在它的具体子类的实例:

    Fruit fruit=new Apple();

    在继承树上,总可以把子类的对象看作父类的对象。当父类是具体类,父类的对象包括父类本身的对象,以及所有具体子类的对象;当父类是抽象类,父类的对象包括所有具体子类的对象,因此,所谓的抽象类不能实例化,是指不能创建抽象类本身的实例,尽管如此,可以创建一苹果对象,并把它看作是水果对象。

    5.抽象方法不能被private修饰符修饰,这是因为如果方法是抽象的,表示父类只申明具备某种功能,但没有提供实现,这种方法有待于某个子类去实现它,父类中的abstract方法必须让子类是可见的。否则,在父类中声明一个永远无法实现的方法是无意义的,假如java允许把父类的方法同时用abstract和private修饰,那就意味着在父类中声明一个永远无法实现的方法,所以在java中不允许出现这一情况。

    注意:abstract类也可以没有abstract方法。

    如果一个abstract类是abstract类的子类,它可以重写父类的abstract方法,也可以继承这个abstract方法。

    abstract类的子类如果不是abstract的,那么它就可以被实例化,这会导致执行该abstract类的构造器,进而执行其用于实例变量的域初始化器。


    3 final修饰符

    final具有不可改变的含义,它可以用来修饰非抽象类,非抽象对象成员,和变量。

    • 用final修饰的类不能被继承,没有子类
    • 用final修饰的方法不能被子类的方法覆盖
    • 用final修饰的变量表示常量,只能被赋一次值

    final不能用来修饰构造方法,因为“方法覆盖”这一概念仅适用于类的成员方法,而不适用于类的构造方法,父类的构造方法和子类的构造方法之间不存在覆盖关系,因此用final修饰构造方法是无意义的。父类中的private修饰的方法不能被子类的方法覆盖,因此private类型的方法默认是final类型的。

    将方法或类声明为final主要目的是:确保它们不会在子类中改变语义。例如,Calendar类中的getTime和setTime方法都声明为final。这表明Calendar类的设计者负责实现Date类与日历状态之间的转换,而不允许子类处理这些问题。同样地,String 类也是final类,这意味着不允许任何人定义String的子类。换言之,如果有一个String的引用,它引用的一定是一个String对象,而不可能是其他类的对象。

    3.1 final类

    继承关系的弱点是打破封装,子类能够访问父类的实现细节,而且能以方法覆盖的方式修改实现细节,在以下情况,可以考虑把类定义为final类型,使得这个类不能被继承。final类中的所有方法自动地成为final方法。

    • 不是专门为继承而设计的类,类本身的方法之间有复杂的调用关系,假如随意创建这些类的子类,子类有可能会错误的修改父类的实现细节。
    • 处于安全的原因,类的实现细节不允许有任何改动
    • 在创建对象模型时,确信这个类不会再被扩展

    例如,JDK中的java.lang.String类被定义为final类:

    public final class String {
        ···
    }

    如果其他类继承String类,就会导致编译错误

    3.2 final方法

    在某些情况下,处于安全的原因,子类不允许子类覆盖某个方法,此时可以把这个方法声明为final类型。例如在java.lang.Object类中,getClass()方法为final类型,而equals()方法不是final类型的:

    public class Object {
        public final Class getClass() {
            ...
        }
        public boolean equal(Object o) {
            ...
        }
    }

    所有Object方法都可以覆盖equals()方法,但不能覆盖getClass()方法。否则就会导致编译错误。

    3.3 final变量

    用final修饰的变量表示取值不会改变的常量。

    例如在java.lang.Integer类中定义了两个常量:

    public static final int MAX_VALUE=2147483647;
    public staric final int MIN_VALUE=-2147483647;

    final变量具有以下特性:

    1.final修饰符可以修饰静态变量,实例变量和局部变量,分别表示静态变量,实例变量和局部变量。

    2.在成员变量的初始化那一节,曾经提到类的成员变量可以不必显式初始化,但是这不适用于final类型的成员变量。final类型的成员变量必须显式初始化,否则会导致编译错误。

    例如:

    public class Sample {
        static final int a=1;
        static final int b;
        static {
            b=1;//合法
        }
    }

    3.final变量只能赋一次值

    例如:

    public class Sample {
        private final int var1=1;
        public Sample() {
            var1=2;  //错误,不允许改变实例变量的值
        }
            public void method(final int param){
            final int var2=1;
            var2+=;  //编译错误
            param++;  //编译错误,不允许改变final类型参数的值
        }
    }

    以下Sample类的var1实例常量分别在Samlpe()和Sample(int x)这两个构造方法中初始化,这是合法的。因为在创建Sample对象时,只会执行一个构造方法,所以var1实例常量不会被初始化两次:

    class Sample {
        final int var1;//定义实例常量
        final int var2=0;//定义并初始化var2实例常量
        Sample() {
            var1=1;//初始var1化实例常量
        }
        Sample(int x) {
            var1=x;//初始化var1实例常量
        }
    }

    4.如果将引用类型的变量用final修饰,那么该变量只能始终引用一个对象,但可以改变对象的内容,例如:

    public class Sample {
        public int var;
        public Sample(int var) {
            this.var=var;
        }
        public static void main(String args[]){
            final Sample s=new Sample(1);
            s.var=2;//合法,修改引用变量s所引用的Sample对象的var属性
            s=new Sample(2);//编译出错,不能改变引用变量s所引用的Sample对象
        }
    }

    在程序中通过final修饰符来定义常量,具有以下作用:

    • 提高代码的安全性,禁止非法修改取值固定并且不允许改变的数据
    • 提高程序代码的可维护性
    • 提高程序代码的可读性

    4 static修饰符

    static修饰符可以用来修饰类的成员变量,成员方法和代码块:

    • 用static修饰的成员变量表示静态变量,可以直接通过类名来访问。
    • 用static修饰的成员方法表示静态方法,可以直接通过类名来访问。
    • 用static修饰的程序代码块表示静态代码块,当Java虚拟机加载类时,就会执行该代码块。

    被static所修饰的成员变量和成员方法表明归某个类所有,它不依赖于类的特定实例,被类的所有实例共享,只要这个类被加载,java虚拟机就能根据类名在运行时数据区的方法区内定位到它们。

    4.1 static变量

    成员变量有两种,一种是被static修饰的变量叫类变量,或者静态变量,一种是没有被static修饰的变量,叫实例变量。

    区别如下:

    • 静态变量在内存中只有一个备份,运行时java虚拟机只为静态变量分配一次内存,在加载类的过程中完成静态变量的内存分配,可以直接通过类名访问静态变量。

    • 对于实例变量,没创建一个实例,就会为实例变量分配一次内存,实例变量可以在内存中有多个备份,互不影响。

    在类的内部,可以在任何方法内直接访问静态变量,在其他类中,可以通过某个类的类名来访它他的静态变量。

    例如:

    public class Sample{
        public static int number;//定义一个静态变量
        public void method(){
            int x=number;//在类的内部访问number静态变量
        }
    }
    public class Sample{
        public void method(){
            int x=Sample.number;//通过类名来访问number静态变量
        }
    }

    static变量在某种程度上与其他语言比如C语言中的全局变量相似,Java语言不支持不属于任何类的全局变量就,静态变量提供了这一功能,他有两个作用:

    • 能被类的所有实例共享,可作为实例之间进行交流的共享数据
    • 如果类的所有实例都包括一个相同的常量属性,可以把这个属性定义为静态常量类型,从而节省内存空间。

    4.2 static方法

    成员方法分为静态方法和实例方法,用static修饰的方法叫做静态方法或者类方法。静态方法和静态变量一样,不需要创建类的实例,可以直接通过类名来访问,例如:

    public class Sample {
        public static int add(int x,int y){//静态方法
            return x+y;
        }
        public class Sample {
        public void Sample{
        public void method() {
                int result=Sample.add(1,2);//调用Sample类的add()静态
                System.out.println("result");
            }
        }
    }

    1.静态方法可访问的内容

    因为静态方法不需要通过它所属的类的任何实例就会被调用,因此静态方法中不能使用this关键字,也不能直接访问所属类的实例变量和实例方法,但是可以直接访问所属类的静态变量和静态方法。

    2.实例方法可以访问的内容

    如果一个类没有被static修饰,那么它就是实例方法。在实例方法中可以直接访问所属类的静态变量,静态方法,实例变量,实例方法。

    实例方法的例子多次已举,不必再举

    3.静态方法必须被实现

    静态方法用来表示某个类所特有的功能,这种功能的实现不依赖于类的具体实例,也不依赖于它的子类。既然如此,当前类必须为静态方法提供实现。换句话说,一个静态方法不能被定义为抽象方法。以下方法的定义是非法的:

    static abstract void method();//编译出错,不能连用

    如果一个方法是静态的,它就必须自己实现该方法;如果一个方法是抽象的,那么它就只表示类所具有的功能,但不会实现它,在子类中才会实现它。

    4.作为程序入口的main()方法是静态方法

    这样使得java虚拟机只要加载了main()方法所属的类,就能执行main方法,而无须先创建这个类的实例。

    在main()静态方法中不能直接访问实例变量和实例方法。比如如下编译错误:

    public class Sample{
        int x;
        void method(){
        }
        public static void main(String args[]){
            x=9;//编译错误
            this.x=9;//编译错误
            method();//编译错误
            this.method();//编译错误
        }
    }

    正确的做法是通过Sample实例的引用来访问实例方法和实例变量

    public class Sample{
        int x;
        public static void main(String args[]){
            Sample s=new Sample();
            s.x=9;
            s.method();//合法
        }
    }

    5.方法的字节码都位于方法区

    不管是实例方法,还是静态方法,他们的字节码都位于方方法区,Java编译器把Java方法的源程序代码编译成二进制的编码,成为字节码,Java虚拟机的解析器能够解析这种字节码。

    注意:以下两点只需要了解,不需要掌握

    4.3 static代码块

    类中可以包含静态代码块,它不存在与任何方法体中,Java虚拟机加载时,会执行这些静态代码块,如果类中包含多个代码块,那么Java虚拟机按他们在类中出现的顺序依次执行他们,每个静态代码块只会被执行一次。

    4.4 用static进行静态导入

    从JDK5开始引入了静态导入语法,其目的是为了在需要经常访问同一个类的方法或成员变量的场合,简化程序代码。

    转载于:https://www.cnblogs.com/whatsabc/p/11489377.html

    展开全文
  • 一.在java中提供的一些修饰符,这些修饰符可以修饰类、变量和方法,在java中常见的修饰符有:abstract(抽象的)、static(静态的)、public(公共的)、protected(受保护的)、private(私有的)...修饰顶层类的修饰符包括a...

    一.在java中提供的一些修饰符,这些修饰符可以修饰类、变量和方法,在java中常见的修饰符有:abstract(抽象的)、static(静态的)、public(公共的)、protected(受保护的)、private(私有的)、synchronized(同步的)、native(本地的)、transient(暂时的)、volatile(易失的)、final(不可改变的)

    二.修饰顶层类的修饰符包括abstract、public和final,而static、protected和private不能修饰顶层类。成员方法和成员变量可以有多种修饰符,而局部变量只能用final修饰

    三.4种访问级别的可访问范围

    f89eb1382fecc811e06b729fc5d24d97.png

    注:顶层类只能被默认修饰符和public修饰,不能被private和protected修饰

    四.abstract修饰符可用来修饰类和成员方法

    1.用abstract修饰的类表示抽象类,抽象类不能实例化

    2.用abstract修饰的方法表示抽象方法,抽象方法没有方法体:“{}”,用来子类重写

    3.abstract修饰的类中,即抽象类中可以有普通方法和抽象方法

    4.抽象类和抽象方法不能被final修饰符修饰。abstract修饰符与final修饰符不能连用

    五.final修饰符

    1.final是“不可改变的”的含义,它可以修饰非抽象类、非抽象成员方法和变量

    2.用final修饰的类不能被继承,没有子类

    3.用final修饰的方法不能被子类的方法覆盖

    4.用final修饰的变量表示常量,比如(PI),因此只能被赋值一次,不能被改变

    六.static修饰符

    1.用static修饰的成员变量表示静态变量,可以通过类名直接访问

    2.用static修饰的成员方法表示静态方法,可以通过类名直接访问

    3.用static修饰的程序发代码块,当java虚拟机(JVM)全称是:Java Virtual Machine就能根据类名在运行时数据区的方法内定位到它们,而且只能运行一次。

    展开全文
  • 对于这个问题,一直没有仔细思考,今天整理一下: 对于顶级(外部)来说,只有两种修饰...内部的上一级是外部,那么对应的有四种访问控制修饰符:本(private),同包(default),父子(protected),任何位置(p
  • 当使用final关键字修饰一个时,则这个不可以被继承即该无子类,并且,该的所有的方法将被默认修饰为final类型,但是,成员变量不会被修饰为final类型,在JDK中,所有包装如Integer...
  • 一、选择题及参考答案1、请问,以下哪些重载了equals()方法?StringIntegerDoubleDateFile答案:ABCDE2、请问,以下哪些描述是正确的?&&是一个逻辑短路与运算符~是一个异或按位运算符|既是一个按位或...
  • Java | 顶层类(Top-Level Class)

    千次阅读 2020-06-26 07:21:59
    顶层类(Top-Level Class),是 Java 中对类的一种定义方式。在 .java 文件中,处于最外层的类就称为顶层类,在其外部不存在将其包围起来的任何代码块。顶层类只能声明为 public 或包私有的。在 .java 文件中,只能...
  • List item 修饰类的关键字及其含义 3.1 修饰符 首先每一个类都会有访问权限,指明这些类可以被哪些类访问。JAVA通过在类声明时,... public:修饰顶层类和成员类,表明该类是一个公共类,可被任何类访问。(注意...
  • 【判断题】若需要定义一个域或方法,应使用static修饰符【判断题】在创建子类的对象时,将先执行继承自父类的无参构造函数,然后再执行自己的构造函数【单选题】Java语言中,多个同名的方法是通过()来区分的。...
  • Java中提供的一些修饰符,这些修饰符可以修饰类、变量和方法,下面小编为大家带来了关于Java语言中修饰符的基础知识。 1.在java中提供的一些修饰符,这些修饰符可以修饰类、变量和方法,在java中常见...2.修饰顶层类
  • 每个编译单元(文件)都只能有一个public,这表示,每个编译单元都有单一的公共接口,用public来表现。该接口可以按要求包含众多的支持包访问权限的。如果在某个编译单元内有一个以上的public,编译器就会给...
  • java基础之static

    2019-12-24 22:19:19
    1. static可以修饰成员变量,成员方法,代码块和内部类,不能修饰顶层类和构造方法。 2. static修饰的成员变量称为类变量,归属于类;在加载类的时候分配内存和初始化,存放在方法区内;通过类名(全路径)访问该...
  • 1、public 修饰,系统默认提供public修饰的无参构造器 2、default修饰,系统默认提供default修饰的无参构造器
  • 我们通过AnnotationConfigApplicationContext传入一个包路径启动Spring之后,会首先初始化包扫描的过滤规则。那我们今天就来看下包扫描的具体过程。 还是先看下面的代码: AnnotationConfigApplicationContext ...
  • 一.在java中提供的一些修饰符,这些修饰符可以修饰类、变量和方法,在java中常见的修饰符有:abstract(抽象的)、static(静态的)、public(公共的)、protected(受保护的)、private(私有的)...修饰顶层类的修饰符包括a...
  • Java基础(八) Java修饰符及接口详解之(二) 内部类 总体来熟,Java内部类为了从维护性的考虑,使用的并不是特别多。...顶层类(正常类)只能处于public和默认访问级别,而成员内部类可以处于public, prot
  • 事件修饰符 在事件处理程序中调用event.preventDefault()或event.stopPropagation()是非常常见的需求。 .stop 阻止单击事件传播 即阻止了事件冒泡,相当于调用了event.stopPropagation方法(通俗讲就是阻止事件...
  • 将const修饰成员函数称为const成员函数,const修饰类成员函数,实际上修饰的是成员函数隐含的this指针,表示在该成员函数中不能对成员进行修改。 class Data { public: void showData()const //t...
  • 只有一个储存空间,可以通过类名调用使用方便)修饰内部类注意:不能修饰顶层类,构造方法,局部变量,抽象类,接口。 静态方法只能访问“静态成员”。 普通方法都可以访问。特点1、只有一个储存空间,被所有对象...
  • 2、当const修饰指针时,由于const的位置不同,它的修饰对象会 有所不同,可以指定指针本身为const,也可以指定指针所指的数据为 const,或二者同时指定为const; int *const p2; int const *p1; const int *...
  • Java中四种访问修饰

    2021-03-13 20:53:23
    Public Private Protect DefaultPublic 修饰属性变量及方法,包内及包外的任何(包括子类和普通)都可以访问。Private 修饰属性变量及方法,只有本可以访问,而在包内包外的任何都不能访问。...
  • 如果有人问你为什么有abstract interface 修饰类,答案一定是他看到的这种方式一定是反编译出来的结果。实际中abstract interface和interface修饰没有区别。 下面就上面的问题,介绍下抽象接口的概念。 在...
  • 05【继承、抽象、权限修饰符、final】

    千次阅读 多人点赞 2021-07-30 20:20:47
    day05【继承、抽象、权限修饰符、final】 一、继承 1.1 继承概述 继承是面向对象三大特征之一,继承就是子类继承父类的特征(属性)和行为,使得子类对象(实例)具有父类的属性和方法,或子类从父类继承方法,使得...
  • ,object,接口,构造函数,方法,属性以及他们的setters都拥有可见性修饰符(属性的getters拥有和...方法、属性、、object 和 接口能在顶层中声明,即直接声明在包中。 package foo fun baz() {} class ...
  • vue中修饰

    2021-02-24 21:48:37
    文章目录vue中修饰符分为以下五种:表单修饰符事件修饰符鼠标按钮修饰符键盘修饰符v-bind修饰符 vue中修饰符分为以下五种: 表单修饰符 事件修饰符 鼠标按键修饰符 键值修饰符 v-bind修饰符 表单修饰符 lazy 在...
  • Java基础知识之修饰

    2017-12-29 10:54:10
    记录一下,Java语言中的修饰符。对于java开发者,也许你不曾... 成员方法 构造方法 成员变量 局部变量 abstract Y Y _ _ _ static _ Y _ Y _ public Y ...
  • 顶层类只能用 public 和默认修饰符(即无修饰符)修饰 (2).abstract: abstract 修饰的类不能被实例化,必须被子类继承。类只要有一个抽象方法就必定是抽象类,但抽象类不一定要有抽象方法。 (3)final...
  • 1. 作用 封装将数据和操作连接起来。封装的一个重要属性:访问控制。 通过封装可以控制程序的某个部分所能...在Java中的每个成员(数据成员和成员方法)都有一个成为可访问性的属性,用来保护成员。 2. Java中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,416
精华内容 10,566
关键字:

修饰顶层类