Java主要修饰符的使用方法总结(周双)

Java修饰符总结1引言众所周知，Java语言是一种具有良好面向对象特性的语言，加上其良好的可移植性Java语言受到广泛的欢迎。

要实现其良好的面向对象的特性就要具有良好的封装性，而要做到具有良好的封装性就需要具有功能强大的修饰符。

通过对Java的学习发现Java的修饰符有很多很复杂，很难理清头绪，所以在此做一个系统的总结，以增进对Java修饰符的理解，便于以后的学习。

java中的修饰符分为类修饰符，字段修饰符，方法修饰符。

按照功能分类可以分为以下几种：1.public使用对象：类、接口、成员介绍：无论它所处在的包定义在哪，该类（接口、成员）都是可访问的。

2.private使用对象：成员介绍：成员只可以在定义它的类中被访问3.static使用对象：类、方法、字段、初始化函数介绍：成名为static的内部类是一个顶级类，它和包含类的成员是不相关的。

静态方法是类方法，是被指向到所属的类而不是类的实例。

静态字段是类字段，无论该字段所在的类创建了多少实例，该字段只存在一个实例被指向到所属的类而不是类的实例。

初始化函数是在装载类时执行的，而不是在创建实例时执行的。

4.final使用对象：类、方法、字段、变量介绍：被定义成final的类不允许出现子类，不能被覆盖（不应用于动态查询），字段值不允许被修改。

5.abstract使用对象：类、接口、方法介绍：类中包括没有实现的方法，不能被实例化。

如果是一个a bstract方法，则方法体为空，该方法的实现在子类中被定义，并且包含一个abstract方法的类必须是一个abstract类6.protected使用对象：成员介绍：成员只能在定义它的包中被访问，如果在其他包中被访问，则实现这个方法的类必须是该成员所属类的子类。

7.native使用对象：成员介绍：与操作平台相关，定义时并不定义其方法，方法的实现被一个外部的库实现。

8.strictfp使用对象：类、方法介绍：strictfp修饰的类中所有的方法都隐藏了strictfp修饰词，方法执行的所有浮点计算遵守IEEE 754标准，所有取值包括中间的结果都必须表示为float或double类型，而不能利用由本地平台浮点格式或硬件提供的额外精度或表示范围。

java类的访问修饰符总结java的修饰符有：权限修饰符：public、protected、default、private修饰符：abstract、static、finalpublic 使用对象：最广，类、接口、变量、方法protected使用对象：变量、方法注意：不能修饰类（外部类）default 使用对象：类、接口、变量、方法。

（即缺省，什么也不写）private 使用对象：变量、方法注意：不能修饰类（外部类）abstract使用对象：类、接口、方法static 使用对象：类、变量、方法、初始化函数（注意：修饰类时只能修饰内部类）final 使用对象：类、变量、方法transient：告诉编译器，在类对象序列化的时候，此变量不需要持久保存volatile：指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理native：用该修饰符定义的方法在类中没有实现，而大多数情况下该方法的实现是用C、C++编写的。

synchronized：修饰方法，多线程的支持类分外部类和内部类，他们的访问控制是相同的吗外部类是相对于内部类而言的，内部类是定义在类里面的类。

外部类的修饰符有：default（缺省，不写）：类定义时前面未加任何修饰符，表示同一个包中可见。

public：修饰类时表示该类能被项目中所有类可见abstract：表示是抽象类final：表示类不可以被继承scrictpf:(java关键字) 当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。

严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示内部类又分：成员内部类、局部内部类、静态内部类、匿名内部类成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列局部内部类：定义在外部类的方法体里面的类静态内部类：使用static修饰的内部类匿名内部类：就是没有名字的内部类成员内部类修饰符有：public：protected：private：private不能修饰外部类，abstract：final：static：可以当做普通类使用，而不用先实例化一个外部类。

JAVA修饰符总结Java修饰符用于控制类、方法、变量和构造方法的访问级别和特性。

Java提供了多种修饰符，包括访问修饰符、非访问修饰符和继承修饰符。

本篇文章将对这些修饰符进行总结，并提供一些使用示例。

一、访问修饰符Java提供了四种访问修饰符：public、protected、default（默认）和private。

这些修饰符的使用不仅可以控制类的访问级别，还可以控制方法、变量和构造方法的访问级别。

