❶ 简述 private、 protected、 public、 internal 修饰符的访问权限。
public：类或成员可以由同一程序集中的任何其他代码或引用它的另一个程序集访问。
private：只能通过同一个类或结构中的代码访问类型或成员。
protected：类或成员只能由同一个类中的代码访问，或者在从该类派生的类中访问。
internal：类或成员可以由同一程序集中的任何代码访问，但不能从另一个程序集访问。
(1)被哪个修饰符修饰可以被外界访问扩展阅读：
private、 protected、 public、 internal 修饰符除了可以单独使用，还可以组合使用。
protected internal：访问仅限于从包含类派生的当前程序集或类型。
private protected： 访问仅限于从当前程序集中的包含类派生的包含类或类型。
除了使用protected internal或private protected组合时，成员或类只允许使用一个访问修
饰符。名称空间上不允许访问修饰符。命名空间没有访问限制。
根据成员声明发生的上下文，仅允许某些声明的可访问性。如果在成员声明中未指定访问修饰
符，则使用默认辅助功能。
顶级类型（不嵌套在其他类型中）只能具有internal或public可访问性。这些类型的默认可访
问性是internal。
❷ Java中目前学习涉及到的四种权限修饰符都有什么并说明各自的权限范围
（1）public : 公共权限
修饰对象： 修饰类、方法、属性
继承： 被public所修饰的成员能被该类的所有子类继承下来。
作用域： 可以被任意类访问
public能用来修饰类，在一个java源文件中只能有一个类被声明为public，而且一旦有一个类为public，那这个java源文件的文件名就必须要和这个被public所修饰的类的类名相同，否则编译不能通过。说到这里，穿插多一点知识。一个类作为外部类的时候只能被public或者默认访问修饰符所修饰，但是一个类如果作为内部类的时候，则可以被四种访问修饰符所修饰，因为一个类作为内部类的时候，就作为外部类的一个成员属性了，因此可以有四种访问修饰符修饰，这是内部类和外部类的一个区别。
public用来修饰类中成员(变量和方法)，被public所修饰的成员可以在任何类中都能被访问到。通过操作该类的对象能随意访问public成员。
public在类的继承上的体现，被public所修饰的成员能被所有的子类继承下来。
（2）protected：受保护的权限
修饰对象：修饰内部类，接口，属性，方法
继承： 被protected所修饰的成员能被该类的所有子类继承下来。
作用域： 可以被同包类访问，如果不是同包，必须是该类的子类才能访问
（3）default : 同包权限(默认，缺省的)
修饰对象：修饰类，属性，方法。
继承：被default所修饰的成员只能被该类所在同一个package中的子类所继承下来。(也就是说只有在同一个package中的子类才能访问到父类中default修饰的成员)
作用域： 只能被同包的类访问
（4） private : 私有权限
修饰对象 ： 内部类，属性，方法
作用域： 只能在本类中使用
注意：
（1）protected不能修饰类。
（2）priavte可以修饰类，但是该类必须是一个内部类。
在定义类时，推荐访问控制级别从严处理：
（1） 如果不允许外部直接通过 new 创建对象，构造方法必须是 private。
（2）工具类不允许有 public 或 default 构造方法。
（3）类非 static 成员变量并且与子类共享，必须是 protected。
（4）类非static成员变量并且仅在本类使用，必须是private。
（5）类 static 成员变量如果仅在本类使用，必须是 private。
（6）若是 static 成员变量，必须考虑是否为 final。
（7）类成员方法只供类内部调用，必须是 private。
（8）类成员方法只对继承类公开，那么限制为 protected。
❸ java选择16级
java：选择20 填空题 4 改错 6个 程序设计 4
单选
1. 方法的重载是指，两个方法具有相同名称和不同的参数形式，其中不同的参数形式是指（）
A 参数个数和类型不同
B 参数有无返回值
C 方法的修饰符不同
D 以上都不对
2. 设A为已定义的类名，下列声明并创建A类的对象a的语句中正确的（）
A A a=new A ();
B public A a=A();
C A a=new class();
D a A;
3. 下列关于静态方法的描述中，错误的是（）
A 静态方法指的是被static关键字修饰的方法
B 静态方法不占用对象的内存空间，而非静态方法占有对象的内容空间
C 静态方法内可以使用this关键字
D 静态方法内部只能访问被static修饰的成员
4. 下面哪个关键字用来修饰静态（）
A static
B protected
C public
D private
5以下关于构造函数的描述错误的（）
A构造函数的返回类型只能是void类
B构造函数是类的一种特殊函数，它的方法名必须与类名相同
C构造函数的主要作用是完成对类的对象的初始化工作
D一般在创建对象时，系统会调用构造函数
**6.父子类在同一包中，子类不能继承父类的哪个属性（）
A default
B protected
C public
D private
7.下列哪个是合法的标示符
A 12class
B +void
C -5
D _black
8.下列语句中执行跳转功能的语句
A for语句
B while 语句
C continue语句
D switch语句
9.下列语句序列执行后，m的值是int m=1;for(int i=5;i>0;i--)m*=i;
A 15
B 120
C 60
D 0
**10.以下由for语句构成的循环执行的次数是for(int i=0;i>0;i++)
A有语法错误，不能执行
B 无限次
C 执行1次
D 一次也不执行
11．下面方法定义中，不正确的（）
A float x(int a,int b){return a-b;}//int可以转float
B int x(int a,int b){return a-b;}
C int x(int a,int b){return a*b;}
D int x(int a,int b){return 1.2*(a-b);} //double不能转int
**12.下列关于静态方法的描述中，错误的
A 静态方法属于类的共享成员
B 静态方法是通过“类名.方法名”的方式来调用
C 静态方法只能被类调用，不能被对象调用
D 静态方法中可以访问静态变量
13.继承的关键字是（）
A extend
B extends
C Extend
D Extends
14.下列不属于面向对象的三大特征是（B 方法）
15.下面哪种写法可以实现访问数组arr的第一个元素
A arr[0]
B arr(0)
C arr[1]
D arr(1)
16.在switch（expression）语句中，expression的数据类型不能是
A byte
B char
C float
D short
7.指出下列类型转换中正确的（）
A int i=8.3// 高类型转低类型必须强制转换
B long L=8.4f
C int i=(boolean)8.9
D double d=100
18.以下关于方法的覆盖的说法，错误的（）
A 子类的方法与父类的方法，方法名必须相同
B 子类的方法与父类的方法，参数形式必须相同
C 子类的方法与父类的方法，返回值类型必须相同
D 以上都不对
19.下面哪个关键字在定义类头时用不到
A class
B public
C extends
D int
21.在使用interface声明一个接口时，只可以使用哪个修饰符修饰该接口
A private
B protected
C private或者proteced
D public
22.下面类的定义结构正确的
A class A
B class 2A
C int class A
D public class A()
23.this 在程序中代表的是（A 类的对象）
24.在java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数，类型或顺序各不相同
A 隐藏
B 覆盖
C 重载
D Java不支持此特性
25.下面关于属性的修饰符，哪个只能在当前类中使用
A default
B protected
C public
D private
27.关于super的说法正确的是
A 是指当前对象的内存地址
B 是指当前对象的父类对象的内存地址
C 是指当前对象的父类
D 可以用在main()方法中
***28.以下的选项中能正确标示java语言中的一个整型常量是
A 12
B -20
C 1，000
D 4 5 6
29．下列数据类型的精度由高到低的顺序
A float，double，int，long
B double，float，int，byte
C byte，long，double，float
D double，int，float，long
30.下面说法正确的是
A final可修饰类，属性，方法
B abstract可修饰类，属性，方法
C 定义抽象方法需要给出方法的返回值类型，方法名，参数列表和方法体
D用final修饰的变量，在程序中可对这个变量的值进行修改
31．设int x=2,则表达式（x++）*3的值是
A 6
B 9
C 6.0
D 9.0
32.已知类的继承关系如下，class A class B extends A class C extends A 则以下语句中能
A A a=new B()
B C c=new B()
C C c=new A()
D B b=new C()
33.字符串长度正确表示
A length;
B length();
C size;
D size();
34.有一个类A，以下为其构造方法的声明，正确的
A void A（int x）
B A(int x)
C a(int x)
D void a(int x)
35.对于一个三位数的正整数n，取出它的十位数字k(k为整型)的表达式是
A k=n/10%10
B k=n%10%10
C k=n%10
D k=n/10
36.若在某一个类定义中定义有如下的方法：static void testWethod()该方法属于
A 本地方法
B 最终方法
C 静态方法
D 抽象方法
37.下列叙述正确的
A Java中允许多重继承
B Java一个类中只能实现一个接口
C Java中只能单重继承
D Java中一个类可以继承多个抽象类
**38.为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调，，，
A static void method（）
B public void method（）
C final void method（）
D abstract void method（）
***39.下面关于super说法不正确的
A 使用super，可以调用父类的构造方法
B 使用super，可以调用父类的属性
C 使用super，可以调用父类的方法
D 使用super，可以调用对象自己的属性和方法
40.在创建对象时必须
A 先声明对象，然后才能使用对象
B 先声明对象，为对象分配内存空间，然后才能使用对象
C 先说明对象，为对象分配内存空间，对对象初始化，然后才能使用对象
D 都不对
41.以下哪个接口的定义是对的
A interface B{（void print）{};}
B abstract interfance B {{void print};}
C abstract interfance B extends A1,A2{(abstract void print){};}
D interface B {void print();}
42.设X,Y 是已定义的类名，下列声明X类的对象x1的语句正确的
A static X x1(123);
B public X x1=new X(123);
C Y x1;
D X x1=X();
43将一个double类型的变量a转化成String类型时，下列语句正确的
A String s=new Double(a).toString();
B String s=a.toString();
C String s=(String) a;
D String s=new double(a).toString();
44.父子类不在同一个包中，子类能继承父类的哪个属性
A default
B protected
C static
D private
45．下面关于抽象类的描述，错误的
A 抽象类的修饰符可以收public
B 抽象类的修饰符可以是默认的
C 抽象类中的可以有抽象方法，也可以有非抽象方法
D 抽象类中的可以有抽象方法，不可以有非抽象方法
46.设定义：String s=”World”.下面哪些语句错误
A int m=s.index()f(‘r’)
B char c=s.charAt(0)
C int n=s.length()
D String str=s.append(‘2’)
47.下列类头定义中，错误的
A public x extends y
B public class x extends y
C class x extends y implements y1
D class x
48.下列单词中，不属于Java关键字的是
A NULL
B class
C this
D byte
49.有以下方法的定义，请选择该方法返回类型type method(byte x,float y) return/y*2
A byte
B short
C int
D float
50.下面哪两个关键字是类的可见修饰符
A public和默认的
B public和private
C private和默认的
D protected和morende
**51.定义抽象类的关键字
A abstract class
B final class
C static class
D public class
52.声明一个数组，_[ ] a=new String[ ]{};空格处应填
A int
B double
C String
D string
53．定义变量int i=3，那么 表达式i/6*5的计算结果是
A 0
B 1
C 2.5
D 2
54.设X,Y均为已定义的类名，下列声明类X的对象x1的语句正确的是
A X x1=new X()
B X x1=X()
C X x1=new Y()
D int X x1
55.若a 和b是整型变量并以正确赋值，以下正确的switch语句是
A switch（a+b）;{}
B switch(a+b*3.0){}
C switch a{}
D switch(a%b){}
56.下列对长度为4的数组a的定义中，正确的
A int[4] a=new int[ ];
B int a[ ]=new int[5];
C int a[ ]={2,4,2,1};
D int[4] a=new int [4]
57.下面关于String类的方法，哪个是返回值定索引位置的字符
A charAt()
B equals()
C index0f()
D replace()
58.下列对构造方法的调用方式的描述正确的
A 使用new调用
B 使用类名调用
C 使用对象名调用
D 使用方法为对象名 方法名
59.被声明为private，protected及public的类成员，在类的外部则
A 只能访问到声明为public的成员
B 只能访问到声明为public和protected的成员
C 都可以访问
D 都不能访问
60.下面哪个标识符是合法的
A #_pound
B $123+w
C 5Interstate
D a_b
61.下列语句序列执行后，i的值是int i=10; do{i/2;}while(i>1);
A 1
B 5
C 2
D 0
**62.关于数据类型转换的说法哪个不是正确的
A Java共有两种数据类型的转换方式，自动转换，强制转换
B Java中当两个类型不同的运算对象进行二元运算时，Java自动把精度较低的类型转换成另一个
C boolean型数据能和其他数据类型进行转换
D char型和int型数据可以幻想转换
63.下面关于常量的描述，正确的
A常量在主函数中可以被修改
B常量在主函数中不可以被修改
C常量一般用static来定义
D常量一定会被调用
64.下面方法定义中，正确的
A int x(){char ch=’a’;return(int)ch;}
B void x(){return true;}
C int x(){return true;}
D int x(int a,b){return a-b;}
65.面向对象程序不包含下面的哪个组成部分
A 类
B 对象
C 接口
D 程序员
66.下列选项中关于super关键字说法正确的
A super 关键字是在子类对象内部指定代其父类对象的引用
B super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C 子类通过super关键字只能调用父类的方法，而不能调用父类的属性
D 子类通过super关键字只能调用父类的属性，而不能调用父类的方法
67下列语法序列执行后，k的值是 int i=4,k=9,m=5;if(i>j||m<k)k++；else k--;
A 5
B 9
C 8
D 10
68.以下for循环的执行次数是for(int x=0;(x==0)&(x<4);x++);
A 无限次
B 1次
C 4次
D 3次
69.下面关于方法的修饰符，哪个只能在当前类中使用（D ）
A default
B protected
C public
D private
70.int a[ ]={45,4,67,23,65,87,34,56};数组中a[5]的值为
A 23
B 45
C 65
D 87
71.下列语句序列执行后，x的值是
int a=4,b=1,x=6;if(a==b)x+=a else x=++a*x;
A 15
B 30
C 25
D 5
72.有以下代码，运行完后最终值是int i=1;int j=i++;if((i>++j)&&(i++==j)) i+=j;
A 1
B 2
C 3
D 4
73.下面关于get和set方法叙述正确的
A 两个方法一般都使用this关键字
B 两个方法一般都不使用this关键字
C set方法不能使用this关键字
D get方法不能使用this关键字
74.下面关于类的结构说法正确的
A类只能包含一个构造方法
B类可以没有属性
C类只能包含方法
D类只能包含属性
75.下面哪个关键字用来修饰常量
A static
B final
C public
D private
76.有以下代码，其中变量i可能额类型死switch（i）{default :System.out.println(“hello”);}
A byte
B long
C double
D A and B
77.将一个整型转换成字符串的正确表示是
A Integer.parseInt(123)
B String.parseStrng(123)
C Integer.valueOf(123)
D String valueOf(123)
78.以下for循环的执行次数是for(int x=0;(x=0)&(x>4);x++)
A无限次
B一次也不执行
C4次
D3次
79.设有定义float x=3.5f,y=4.6f,r=5.7f;则以下的表达式中，值为true的
A x>y||x>z
B x !=y
C z>(y+x)
D y>z
80.现有一个变量声明为boolean aa;下面赋值语句中正确的是
A aa=false
B aa=False
C aa=true
D aa=0
81.下面关于get和set方法的叙述，正确的是
A两个方法一般都有返回值
B两个方法一般都没有返回值
C get方法一般有返回值
D set方法一般有返回值
82.下列方法定义中，方法头不正确的是
A double m(int m){ }
B void m(int m){ }
C public int m(int m, int n){ }
D m(int h,int m,int n){ }
83.下面关于多态性的说法，正确的是（）
A 一个类中不能有同名的方法
B 子类中不难有和父类中同名的方法
C 子类中可以有和父类中同名且参数相同的方法
D 多态性就是方法的名字可以一样，但返回的类型必须不一样
84.静态方法的描述错误的（C静态方法只能被类调用，不能被对象调用）
85．下面哪个标识符是合法的（D a_ b）
86.下面关于多态性的说法正确的（C子类中可以有和父类中同名且参数相同的方法）
87.对java语言的叙述错误的（B Java中执行跳转功能的语句是switch）
88.Java语言中占用32位存储空间的是（D int，float）
89.下面关于属性的修饰符，（D private）只能在当前类中使用
90.定义类投时，不可能用到的关键字（D static）
91．下列对构造方法的调用方法的描述正确的（A 使用new调用）
92.为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该…（A static void method（））
93.以下由for语句构成的循环执行的次数是（一次也不执行）
94.下面正确的main方法是（C public static void main（String[] args））
95.下列选项中关于super关键字说法正确的是（A super关键字是在子类对象内部指代其父类对象的引用）
96.以下for循环的执行次数for(int x=0;(x==0&(x>4);x++))（B 一次也不执行）
97.若a和b是整型变量并以正确赋值，以下正确的switch语句是（D switch（a%b） {}）
98.关于对象数组的叙述正确的（B对数组里的每个元素都是那个对象的引用）
99.已知x和y均为boolean型变量，则x&&y的值为true的条件是（C x和y均为true）
100.设 int x=1,y=2,z=3,则表达式y+=z--/++x中y的值（A 3）
101.构造方法的调用方式正确的（C 只能通过new自动调用）
102.方法定义中，正确的是（A int x(){char ch=’a’,return(int)ch;}）
103.方法定义中，方法头不正确的（D m (int h, int m, int n){}）
104.覆盖与重载的关系（A 覆盖只有发生在父类与子类之间，而重载可以发生在同一个类在中）
105.关于Java源文件说法正确的是（A 一个Java源文件中只能有一个public修饰的类）
106.关于类的继承描述正确的（B 一个类可以具有多个子类）
107.关于super的说法正确的是（B 是指当前对象的父类对象的内存地址）
108.下面关于String类的方法，哪个是返回指定索引位置的字符（A charAt()）
109.定义一个接口时，哪个关键字用不到（D class）
110.修饰符中，成员内部被（C public）修饰后，可以被外界访问
111.this在程序中代表（A类的对象）
112.下列语句序列执行后，i的值(C 24)
Int s=1;i=1;
While(i<=4){
s=s*i;
i++;}
113.下列语句序列执行后，k的值(D 54)
Int x=6,y=10,k=5;
Switch(x%y){
Case 0:k=x*y;
Case 6:k=x/y;
Case 12:k=x-y;
Default:k=x*y-x;}
114.Java支持的3种跳转语句不包括（D goto语句）
115.字符串长度的正确表示（B length（））
❹ java 中有多少修饰符，它们的访问权限又是什么
楼主问的是访问控制符，只有访问控制符才说访问权限
JAVA里面 准确来讲是有四个访问控制符 默认、public、private、protected等四个
pravite 只能在同一个类中访问
protected，可以在同一个类、同一个包、不同包中的子类访问
默认：在同一个类、同一个包中访问
public 同一个类，同一个包、不同包中的子类、不同包中的非子类
不知道楼主问的是不是这，如果不是可以再留言
❺ java中修饰符有哪些
java的修饰符有：权限修饰符：public、protected、default、private
修饰符：abstract、static、final
public 使用对象：最广，类、接口、变量、方法
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：可以当做普通类使用，而不用先实例化一个外部类。（用他修饰后，就成了静态内部类了）
strictfp：（java关键字） 即 strict float point (精确浮点)。（可修饰类、接口、方法）
(5)被哪个修饰符修饰可以被外界访问扩展阅读：
java中的类修饰符、成员变量修饰符、方法修饰符。
类修饰符：
public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。
abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。
final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。
friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。
成员变量修饰符：
public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
friendly ，在同一个包中的类可以访问，其他包中的类不能访问。
final，最终修饰符，指定此变量的值不能变。
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。
volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。
方法修饰符：
public（公共控制符）
private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）
protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。
final，指定该方法不能被重载。
static，指定不需要实例化就可以激活的一个方法。
synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。
❻ java中类成员的访问修饰符有哪些
一：访问修饰符：
1.省略访问修饰符
具有默认的访问特性，即具有包访问特性，只能被同一个包中的类使用。
2.public访问修饰符
用于说明类和类的成员的访问权限。这种类叫公有类。在一个文件中只能有一个public类型的类。
例如：Rect和UseImport两个类，分别在两个不同的包中。顺便回顾一下不同类要用import导入。（哎，一直就没记住）
//Rect.java
pacakage my;
public class Rect
{
private int a,b;
public void init(int len,int width)
{
a=len;
b=width;
}
public int area()
{
return a*b;
}
}
//UseImport.java
import.my.*;//导入my 包的所有类
public class UseImport
{
public static void main(string[] args)
{
Rect x=new Rect();
x.init(2,3);
System.out.println("矩形面积为："+x.area());
}
}
3.private
用private修饰的类成员成为私有成员，只能在声明该成员的类中使用，不能在类外使用。一般通过本类中公有方法进行访问。
4.protected
protected修饰的类成员为保护成员，可以被三种类使用，分别是该类本身，该类的所有子类，该类同包的其他类，该类的子类。
5.private protected
私有保护成员。可被两种类使用。分别是：该类本身和该类的所有子类。
二：特征修饰符
1.abstract：抽象
修饰类为抽象类，修饰方法为抽象方法。只要类中有抽象方法，就必须定义为抽象类。抽象方法只能声明，不能实现。但是可以在其子类中对抽象方法进行实现。抽象类中也可以包含非抽象方法。
2.final：最终
修饰的类为终止类，不能有子类。修饰变量为终止变量，只可赋值一次。修饰方法为终止方法，不能在子类中更改。如Socket、ServerSocket等都是final类，防止黑客派生子类进行破坏。同时，final与abstract是相互矛盾的。
3.static：静态
静态成员无需通过对象调用，可以直接通过类名直接调用。
public class RectArea//输出6 和 12
{
public static void main(String[] args)
{
System.out.println(area(2,3));
System.out.println(area(3,4));
}
static void area(int a,int b)
{
return a*b;
}
}
4.native
用native修饰的为本地方法。它修饰的方法在程序外部使用其他编程语言编写。（这个步骤比较多，所以就木有继续研究了）
5.synchronized
修饰的方法为同步方法。
❼ java中四种访问权限修饰符的各种情况介绍（最好是个人心得!!）、简明易懂些的
访问修饰符有四种public protected 默认的不写的 private
要区分的重点 在同包中的类和不同包中类中的访问 （注意这里是指类和类之间的访问权限）
同包的类是指写在一个文件夹中的类，不同包中的类是指写在不同文件夹中的类（如不同项目和不同包都是这个范畴）
下面关键的权限问题了
public 访问权限最大，同包（同文件夹）里面的类绝对是可以互相访问的，不同包中的类只要经过import得到了路径后也是可以通过类的对象访问的
protected 和 默认的比public访问权限都要小（不能在其他包中被访问除非继承这里是指protected）但他们两之间有细微的区别就是在不同包中的类继承protected和 默认的时候 ,继承的类能够访问用protected修饰的成员而不能访问默认即不写修饰符的成员
private 范围最小 只能在类内部的成员之间进行访问，外部的类是绝对没有办法通过对象访问到私有成员的,继承的类也不会继承private的成员（完全手打）
❽ 访问修饰符有4个分别是public，private，protected，default。请问下怎么使用分别什么时候用
java作用域public ,private ,protected 及不写时的区别
在说明这四个关键字之前，我想就class之间的关系做一个简单的定义，对于继承自己的class，base class可以认为他们都是自己的子女，而对于和自己一个目录下的classes，认为都是自己的朋友。
1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用
2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。
3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。
4、default 则在包内包外的子类都可见。
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
❾ 请问：java类成员访问修饰符的限制范围
public：Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。
private:Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。
protect:介于public和private之间的一种访问修饰符，一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
default：即不加任何访问修饰符，通常称为“默认访问模式“。该模式下，只允许在同一个包中进行访问。
❿ java 中的修饰符有那几个,它们的访问权限的范围是多少
java中的修饰符分为类修饰符，字段修饰符，方法修饰符。根据功能的不同，主要分为以下几种。
1、权限访问修饰符
public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段。
包外 子类 包内 类内
public yes yes yes yes
protected no yes yes yes
default no no yes yes
private no no no yes
2、final修饰符
final的意思是不可变，他可以修饰类、字段、方法。修饰类后类不能被扩展（extends），也就是不能被继承。修饰字段后字段的值不能被改变，因此如果有final修饰字段，应该对字段进行手动初始化。修饰方法后该方法不能被改变，也就是重写。
3、abstract修饰符
abstract是抽象的意思，用来修饰类和方法，修饰类后，该类为抽象类，不能被实例化，必需进行扩展。修饰方法后，该方法为抽象方法必须被子类重写（override）。
4、static修饰符
static用来修饰内部类，方法，字段。修饰内部类说明该内部类属于外部类而不属于外部类的某个实例。修饰字段说明该字段属于类而不属于类实例。修饰方法说明该方法属于类而不属于类实例。