网站地图 | RSS订阅 老铁博客 - 上海SEO优化|上海网站建设|蜘蛛池出租|站群代搭建
你的位置:首页 » 前端脚本 » 正文

java修饰符,java方法修饰符有哪些

2020-6-12 13:56:2 | 作者:老铁SEO | 0个评论 | 人浏览

  1、类的修饰符分为:可访问控制符和非访问控制符两种。


  可访问控制符是:公共类修饰符public


  非访问控制符有:抽象类修饰符abstract;最终类修饰符final


  1)公共类修饰符public:Java语言中类的可访问控制符只有一个:public即公共的。每个Java程序的主类都必须是public类作为公共工具供其它类和程序使用的应定义为public类。


  2)抽象类修饰符abstract:凡是用abstract修饰符修饰的类,被称为抽象类。所谓抽象类是指这种类没有具体对象的一种概念类。这样的类就是Java语言的abstract类。


  3)最终类修饰符final:当一个类不可能有子类时可用修饰符final把它说明为最终类。被定义为final的类通常是一些有固定作用、用来完成某种标准功能的类。


  4)类缺省访问控制符:如果一个类没有访问控制符,说明它具有缺省的访问控制符特性。此时,这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。


  2.域的控制修饰符也分为:可访问控制符和非访问控制符两类。


  可访问控制符有4种:公共访问控制符:public;私有访问控制符:private;保护访问控制符:protected;私有保护访问控制符:privateprotected


  非访问控制符有4种:静态域修饰符:static;最终域修饰符:final;易失(共享)域修饰符:volatile;暂时性域修饰符:transient


  1)公共访问控制符public:用public修饰的域称为公共域。如果公共域属于一个公共类,则可以被所有其它类所引用。由于public修饰符会降低运行的安全性和数据的封装性,所以一般应减少public域的使用。


  2)私有访问控制符private:用private修饰的成员变量(域)只能被该类自身所访问,而不能被任何其它类(包括子类)所引用。


  3)保护访问控制符protected:用protected修饰的成员变量可以被三种类所引用:①该类自身;②与它在同一个包中的其它类;③在其它包中的该类的子类。使用修饰符protected的主要作用是允许其它包中它的子类来访问父类的特定属性。


  4)私有保护访问控制符privateprotected:用修饰符privateprotected修饰的成员变量可以被该类本身或该类的子类两种类访问和引用。


  5)静态域修饰符static:用static修饰的成员变量仅属于类的变量,而不属于任何一个具体的对象,静态成员变量的值是保存在类的内存区域的公共存储单元,而不是保存在某一个对象的内存区间。任何一个类的对象访问它时取到的都是相同的数据;任何一个类的对象修改它时,也都是对同一个内存单元进行操作。


  6)最终域修饰符final:最终域修饰符final是用来定义符号常量的。一个类的域(成员变量)如果被修饰符final说明,则它的取值在程序的整个执行过程中都是不变的。


  7)易失(共享)域修饰符volatile:易失(共享)域修饰符volatile是用来说明这个成员变量可能被几个线程所控制和修改。也就是说在程序运行过程中,这个成员变量有可能被其它的程序影响或改变它的取值。因此,在使用中要注意这种成员变量取值的变化。通常volatile用来修饰接受外部输入的域。


  8)暂时性域修饰符transient:暂时性域修饰符transient用来定义一个暂时性变量。其特点是:用修饰符transient限定的暂时性变量,将指定Java虚拟机认定该暂时性变量不属于永久状态,以实现不同对象的存档功能。否则,类中所有变量都是对象的永久状态的一部分,存储对象时必须同时保存这些变量。


  3.方法的控制修饰符也分为:可访问控制符和非访问控制符两类。


  可访问控制符有4种:公共访问控制符:public;私有访问控制符:private;保护访问控制符:protected;私有保护访问控制符:privateprotected


  非访问控制符有5种:抽象方法控制符:abstract;静态方法控制符:static;最终方法控制符:final;本地方法控制符:native;同步方法控制符:synchronized


  1)抽象方法控制符abstract:用修饰符abstract修饰的方法称为抽象方法。抽象方法是一种仅有方法头,没有方法体和操作实现的一种方法。


  2)静态方法控制符static:用修饰符static修饰的方法称为静态方法。静态方法是属于整个类的类方法;而不使用static修饰、限定的方法是属于某个具体类对象的方法。由于static方法是属于整个类的,所以它不能操纵和处理属于某个对象的成员变量,而只能处理属于整个类的成员变量,即static方法只能处理static的域。


  3)最终方法控制符final:用修饰符final修饰的方法称为最终方法。最终方法是功能和内部语句不能更改的方法,即最终方法不能重载。这样,就固定了这个方法所具有的功能和操作,防止当前类的子类对父类关键方法的错误定义,保证了程序的安全性和正确性。所有被private修饰符限定为私有的方法,以及所有包含在final类(最终类)中的方法,都被认为是最终方法。


  4)本地方法控制符native:用修饰符native修饰的方法称为本地方法。为了提高程序的运行速度,需要用其它的高级语言书写程序的方法体,那么该方法可定义为本地方法用修饰符native来修饰;


  5)同步方法控制符synchronized:该修饰符主要用于多线程共存的程序中的协调和同步。


  本文出自http://hi.baidu.com/lifa868/blog/item/d91674ecb346c64779f0557d.html


  Java内部类的修饰符有哪些?


  一、内部类可以为四种:


  ⒈静态内部类


  ⒉成员内部类


  ⒊局部内部类


  ⒋


  匿名内部类几种内部类的共性:


  A、内部类仍然是一个独立的类,在编译之后会内部类会被编译成独立的.class文件,但是前面冠以外部类的类命和$符号。


  B、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的。


  1、静态嵌套类:从技术上讲,静态嵌套类不属于内部类。因为内部类与外部类共享一种特殊关系,更确切地说是对实例的共享关系。而静态嵌套类则没有上述关系。它只是位置在另一个类的内部,因此也被称为顶级嵌套类。静态的含义是该内部类可以像其他静态成员一样,没有外部类对象时,也能够访问它。静态嵌套类不能访问外部类的成员和方法。classOuter{staticclassInner{}}classTest{publicstaticvoidmain(String[]args){Outer.Innern=newOuter.Inner();}}


  2、成员内部类:形式如下


  classOuter{classInner{}}


  编译上述代码会产生两个文件:Outer.class和Outer$Inner.class。成员内部类内不允许有任何静态声明!下面代码不能通过编译。


  classInner{staticinta=10;


  }能够访问成员内部类的唯一途径就是通过外部类的对象!


  A、从外部类的非静态方法中实例化内部类对象。classOuter{private


  inti=10;publicvoidmakeInner(){Innerin=newInner();


  in.seeOuter();}classInner{publicvoidseeOuter(){


  System.out.print(i);}}


  }表面上,我们并没有创建外部类的对象就实例化了内部类对象,和上面的话矛盾。事实上,如果不创建外部类对象也就不可能调用makeInner()方法,所以到头来还是要创建外部类对象的。可能试图把makeInner()方法修饰为静态方法,即static


  publicvoid


  makeInner()。这样不创建外部类就可以实例化外部类了!但是在一个静态方法里能访问非静态成员和方法吗?显然不能。它没有this引用。没能跳出那条规则!但是如果在这个静态方法中实例化一个外部类对象,再用这个对象实例化外部类完全可以!也就是下一条的内容。


  B、从外部类的静态方法中实例化内部类对象。


  classOuter{privateinti=10;classInner{publicvoidseeOuter(){


  System.out.print(i);


  }}publicstaticvoidmain(String[]args){Outerout=newOuter();


  Outer.Innerin=out.newInner();//Outer.Innerin=newOuter().new


  Inner();in.seeOuter();}


  }被注释掉的那行是它上面两行的合并形式,一条简洁的语句。对比一下:在外部类的非静态方法中实例化内部类对象是普通的new方式:Innerin=


  newInner();在外部类的静态方法中实例化内部类对象,必须先创建外部类对象:Outer.Inner


  in=newOuter().new


  Inner();


  C、内部类的this引用。普通的类可以用this引用当前的对象,内部类也是如此。但是假若内部类想引用外部类当前的对象呢?用“外部类名”.this;的形式,如下例的Outer.this。


  classOuter{classInner{publicvoidseeOuter(){


  System.out.println(this);System.out.println(Outer.this);}}


  }


  D、成员内部类的修饰符。对于普通的类,可用的修饰符有final、abstract、strictfp、public和默认的包访问。但是成员内部类更像一个成员变量和方法。可用的修饰符有:final、abstract、public、private、protected、strictfp和static。一旦用static修饰内部类,它就变成静态内部类了。


  3、方法内部类:顾名思义,把类放在方法内。


  classOuter{publicvoiddoSomething(){classInner{publicvoid


  seeOuter(){}}}


  }


  A、方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。


  B、方法内部类对象不能使用该内部类所在方法的非final局部变量。因为方法的局部变量位于栈上,只存在于该方法的生命期内。当一个方法结束,其栈结构被删除,局部变量成为历史。但是该方法结束之后,在方法内创建的内部类对象可能仍然存在于堆中!例如,如果对它的引用被传递到其他某些代码,并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长,所以内部类对象不能使用它们。下面是完整的例子:


  classOuter{publicvoiddoSomething(){finalinta=10;classInner{


  publicvoidseeOuter(){System.out.println(a);}}Innerin=new


  Inner();in.seeOuter();}publicstaticvoidmain(String[]args){Outer


  out=newOuter();out.doSomething();}


  }


  C、方法内部类的修饰符。与成员内部类不同,方法内部类更像一个局部变量。可以用于修饰方法内部类的只有final和abstract。


  D、静态方法内的方法内部类。静态方法是没有this引用的,因此在静态方法内的内部类遭受同样的待遇,即:只能访问外部类的静态成员。


  4、匿名内部类:顾名思义,没有名字的内部类。表面上看起来似乎有名字,实际那不是名字。


  A、继承式的匿名内部类。


  classCar{publicvoiddrive(){System.out.println("Drivingacar!");}


  }classTest{publicstaticvoidmain(String[]args){Carcar=new


  Car(){publicvoiddrive(){System.out.println("Drivinganothercar!");}


  };car.drive();}}结果输出了:Drivinganother


  car!


  Car引用变量不是引用Car对象,而是Car匿名子类的对象。建立匿名内部类的关键点是重写父类的一个或多个方法。再强调一下,是重写父类的方法,而不是创建新的方法。因为用父类的引用不可能调用父类本身没有的方法!创建新的方法是多余的。简言之,参考多态。B、接口式的匿名内部类。


  interfaceVehicle{publicvoiddrive();}classTest{publicstatic


  voidmain(String[]args){Vehiclev=newVehicle(){


  publicvoiddrive(){System.out.println("Drivingacar!");}};


  v.drive();}


  }上面的代码很怪,好像是在实例化一个接口。事实并非如此,接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。


  C、参数式的匿名内部类。class


  Bar{voiddoStuff(Foof){}}interfaceFoo{voidfoo();}classTest{


  staticvoidgo(){Barb=newBar();


  b.doStuff(newFoo(){publicvoidfoo(){System.out.println("foofy");}


  });


  }}


  二、权限修饰符:public、protected、default、private。


  修饰符:abstract、static、final。


  public??使用对象:最广,类、接口、变量、方法。


  protected使用对象:变量、方法注意:不能修饰类(外部类)。


  default?使用对象:类、接口、变量、方法。(即缺省,什么也不写)。


  private?使用对象:变量、方法注意:不能修饰类(外部类)。


  abstract使用对象:类、接口、方法。


  static?使用对象:类、变量、方法、初始化函数(注意:修饰类时只能修饰内部类)。


  final??使用对象:类、变量、方法。


  transient:告诉编译器,在类对象序列化的时候,此变量不需要持久保存


  volatile:指出可能有多个线程修改此变量,要求编译器优化以保证对此变量的修改能够被正确的处理。


  native:用该修饰符定义的方法在类中没有实现,而大多数情况下该方法的实现是用C、C++编写的。


  synchronized:修饰方法,多线程的支持。


  java中类修饰符有哪些?


  1.class不加修饰符的时候即直接声明classA{}


  在这种情况下,class前面没有加任何的访问修饰符,通常称为“默认访问模式”,在该模式下,这个类只能被同一个包中的类访问或引用,这一访问特性又称包访问性。


  2.类修饰符:


  (1)public(访问控制符),将一个类声明为公共类,他可以被任何对象访问,一个程序的主类必须是公共类。


  (2)abstract,将一个类声明为抽象类,没有实现的方法,需要子类提供方法实现。


  (3)final,将一个类生命为最终(即非继承类),表示他不能被其他类继承。


  3.成员变量修饰符:


  (1)public(公共访问控制符),指定该变量为公共的,他可以被任何对象的方法访问。


  (2)private(私有访问控制符)指定该变量只允许自己的类的方法访问,其他任何类(包括子类)中的方法均不能访问。


  (3)protected(保护访问控制符)指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。


  (4)friendly?,在同一个包中的类可以访问,其他包中的类不能访问。


  (5)final,最终修饰符,指定此变量的值不能变。


  (6)static(静态修饰符)指定变量被所有对象共享,即所有实例都可以使用该变量。变量属于这个类。


  (7)transient(过度修饰符)指定该变量是系统保留,暂无特别作用的临时性变量。


  (8)volatile(易失修饰符)指定该变量可以同时被几个线程控制和修改。


  4.方法修饰符:


  (1)public(公共控制符)


  (2)private(私有控制符)指定此方法只能有自己类等方法访问,其他的类不能访问(包括子类)


  (3)protected(保护访问控制符)指定该方法可以被它的类和子类进行访问。


  (4)final,指定该方法不能被重载。


  (5)static,指定不需要实例化就可以激活的一个方法。


  (6)synchronize,同步修饰符,在多个线程中,该修饰符用于在运行前,对他所属的方法加锁,以防止其他线程的访问,运行结束后解锁。


  (7)native,本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。


  扩展资料:百度百科-java关键字


  java的访问修饰符是什么?


  Java中的访问修饰符


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


  (1)public:用public修饰的类、类属变量及方法,包内及包外的任何类(包括子类和普通类)均可以访问;


  (2)protected:用protected修饰的类、类属变量及方法,包内的任何类及包外那些继承了该类的子类才能访问(此处稍后解释),protected重点突出继承;


  (3)default:如果一个类、类属变量及方法没有用任何修饰符(即没有用public、protected及private中任何一种修饰),则其访问权限为default(默认访问权限)。默


  认访问权限的类、类属变量及方法,包内的任何类(包括继承了此类的子类)都可以访问它,而对于包外的任何类都不能访问它(包括包外继承了此类的子类)。default重点突出包;


  (4)private:用private修饰的类、类属变量及方法,只有本类可以访问,而包内包外的任何类均不能访问它。


  网上一些资料及一些书上用表格对java访问修饰符做了清楚的总结,如下表所示:?


  重要总结:通过上面的分析,我们可以看到:


  1.?public、private和protected对我们来说没有任何异议。


  2.顶层类只能用public访问修饰符和default(默认)访问修饰符修饰,其中用默认修饰符修饰的类(及没有任何修饰符的类,如classB{})不能被其他包中的类继承,这也说明了default(默认)访问修饰符突出的是包权限


  3.protected:本人做了一次实验,发现在不同包的子类中,new一个父类对象,并用该父类对象去访问父类中的用protected修饰的类属变量和方法时不能访问,而new一个子类对象时,子类对象可以访问(说明protected修饰的类可以被其他包中的类继承)。也可以在子类重写父类的方法中使用super关键字调用。这岂不是和上面表格中的总结(红色对勾)冲突了?本人也是百思不得其解。最后在网上找到了一个相对比较认可的解释,如下:


  protected修饰符的修饰的成员变量和方法也称为受保护的成员变量和方法,受保护的成员变量和方法可以在本类或同一个包中的其它类(包括子类)中通过类的实例进行访问,也可以被同一个包中的类或不同包中的类继承,但是不能在不同包中的其它类(包括子类)中通过类的实例进行访问。


  4.如果一个类使用public修饰,那该类的类名必须与他所在的源文件名相同。一个.java源文件中有且只有一个public类,顶层类只能用public和默认修饰符(即无修饰符)修饰;


  5.?final修饰的类不能被继承,没有子类。


  6.?abstract修饰的类不能被实例化,必须被子类继承。类只要有一个抽象方法就必定是抽象类,但抽象类不一定要有抽象方法。


  最终总结,就一句话:protected修饰符所修饰的类(这句话中指父类)属成员变量和方法,只可以被子类访问,而不管子类是不是和父类位于同一个包中。default修饰符所修饰的类属成员变量和方法,只可被同一个包中的其他类访问,而不管其他类是不是该类的子类。protected属于子类限制修饰符,而default属于包限制修饰符。

  • 本文来自: 老铁博客,转载请保留出处!欢迎发表您的评论
  • 相关标签:
  • 已有0位网友发表了一针见血的评论,你还等什么?

    必填

    选填

    记住我,下次回复时不用重新输入个人信息

    必填,不填不让过哦,嘻嘻。

    ◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

    相关推荐