1. public修饰符public修饰符具有最高的访问级别，被public修饰的类、方法、变量和构造方法可以被所有其他类访问。

示例代码：```public class MyClasspublic void myMethoSystem.out.println("This method can be accessed by any other class.");}public class OtherClasspublic static void main(String[] args)obj.myMethod(;}```2. protected修饰符protected修饰符限制了对同一包内的其他类的访问，以及对其他包中的子类的访问。

示例代码：```package mypackage;public class MyClassprotected void myMethoSystem.out.println("This method can be accessed by classes in the same package and subclasses in other packages.");}package otherpackage;import mypackage.MyClass;public class SubClass extends MyClasspublic static void main(String[] args)obj.myMethod(;}```3. default（默认）修饰符默认修饰符是指当没有使用任何访问修饰符时，所使用的修饰符。

Java中主要修饰符的使用(周双) 武汉理工大学计算机学院软件sy1001班周双（0121010680234）Java中定义了6个常用修饰符：public、protected、private、abstract、static、final。

访问控制符：公开级别：public；受保护级别：protected；默认级别：friendly （一般不指明）；私有级别：private。

类只能使用public和默认级别修饰。

其中类的属性和方法可以使用上述4个访问修符；局部变量不可以使用访问修饰符；常用的方法是将类的属性设为private，而将类的方法设为public。

abstract修饰符：abstract修饰符可以用来修饰类和成员方法：用abstract修饰抽象类，表示该类不可以被实例化。

相对应的则称为具体类。

用abstract修饰的方法成为抽象方法，该方法没有方法体。

抽象方法用来描述系统具有什么功能。

final 修饰符：final修饰符表示不可以改变的含义。

final修饰符可以用来修饰类，成员方法，和成员变量。

用final修饰类，表示该类不可以被继承；用final 修饰成员方法，表示该方法不可以被覆盖（override）；用final修饰变量，表示一旦赋值就不可以被改变。

注意，final变量必须被显式初始化。

对于实例变量可以在定义时或在构造方法中进行初始化。

而类变量(static变量)必须在定义时进行初始化。

对于final修饰的引用类型，那么该变量在其生命周期中只能指向同一个对象，但可以改变对象的值。

Static修饰符：static成员变量表示静态变量，可以直接通过类名来访问。

static 成员方法表示静态方法，可以直接通过类名来访问。

由于static方法中，只可以访问静态变量和方法，所以要想访问一个实例变量或方法，则必须要先得到相应的对象的引用，才能访问其变量和方法。

一、类的修饰符Java程序在定义类时，除恶额使用class关键字标识外，还可以在在class之前增加若干类的修饰符来修饰限定所定义的类的特性。

Java主要修饰符的使用软件1004班杨娜0121010680433java主要修饰符的使用一、类及其成员的访问权限Java为类中成员设置了四种访问权限，为类设置了两种访问权限。

（一）类中成员的访问权限Java主要定义了四种权限修饰符：public（共有）、protected （保护）、缺省和private（私有）。

这四种权限修饰符均可用于声明类中成员的访问权限，例如：private int year，month，day；public void print（）；四种权限修饰符用于声明类中成员的访问权限，说明如下：1、public：说明该类成员可被所有类的对象访问。

public指定最大访问权限范围。

2、protected：说明该类成员可被同一类中的其他成员或其子类成员，或同一包中的其他类访问，不能被其他包中的非子类访问。

protected指定中间级的有限的访问权限范围，使保护成员在子类和非子类中具有不同的访问权限，即保护成员可被子类访问，不能被非子类访问。

3、缺省：当没有使用访问权限修饰符声明成员时，说明该类成员能被同一类中的其他成员访问或被同一包中的其他类访问，不能被包之外的其他类访问。

缺省权限以包为界划定访问权限范围，是同一包中的类具有访问权限，其他包中的类则没有访问权限。

4、private：说明该类成员只能被同一类中的其他成员访问，不能被其他类的成员访问，也不能被子类成员访问。

private指定最小访问权限范围，对其他类隐藏类的成员，防止其他类修改该类的私有成员。

注意：public等访问权限修饰符不能用于修饰方法体中的局部变量，因为方法体中局部变量的作用域仅限于该方法，在类之外是不可见的，不存在其他类对他的访问。

四种权限修饰符定义的访问权限如表所示：（二）类的访问权限声明一个类可使用的权限修饰符只有两种：public和缺省，不能使用protected和private。

一个源程序文件中可以声明多个类，但用public修饰的类只能有一个，且该类名必须与文件名相同。

目录Java主要修饰符的使用“说明书” (1)一、public、protected和private (2)一）对类的类型的修饰 (2)二）未标注此类类型的成员变量和成员函数 (2)三）public、protected和private在子类中的可见情况 (3)四）public、protected和private在非子类中的可见情况 (8)二、final (10)（一）对类类型的修饰 (10)（二）final修饰的成员函数 (11)（三）final修饰的成员变量 (11)三、static (12)附录：原函数 (14)一）father.java (14)二）childinsamepa.java (16)三) childindifferentp.java (17)四）AFINALCLASS.java (18)五）DEFFERENTPAKAEGEIMPORT.java (19)六）FORSTATIC.java (19)七）ROOT.java (20)——武汉理工软件1003班0121010680328 陈莹伊Java主要修饰符的使用“说明书”示例用工作空间结构：一、public、protected和private一）对类的类型的修饰类的类型只能使用public修饰，或者省略。

二）未标注此类类型的成员变量和成员函数未标注类型的成员变量和成员函数在java类中的使用可见类别不同于public、protected和private。

当成员变量和成员函数无这三个修饰符修饰，无论是该类的子类还是非子类，只要是和该类属于同一个包，这些成员变量和成员函数都是可见的。

而对于不属于同一个包的类，它们则是不可见的。

示例用class father的成员列表：在同包子类中的可见情况：在不同包子类中的可见情况：在同包非子类中的可见情况：在不同包非子类中的可见情况：三）public、protected和private在子类中的可见情况father类成员表列：a)对于子类而言，无论是否属于同一个包，父类中的public类型和protected 类型变量和函数在子类中是可见的。

java中修饰符的用法在Java中，修饰符是用来控制访问级别和行为的关键字。

Java中的修饰符可以应用在类、方法、变量和构造函数上。

修饰符主要分为访问修饰符和非访问修饰符两类。

一、访问修饰符：1. public：该修饰符表示对任意代码片段都是可见的。

被public修饰的类、方法、成员变量都可以在任何位置被访问。

2. protected：该修饰符表示对子类和同一包中的代码片段可见。

被protected修饰的方法和成员变量可以在子类中访问。

3. private：该修饰符表示对同一类中的代码片段可见。

被private 修饰的方法和成员变量只能在同一个类中访问。

4.默认修饰符：当没有使用任何访问修饰符时，表示为默认访问修饰符。

默认修饰符表示对同一包中的代码片段可见，但对其他包中的代码片段不可见。

二、非访问修饰符：1. static：该修饰符表示成员变量或方法属于类而不是实例。

被static修饰的成员变量在类的所有实例中都共享相同的值，被static修饰的方法可以直接通过类名调用。

2. final：该修饰符表示被修饰的类、方法或变量的值无法更改。

被final修饰的类无法被继承，被final修饰的方法无法被重写，被final 修饰的变量只能被赋值一次。

3. abstract：该修饰符表示被修饰的类是抽象类，不能被实例化。

被abstract修饰的方法没有具体的实现，只有声明，需要在子类中进行实现。

4. synchronized：该修饰符表示同一时间只能有一个线程访问被修饰的代码段或方法。

多个线程在访问该代码段时，会依次进行排队访问，提供了多线程的安全性。

5. transient：该修饰符表示被修饰的成员变量在序列化时会被忽略，不会被保存。

6. volatile：该修饰符表示被修饰的成员变量的值在多线程环境下都是可见的。

当一个线程修改了该成员变量的值，其他线程都能立即看到该修改。

这些修饰符可以在不同的位置使用：1. 类的修饰符：可以使用public、abstract或final来修饰类。

java修饰符详解1. 访问修饰符public：公共的protected：受保护的（不能修饰类）default（默认不写）private：私有的（不能修饰类）修饰符当前类同⼀包内被继承的类（同包）被继承的类（不同包）其他包public能访问能访问能访问能访问能访问protected能访问能访问能访问能/不能不能访问default能访问能访问能访问不能访问不能访问private能访问不能访问不能访问不能访问不能访问注：protected：基类的 protected 成员是包内可见的，并且对⼦类可见若⼦类与基类不在同⼀包中，那么在⼦类中，⼦类实例可以访问其从基类继承⽽来的protected⽅法，⽽不能访问基类实例的protected⽅法2. 特征修饰符abstract：抽象的1. 修饰⽅法⽤abstract修饰符修饰的⽅法只有⽅法的结构没有⽅法执⾏体叫做抽象⽅法注：native修饰的⽅法虽然也没有⽅法体但不是抽⽅法，过程是其他语⾔写的public class Person(){//被abstract修饰的⽅法没有⽅法体public abstract void medth();}2. 修饰类⽤abstract修饰符修饰的类叫做抽象类public abstract class Person(){//抽象类⾥⾯可以有抽象⽅法也可以有普通⽅法//抽象⽅法public abstract void medth();//普通⽅法public void medth1(){System.out.println("这是⼀个普通⽅法");}}3. 特点抽象类中不是必须要有抽象⽅法抽象⽅法必须放在抽象类中或者接⼝中，普通类中不允许有抽象⽅法4. 如何使⽤抽象类中含有构造⽅法，但是我们不能通过调⽤构造⽅法直接创建对象抽象类只能通过⼦类继承来做事//定义⼀个抽象类public abstract class Person(){public abstract void run();}//定义⼀个类并继承Personpublic class Son extends Person(){//重写Person中的run⽅法@Overridepublic void run() {System.out.println("这是我继承我的⽗类重写的⽅法");}}public static void main(String[] args) {son son=new son();son.run();}以上程序执⾏结果为：这是我继承我的⽗类重写的⽅法5.类和类之间的关系：抽象类---单继承---抽象类抽象类---单继承---具体类（⼀般不会出现）具体类---单继承---抽象类不可以（将⽗类的抽象⽅法具体化或⼦类也变成抽象类）final：最终的不可改变的修饰变量如果存储的是值类型：变量内的值不让更改---常量如果存储的是引⽤类型：变量⾥⾯的地址引⽤不让更改---对象唯⼀修饰属性属性如果没有赋值有默认值存在的属性⽤final修饰后必须给属性赋初始值，否则会编译错误修饰⽅法⽅法是最终的⽅法不可以更改（覆盖）final修饰的⽅法，要求不可以被⼦类重写（覆盖）修饰类本⾝类是最终的不可以更改、（太监类）此类不可以被其它⼦类继承static：静态的修饰变量：static修饰的成员变量也叫做静态变量，也叫作类变量，说明这个变量属于类的，⽽不是属于对象的被所有的对象共享，在内存中只有⼀个副本，static成员变量的初始化顺序按照定义的顺序进⾏初始化静态变量必须要静态成员才能调⽤或者访问public class Test(){//定义⼀个静态变量static String name;//这⾥定义⼀个静态⽅法注意：要想使⽤静态变量⽅法也必须定义成静态⽅法//如果不定义成静态⽅法调⽤静态变量就会报错public static void medth(){name="定义的静态变量";System.out.println(name);}public static void main(String[] args){medth();}}以上程序执⾏的结果为：定义的静态变量修饰⽅法：被static修饰的⽅法也叫做静态⽅法，因为对于静态⽅法来说是不属于任何实例对象的public class Test(){//定义⼀个静态变量static String name;//定义⼀个普通的变量int age;//定义⼀个静态⽅法public static void medth(){//打印输出静态nameSystem.out.println(name);//打印输出普通变量ageSystem.out.println(age);}public static void main(String[] args) {medth();}}以上程序执⾏的结果：age是访问不到的，会报错误：⽆法从静态上下⽂中引⽤⾮静态变量age 注：静态变量和普通变量的区别：静态变量属于类变量成员变量属于对象变量静态变量存储在⽅法区的静态区成员变量存储在内存中的堆静态变量随着类的加载⽽加载，随着类的消失⽽消失成员变量随着对象的加载⽽加载，随着对象的消失⽽消失静态通过类名调⽤成员变量通过对象调⽤特点：静态元素在类加载时就初始化了静态元素存储在静态元素区中，每⼀个类有⼀个⾃⼰的区域，与别的类不冲突静态元素只加载⼀次（只有⼀份）全部的类对象及类本⾝共享由于静态元素区加载的时候，有可能没有创建对象，可以通过类名字直接访问GC机制时⽆法管理静态元素的，可以认为是常驻内存⾮静态成员中可以访问静态成员静态成员中可以访问静态成员静态成员中不可以访问⾮静态成员在静态元素中不能出现this或supernative：本地的java源代码中看到native就已经看不到后续的代码了后续会调⽤其他语⾔C++ C执⾏的内存操作帮我们操作内存。

Java修饰符使用方法Java中的修饰符主要包括:1.访问控制符：public ,private ,protected，default .2.非访问控制符：abstract ,static ,transient ,final，native , asnchronized ,volatile .这里的访问控制符的含义为设置一种访问权限来限制其他类对本类中的成员函数及成员变量访问方式。

其中我们目前学习的是:public ,private ,protected ,static ,final .下面列举一些修饰符的主要用途。

1. 用作类修饰符的有:public：可以从其他类中被访问。

Java的类是通过包的概念来组织的，包是类的一个松散的集合。

处于同一个包中的类可以不需要任何说明而方便的互相访问和引用，而对于不同包中的类，则不行。

但当一个类被声明为public时，他就具有了被其他包中的类访问的可能性，只要这些其他包中的类在程序中使用import语句引入public类，就可以访问和引用这个类。

每个Java程序的主类都必须是public类，也是基于相同的原因。

例：（1）对于同一个包中的两个类：运行结果为：证明此时当两个类在一个包中时，一个类可对另外一个为公有类中的公有域进行访问。

（2）对于不同包的两个类此时，将同样代码的两个类分别放在不同的包中：当在引用的类中不写import该public类，得到以下结果：当添加语句import experiment1.A后，结果如下：说明了以上结果。

abstract：类中包括没有实现的方法，该类不能被实例化，抽象类就是没有具体对象的概念类。

抽象类是一种经过优化的概念组织方式：把共同特点抽象出来；其后在描述和处理某一种具体对象时，就只需描述不同的特殊之处。

这种组织方式使得所有的概念层次分明，简洁洗练，非常符合人们日常的思维习惯。

由于抽象类是它的所有子类的公共属性的集合，所以使用抽象类的一个优点就是可以充分利用这些公共属性来提高开发和维护程序的效率。

武汉理工大学计算机学院软件1002班蒋韬JA V A主要修饰符总结修饰符是用于限定类型以及类型成员的申明的一种符号。

我们此次主要讨论JAVA的访问修饰符。

常见的访问修饰符有：public：访问不受限制。

protected：访问仅限于包含类或从包含类派生的类型。

只有包含该成员的类以及继承的类可以存取.protected internal：访问仅限于当前程序集或从包含类派生的类型。

private：访问仅限于包含类型。

只有包含该成员的类可以存取.下面为了更直观的看出他们之间的区别，列出下表：下面对上面提到的修饰符做下具体介绍：一、存储与生命周期的修饰符①Abstractabstract修饰符可用来修饰类和实例成员方法用abstract修饰的类表示抽象类，抽象类不能被实例化。

没有用abstract修饰的类称为具体类，具体类可以被实例化。

用abstract修饰的方法表示抽象方法，抽象方法没有方法体。

抽象方法用来描述系统具有什么功能，但不提供具体的实现。

没有用abstract修饰的方法称为具体方法，具体方法必须要有方法体。

使用abstract修饰符需要遵守以下语法规则：（1）抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类。

如果子类没有实现父类中所有的抽象方法，那么子类也必须被定义为抽象类，否则编译出错。

（2）没有抽象构造方法，也没有抽象静态方法。

abstract class Base {abstract Base() {} //编译出错，构造方法不能是抽象的static abstract void method1(); //编译出错，static和abstract修饰符不能连用static void method2() {...} //合法，抽象类中可以有静态方法}（3）抽象类中可以有非抽象的构造方法，创建子类的实例时可能会调用这些构造方法。

抽象类不能被实例化，然而可以创建一个引用变量，其类型是一个抽象类，并让它引用非抽象的子类的一个实例。

Java中各类修饰符的使用总结（看完这篇就够了）引言：Java的修饰符根据修饰的对象不同，分为类修饰符、方法修饰符、变量修饰符，其中每种修饰符又分为访问控制修饰符和非访问控制修饰符。

访问控制存在的原因：a、让客户端程序员无法触及他们不应该触及的部分b、允许库设计者可以改变类内部的工作方式而不用担心影响到客户端程序员。

目录一、类修饰符二、方法修饰符三、变量修饰符四、访问控制修饰符总结一、类修饰符1.访问修饰符：公共类修饰符public公共类修饰符 public ： Java 语言中类的访问控制符只有 public 即公共的。

每个Java 程序的有且只有一个类是public，它被称为主类，其他外部类无访问控制修饰符，具有包访问性。

注意：一个类的内部类可以被其他访问控制修饰符protected、default、private修饰，相当于类的成员。

2.非访问控制符：抽象类修饰符 abstract 、最终类修饰符 final（1）抽象类修饰符 abstract ：用 abstract 修饰符修饰的类，被称为抽象类。

（2）最终类修饰符final ：当一个类不能被继承时可用修饰符final修饰为最终类。

被定义为 final 的类通常是一些有固定作用、用来完成某种标准功能的类。

（3）类缺省访问控制符：如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。

此时，这个类只能被同一个包中的类访问或引用。

这一访问特性又称为包访问性。

二、方法修饰符1.访问控制修饰符公共访问控制符public、保护访问控制符protected、缺省默认default、私有访问控制符private2.非访问控制修饰符抽象方法控制符abstract 、静态方法控制符static 、最终方法控制符final 、本地方法控制符native 、同步方法控制符synchronized （1）抽象方法控制符 abstract ： abstract 修饰的方法称为抽象方法。

Java中常⽤修饰符的使⽤⽅法汇总修饰符汇总：⼀：public protected default private修饰类，修饰⽅法，修饰属性，修饰代码块。

类：顶级类只能⽤public 修饰，顶级类不能使⽤private 和protected 修饰。

外部类可以被public修饰或者默认不写，不能⽤private和protected。

内部类可为静态，可⽤protected和private修饰。

⽅法：通常⽅法可以被四个访问修饰符修饰，构造⽅法也可以被四个访问修饰符修饰。

抽象类中的抽象⽅法不能被private修饰，可以被其他三个修饰。

⽽接⼝中的⽅法只能被public修饰（默认也是public）。

属性：属性可以被四个修饰符修饰，接⼝中的属性只能被public修饰（默认也是public）。

代码块：代码块不能被任何修饰符修饰（因为代码块⾥⾯是属性还是⽅法，这个属性和⽅法都有⾃⼰的修饰符）。

构造代码块的作⽤：可以初始化⾮静态属性，构造代码块优先于构造函数执⾏，可以放在构造函数中。

静态代码块的作⽤：可以初始化静态属性，类加载时加载，不可以放在构造函数中。

⼆：final：修饰类：最终类，最终类不能被继承。

最终类通常完成⼀定标准功能的类，例如Java库中的数学类Math等。

修饰⽅法：⽤final修饰的⽅法不能被继承，不能被重写(例如Object中的wait())，但是可以重载。

常量：定义局部常量⽤final，定义全局常量⽤static final （或者final static）。

三：static：修饰类：可以修饰内部类修饰属性：static可以修饰任何属性。

修饰⽅法：不能修饰抽象⽅法，不能修饰构造⽅法。

修饰代码块：被修饰的代码块叫静态代码块四：abstract修饰类（抽象类）：抽象类不能被实例化。

抽象类就是⽤来被继承的。

修饰⽅法（抽象⽅法）：能被修饰的⽅法叫做抽象⽅法，只有⽅法的声明，没有⽅法的实现，以分号结束。

不能修饰：不能修饰属性、私有⽅法、构造器、静态⽅法、final ⽅法。

java中修饰符及其⽤法
1. java中的修饰符
a. 权限修饰符
private，默认的，protected，public
b. 状态修饰符
static，final
c. 抽象修饰符
abstract
2. 类修饰符
public（访问控制符），将⼀个类声明为公共类，他可以被任何对象访问，⼀个程序的主类必须是公共类，⼀个.java⽂件中只能有⼀个public类，⽽且⽂件名必须与该类相同。

默认的，把⼀个类声明为默认的，可以被同⼀个包中的其他类使⽤。

abstract，将⼀个类声明为抽象类，抽象类中可以有抽象⽅法，也可以没有。

抽象类只能被继承不能被实例化。

final，将⼀个类声明为最终（即⾮继承类），表⽰他不能被其他类继承。

外部类不能使⽤protected、private、static等修饰符，内部类可以使⽤。

3. 成员变量修饰符
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
4. 构造⽅法修饰符
权限修饰符：private，默认的，protected，public
⽤的最多的是public
5. 成员⽅法修饰符
权限修饰符：private，默认的，protected，public
状态修饰符：static、final
抽象修饰符：abstract ⽤来修饰抽象类和接⼝中的抽象⽅法
6. ⼀些组合⽅式
成员变量：public static final
成员⽅法：
* public static
* public abstract
* public final。

Java主要修饰符的使用----武汉理工大学计算机学院软件工程 1001班王艳java中的修饰符分为类修饰符，字段修饰符，方法修饰符。

根据功能的不同，主要分为以下几种。

一、权限访问修饰符public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段。

位置private 默认protected public 同一个类是是是是同一个包内的类否是是是不同包内的子类否否是是不同包并且不是子类否否否是二、final修饰符1、final的意思是不可变，他可以修饰类、字段、方法。

修饰类后类不能被扩展（extends），也就是不能被继承。

列举：在同一个包中anarray中创建一个“父类”sortAnArray 与一个“子类”achild.“父类”前用final修饰符修饰。

代码如下：package anarray;public final class sortAnArray {int[] ar={78,1,-2,789,25,45}; public void print(){for(int i=0;i<ar.length;i++) {System.out.print(ar[i]+"\t"); }}public void CompareArray() {int i,j,temp;for(i=0;i<ar.length-1;i++){for(j=i+1;j<ar.length;j++){if(ar[j]>ar[i]){temp=ar[i];ar[i]=ar[j];ar[j]=temp;}}System.out.println();}}public static void main(String[] args){sortAnArray sr=new sortAnArray();sr.print();pareArray();sr.print();}}后创建的类不能继承该类，否则提示出错：2、修饰字段后字段的值不能被改变，因此如果有final修饰字段，应该对字段进行手动初始化。

Java作业题目Java主要修饰符的使用学院计算机科学与技术学院专业软件工程专业班级软件1002 班姓名黄彬指导教师祁明龙2012 年10 月7 日JAVA主要修饰符的使用J ava中的修饰符分为类修饰符、字段修饰符、方法修饰符。

根据功能的不同，也可以分为非访问修饰符和权限访问修饰符。

非访问修饰符主要指出了类和方法的性质及属性，是本质上的归属和划分。

有静态修饰符static，修饰属性和方法；抽象修饰符abstract，修饰类和方法；最终修饰符final，修饰类、属性和方法。

访问修饰符是一组限定类、域或方法是否被程序里的其他部分访问和调用的修饰符。

通过控制声明内容的访问权限、作用域，降低代码的耦合性，程序的复杂性，提高程序的安全性。

类的访问修饰符只有一个public，域和方法的访问修饰符有四个，分别是public、private、protected、default，另外还有一种没有定义专门的访问修饰符的缺省情况。

1、权限访问修饰符public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段，这四种权限的基本作用如下表：注：√表示可以访问，×表示不能访问。

由该表我们可以清楚的看到各个修饰符所代表的访问权限。

在修饰成员方法或成员变量时，public的权限最开放，无论在类内内外，还是包外都可以直接访问；其次是protected所修饰的权限仅在包外不能够访问，只要在同一个包内都可以访问；例如：class A{protected int weight;protected int f( int a,int b ){// 方法体}}假设B与A在同一个包中 则class B{void g(){A a=new A();A.weight=100;//合法A.f(3,4);//合法}}假设B与A 不在同一个包中 则Class B{void g(){A.a=new A();A.weight=100;//不合法A.f(3,4)//不合法}}特别说明：用package打包在一起的类在同一个包里。

Java的一些关键字及其用法访问范围private，protected，public：这种关键字又称访问权限关键字。

有private，protected，public三个。

用private声明的变量和函数只有在同一个包中的类的成员才能访问，包外的类无法访问。

用protected声明的变量和函数在同一个包中的所有类都能访问，在不同包只能通过子类来访问。

用public声明的变量和函数对所有的类公开，所有的类都可以访问它。

用法：在声明变量和函数的是写在最前面即可，如不写则默认为private。

如：private int i；protected String name；public void show()包package：这个关键字仅仅是用来声明这个java文件下的类属于哪个个包。

用法：package study.homework.math变量类型boolean，byte，char，double，float，int，long，short，void：这些都是java的基本变量类型，boolean（bool）是布尔型，byte是字节型，char是字符型，double是双精度浮点型，float是浮点型，int是整型，long是长整型，short是短整型，void是空类型。

用法：bool flag；double change；int count；类和接口class，import，extends，abstract，implements，interface，staticclass用来声明一个类。

extends用在声明类的时候声明该类的父类是什么。

abstract用在声明类时声明它是抽象类，即不能产生对象只能作为其他类的父类。

implements用来实现接口中定义的抽象方法。

import用来导入某个包中的其他类到当前文件中。

static用来声明一个类下的所有对象共享的属性。

interface用来定义接口。

用法：import study.*class B extends class A{………………}abstract class text{………………}Public interface human{Public void speak（）；}//这是接口，其中声明了方法但是没有方法的实现，而方法的实现需要由类完成。

课 程 作 业2012——2013学年 第1学期课程名称JA V A 语言程序设计 学 院 计算机科学与技术学院专 业软件工程班 级 软件1002班 姓 名王艳平Java主要修饰符的使用方法Java程序在定义类时，除了使用class关键字标识外，还可以在class之前增加若干类的修饰符限定所定义的类的特性。

1 类的修饰符分为：访问控制符和非访问控制符两大类。

1.1可访问控制符是：公共类修饰符public。

<1>当一个类被声明为public时，它就具有了被其他包中的类访问的可能性。

<2>假如一个类没有访问控制符public说明，它就具有默认的访问控制特性。

并且规定该类只能被同一个包中的类访问和引用，而不可以被其他包中的类使用。

例如：有类如下：class work2 {public work2(){}在guoqing包中定义了没有public修饰的class work2，其输出的结果为：在guoqing包中类guoqing2用import guoqing.work2.*引入了类work2.输出结果为：而在另一个包mywork中定义的类jieri却不能引入类work2。

会显示“the type guoqing.work2 is not visible”,说明当类为默认类型时，其他包中的类不可以引入，而同包可以。

1.2非访问控制符：抽象类修饰符abstract,最终类修饰符final.1.2.1抽象类修饰符abstract:<1>abstract方法只有方法头的声明，后面没有大括号包含的方法体。

例如：abstract voi performDial();<2>必须注意的是所有抽象方法，都必须存在于抽象类之中。

一个非抽象类中出现抽象方法是非法的。

例如：正确的：错误的：<3>抽象类可以有非抽象的方法。

<4>各子类在继承了父类的抽象方法之后，再分别用不同的语句和方法体来重新定义它，形成若干名字相同，返回值相同，参数列表也相同，目的一致但是具体实现有一定差别的方法。

java主要修饰符--武汉理工大学软件工程1001 舒越粗略介绍Java语言中一些修饰符的用法以及作用效果。

1 java访问修饰符1.1 publicpublic公共的、共有的意思。

Public可以用来修饰类及类中成员。

修饰类方法时，分为类中的函数和主函数，修饰主函数时，说明main（）是公有方法，它可以被任何方法访问，包括Java解释器。

例如public class HelloWorld{public static void main(String agrs[]){System.out.println("Hello world!");}}运行结果如下图：如果将主函数main(）中public删除后，运行结果如下图：因为main（）是主函数，所有程序执行的入口，因此须设为公有的，Public修饰类中方法时，主要是用于继承和调用，这也是面向对象语言一个很重要的特点。

例如：class Test01{public void Method01(){System.out.println("Hello everyone!");}}class Test02 extends Test01{public void Method02(){Method01();System.out.println("Hello world!");}}public class Test{public static void main(String agrs[]){Test02 t=new Test02 ();t.Method02();}}运行结果如下：将类Test01中的函数改为private私有之后，运行结果如下：public修饰成员变量也是一样的效果。

public修饰类时，是公共类，这里主要对比于静态类。

两者的区别在于：公共类里面的方法，必须生成对象，才能被访问；而静态类里面的方法，通过<类名.方法名>就可以访问。