java成员变量和方法的public等访问限定符的访问权限

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：可以当做普通类使用，而不用先实例化一个外部类。

public在java中的作用public是Java中的一个访问修饰符，它可以应用在类、方法和变量上。

下面将介绍public在Java中的作用以及相关参考内容。

1. 类的作用：在Java中，可以使用public修饰类，这样可以使得该类可以在任意的包中被访问和使用。

一个类只能有一个public修饰符，并且这个类的名称要与文件名相同。

参考内容：- 《Java核心技术卷一》（原书第10版）- 有关修饰符的讲解- 《深入理解Java虚拟机：JVM高级特性与最佳实践》(第3版) - 对访问修饰符的意义和使用的详细解释2. 方法的作用：使用public修饰的方法可以被任何类和对象访问，无论是否处于同一个包中。

public方法是类对外提供的对外接口，供其他类调用。

参考内容：- 《Java编程思想（第四版）》- 对访问修饰符的介绍和使用案例- 《Effective Java》（第3版） - 对访问修饰符的最佳实践和使用场景进行解释3. 变量的作用：使用public修饰的变量可以被任何类和对象访问，无论是否处于同一个包中。

public变量是对外公开的数据，可以供其他类读取和修改。

参考内容：- 《Java编程思想（第四版）》- 对访问修饰符的介绍和使用案例- 《Effective Java》（第3版） - 对访问修饰符的最佳实践和使用场景进行解释总结：通过以上介绍可以看出，public修饰符在Java中的作用主要是对外公开和访问控制。

- 对于类，使用public修饰符可以使得该类可以在任意的包中被访问和使用。

- 对于方法，public修饰符可以使得方法对外开放，方便其他类进行调用。

- 对于变量，public修饰符可以将变量对外公开，以供其他类进行读取和修改。

使用public时需要注意：- 对于类和方法，仅在需要对外公开使用的时候使用public修饰符，减少不必要的访问权限。

- 对于变量，建议使用private修饰符，并提供公开的访问方法（如get和set方法）来提供对外的访问接口。

java中修饰符的限制范围Java 是一种面向对象的编程语言，其中修饰符是用于限制代码可见性、修饰类、方法、变量等的重要机制。

掌握不同修饰符的限制范围和应用场景对于Java 开发者至关重要。

一、概述Java 修饰符Java 修饰符分为以下几种：1.访问修饰符：用于控制类、方法、变量的可见性，包括public、private、protected 和默认（friendly）四种。

2.非访问修饰符：包括final、volatile、transient、static、synchronized、native、const 和volatile 等。

二、限制范围的作用访问修饰符的限制范围如下：1.public：表示公共的，可以被任何类访问，包括其他包中的类。

2.private：表示私有，只能在本类中访问。

3.protected：表示受保护，可以被以下三种情况访问：a.同一个包中的类。

b.子类（继承关系）。

c.同一个包中的静态方法。

4.default（友好访问符）：表示默认访问权限，相当于protected。

可以被同一个包中的类访问，但不能被其他包中的类访问。

三、不同修饰符的应用场景1.访问修饰符：- public：适用于需要与其他类共享的类、方法或变量。

- private：适用于类的内部实现，建议将私有方法设置为final，以防止子类覆盖。

- protected：适用于需要子类继承或扩展的类、方法或变量。

- default：适用于包内访问，但不希望被其他包访问的类、方法或变量。

2.非访问修饰符：- final：表示不可变，适用于常量、方法（防止被子类覆盖）和类（表示类不可继承）。

- volatile：表示变量在多个线程之间的可见性，适用于共享变量。

- transient：表示变量在垃圾回收时的处理，适用于生命周期较短的变量。

- static：表示静态，适用于静态方法、静态变量，以及类的初始化。

- synchronized：表示同步，适用于需要线程安全的方法或代码块。

java⾯向对象中四种权限（private，protected，public，友好型）详解俗话说没有规矩就没有⽅圆，java作为⼀门严谨的⾯向对象的⾼级编程语⾔，⾃然对权限整个重要的问题有严格的控制。

Java⼀共有四种权限，private (私有)，public（公有）。

Protected（受保护）还有友好型。

在java⾥，这些语句都可以修饰类中的成员变量和⽅法，但是只有public和友好型可以修饰类。

1. 不⽤priavate，public，protected修饰的成员变量和⽅法被称为友好变量和友好⽅法2. 当在另外⼀个类B中，⽤该类A创建了⼀个对象后，如果类A和类B在同⼀个包中，那么该对象能访问⾃⼰的友好变量和友好⽅法3. 在class前⾯加public的类称为public类，class前⾯不能加protected和private，不加public的类称为友好类。

4. public类默认的构造⽅法是public，友好类默认的构造⽅法是友好的。

举个例⼦：接下来就详细解释⼀下这⼏种权限的差别(博客最后有表格）按权限由低到⾼：（⾼权限有低权限所有特性）Private：类中的所有private⽅法和private 成员变量只能在类中访问⽽不能在其他类中访问。

例如：[java]1. package Main;2.3. public class Private {4. private int a;5. private int b;6. Protected (){7. this.a=1;8. this.b=2;//a和b只能在Private类中调⽤9. }10. private void set(){11. System.out.println(""+a+""+b+"\n");12. }13. void Print(){14. this.set();//只能在这⾥⽤；15. }16. }友好型和protected：如果在另⼀个类中声明其他的⼀个类，如果这两个在⼀个包中那么另⼀个类能访问这个其他类的友好型变量不同包不能访问：如果在另⼀个B类中声明其他的⼀个类A，如果这两个在⼀个包中那么另⼀个类B也能能访问这个其他类A的protected变量（或⽅法），如果不在⼀个包，那么如果类A有⼀个⽗类C如果，如果⽗类C中有⼀个protected变量（或⽅法），只要B，C 在⼀个包中，B就能使⽤A中从⽗类继承的protected⽅法。

Java访问权限控制Java访问权限控制修饰符⽤来定义类、⽅法或者变量，通常放在语句的最前端。

Java语⾔提供了很多修饰符，主要分为以下两类：访问修饰符⾮访问修饰符其中⾮访问修饰符主要有：static、final、abstract、synchronized和volatile，⾮访问修饰符根据各⾃的特性来保证特定功能的实现。

Java中使⽤访问控制符来保护对类、变量、⽅法和构造⽅法的访问，访问控制修饰符对应的权限控制的⼤⼩情况为：public > protected > default(包访问权限) > private。

1. 编译单元和包编译单元：即为最⼩的可以被编译且执⾏的Java⽂件。

⼀个.java⽂件就是⼀个编译单元，⼀个编译单元必须只包含有⼀个public类，可以包含有其他⾮public的类，并且⽤publi类标⽰的类名必须和⽂件名相同。

如果.java⽂件中不包含有publi类，则这个类也是没有意义的，因为不能被外界所访问。

.java⽂件中包含有⼏个类，编译后就会⽣成⼏个.class⽂件。

包含有⼀组类，是以⼀个名字空间集合在⼀起的类⽽已。

2. 访问控制修饰符public : 对所有类可见使⽤对象：类、接⼝、变量、⽅法protected : 对同⼀包内的类和所有⼦类可见使⽤对象：变量、⽅法。

注意：不能修饰类（外部类）default (即缺省，什么也不写）: 在同⼀包内可见，不使⽤任何修饰符使⽤对象：类、接⼝、变量、⽅法。

private : 在本类中可见使⽤对象：变量、⽅法。

注意：不能修饰类（外部类）private和protected修饰符不能⽤以修饰类/接⼝2.1 公有访问修饰符-public被声明为 public 的类、⽅法、构造⽅法和接⼝能够被任何其他类访问。

如果⼏个相互访问的 public 类分布在不同的包中，则需要导⼊相应 public 类所在的包。

由于类的继承性，类所有的公有⽅法和变量都能被其⼦类继承。

java四种访问权限实例分析引⾔Java中的访问权限理解起来不难，但完全掌握却不容易，特别是4种访问权限并不是任何时候都可以使⽤。

下⾯整理⼀下，在什么情况下，有哪些访问权限可以允许选择。

⼀、访问权限简介访问权限控制：指的是本类及本类内部的成员（成员变量、成员⽅法、内部类）对其他类的可见性，即这些内容是否允许其他类访问。

Java 中⼀共有四种访问权限控制，其权限控制的⼤⼩情况是这样的：public > protected > default(包访问权限) > private ,具体的权限控制看下⾯表格，列所指定的类是否有权限允许访问⾏的权限控制下的内容：访问权限本类本包的类⼦类⾮⼦类的外包类public是是是是protected是是是否default是是否否private是否否否1、public：所修饰的类、变量、⽅法，在内外包均具有访问权限；2、protected：这种权限是为继承⽽设计的，protected所修饰的成员，对所有⼦类是可访问的，但只对同包的类是可访问的，对外包的⾮⼦类是不可以访问；3、包访问权限（default）：只对同包的类具有访问的权限，外包的所有类都不能访问；4、private：私有的权限，只对本类的⽅法可以使⽤；注意：要区分开 protected 权限、包访问权限，正确使⽤它们；当某个成员能被所有的⼦类继承，但不能被外包的⾮⼦类访问，就是⽤protected；当某个成员的访问权限只对同包的类开放，包括不能让外包的类继承这个成员，就⽤包访问权限；使⽤访问权限控制的原因：1）使⽤户不要碰触那些他们不该碰触的部分；2）类库设计者可以更改类的内部⼯作的⽅式，⽽不会担⼼这样会对⽤户产⽣重⼤影响；⼆、访问权限控制的使⽤场景访问权限使⽤的场景可以总结为下⾯的五种场景，分别对访问权限的使⽤有不同的限制：1. 外部类的访问控制外部类（外部接⼝）是相对于内部类（也称为嵌套类）、内部接⼝⽽⾔的。

JAVA篇：修饰符与接⼝、类、⽅法、成员变量、局部变量、⽅法块或许这是⼀个⽐较轻松简单的知识点，因为只是简单地做⼀个总览对⽐⽽已。

这周⽐较忙，祝我⾃⼰好运。

有关接⼝(interface)的修饰符，其实⼀般⽤public，也可以不加修饰词（default），或者是使⽤private修饰的声明在类的内部的内部接⼝。

不存在protected修饰的接⼝。

⽽接⼝内部可以有⽤public static final修饰的静态常量，除此之外只存在public修饰的⽅法（接⼝中⽆修饰词的⽅法也默认是public）了。

⽆论是接⼝还是接⼝中的⽅法的abstract修饰词都是隐含的，不必显式地修饰在接⼝或者⽅法前⾯。

类的访问限制修饰词与接⼝⼀样，但是还可以有⾮访问限制修饰词abstract(抽象类)和final(不可继承的类)。

类的成员变量可以被四种访问修饰词修饰，同时也可以被static(静态变量),final(常量),transtient(有关序列化特殊标识变量,具体还需要进⾏了解), volatie(线程共享变量)。

类⽅法除了访问限制修饰符，还可使⽤static（静态⽅法）,final(不可改变的⽅法),abstract(抽象的),native(⾮java实现的),synchronized(线程同步),类构造⽅法只可使⽤访问限制修饰符修饰，局部变量只能使⽤final定义常量,⽅法块可以使⽤static定义静态⽅法块和使⽤synchronized 定义线程同步的⽅法块。

java的接⼝、类1、接⼝(interface) 在java中，接⼝是⼀个抽象类型，是抽象⽅法的集合，接⼝通常以interface来声明，接⼝只能包含抽象⽅法和以static\final修饰的变量，⼀个接⼝可以继承（extends）另⼀个接⼝。

接⼝只包含要实现的⽅法，⽽类描述对象的属性和⽅法，两者实现类似但是概念不同。

java提供了类和接⼝之间的实现机制，接⼝不可被实例化，只能被实现（implements），实现接⼝的类必须实现接⼝中全部的抽象⽅法，否则该类必须使⽤abstract声明为抽象类。

C++类成员的访问权限及继承⽅式（public,protected,private）1、访问权限C++通过 public、protected、private 三个关键字来控制成员变量和成员函数的访问权限，它们分别表⽰公有的、受保护的、私有的，被称为成员访问限定符。

所谓访问权限，就是你能不能使⽤该类中的成员。

在类的内部（定义类的代码内部），⽆论成员被声明为 public、protected 还是 private，都是可以互相访问的，没有访问权限的限制。

在类的外部（定义类的代码之外），只能通过对象访问成员，并且通过对象只能访问 public 属性的成员，不能访问 private、protected 属性的成员。

类成员的访问权限由⾼到低依次为 public --> protected --> private。

2、继承⽅式public、protected、private 指定继承⽅式不同的继承⽅式会影响基类成员在派⽣类中的访问权限。

1) public继承⽅式基类中所有 public 成员在派⽣类中为 public 属性；基类中所有 protected 成员在派⽣类中为 protected 属性；基类中所有 private 成员在派⽣类中不能使⽤。

2) protected继承⽅式基类中的所有 public 成员在派⽣类中为 protected 属性；基类中的所有 protected 成员在派⽣类中为 protected 属性；基类中的所有 private 成员在派⽣类中不能使⽤。

3) private继承⽅式基类中的所有 public 成员在派⽣类中均为 private 属性；基类中的所有 protected 成员在派⽣类中均为 private 属性；基类中的所有 private 成员在派⽣类中不能使⽤。

C++继承的⼀般语法为：class 派⽣类名:［继承⽅式］基类名{派⽣类新增加的成员};下⾯⽤多级继承的例⼦来说明public、protected、private的关系，如下：1 #include<iostream>2using namespace std;3//基类People4class People{5public:6void setname(char *name);7void setage(int age);8void sethobby(char *hobby);9char *gethobby();10protected:11char *m_name;12int m_age;13private:14char *m_hobby;15 };16void People::setname(char *name){ m_name = name; }17void People::setage(int age){ m_age = age; }18void People::sethobby(char *hobby){ m_hobby = hobby; }19char *People::gethobby(){ return m_hobby; }20//派⽣类Student21class Student: public People{22public:23void setscore(float score);24protected:25float m_score;26 };27void Student::setscore(float score){ m_score = score; }28//派⽣类Pupil29class Pupil: public Student{30public:31void setranking(int ranking);32void display(); //显⽰输出函数33private:34int m_ranking;35 };36void Pupil::setranking(int ranking){ m_ranking = ranking; }37void Pupil::display(){38 cout<<m_name<<"的年龄是"<<m_age<<"，考试成绩为"<<m_score<<"分，班级排名第"<<m_ranking<<"，TA喜欢"<<gethobby()<<"。

但是对象的引用与内存地址无关，不能计算。利用 this 可以调用当前对象的方法或使用当前对象的域。 7. super：代表是直接父类，通过它来引用父类的成员。 8. 多态：指一个程序中同名的不同方法共存的情况。可以表现为子类对父类方法的覆盖，也可以表现为一个类中
方法的重载，还可以将子类的对象作为父类的对象实现对象的多态。 9. 对象引用的多态：即对象的引用型变量具有多态性。因为子类对象可以作为父类对象来使用，但是父类对象不
4. Java是区分大小写的语言，关键字的大小写不能搞错，如果把类class写成Class或者CLASS，都是错误的。 （）T
5. Java源程序编写好之后，以文件的形式保存在硬盘或U盘上，源文件的名字可以随便取的，它不一定与程序 的主类名一致。（）F
6. 在JDK命令行开发工具中，用编译程序javac.Exe编译生成的文件是二进制可执行文件。（）F
}
第4章
通过_______运算符就能实现对对象成员变量的访问和对象方法的调用。（圆点） 类的构造方法的名称必须与_______名相同。（类）
简述题
1. 什么是类？什么是对象？类和对象有何联系？ 1. 答：在面向对象程序设计里，类是定义一个对象的属性和方法的蓝本。对象就是一组变量和相关方法的集
合，其中变量表明对象的状态，方法表明对象所具有的行为。类是对象的模板，对象是类的实例，可以从一个类中 创建许多对象。
简述题 1. 方法的重载和方法的覆盖有什么不同？
答：方法重载，指的是在类中创建多个具有相同名称，但使用不同参数的方法，Java虚拟机根据传递给方法的参数 个数和类型决定调用哪个重载方法。方法的覆盖指在子类中重新定义父类中已有的方法，对于重写的方法，运行时 系统根据调用该方法的实例的类型来决定选择哪个方法调用。

高级语言程序设计（Java）——在线考试一、单选题1.下列哪一个包给出了Runnable接口的定义?( )A.iava.utilB.java.iongD.java.sql2.下列( )属于Java线程同步方法。

A.joiny( )B.run( )C.wait( )D.destroy( )3.下列方法中可以用来创建一个新线程的是( )。

A.实现ng.Runnable接口并重写start( )方法B.实现ng.Runnable接口并重写run( )方法C.实现ng.Thread类并重写run( )方法D.实现ng.Thread类并实现start( )方法4.在Applet应用程序中,为了执行窗体的刷新,下列( )调用方式是正确的。

A.paint( );B.repaint( );C.paint(g);D.update(g);5.main( )方法的返回类型是( )。

A.intB.voidC.booleanD.static6.为了区分重载多态中同名的不同方法,要求( )。

A.采用不同的形式参数列表B.返回值类型不同C.调用时用类名或对象名做前缀D.参数名不同7.有程序片段如下,以下哪个表示式的结果为true?( )A.s==tB.s.equals(t)C.u.equals(s)D.t.equals(u)8.设有定义语句int a[]={66,88,99};则以下对此语句的叙述错误的是( )。

A.定义了一个名为a的一维数组B.a数组有3个元素C.a数组的下标为1~3D.数组中的每个元素都是整型9.有语句String s = ”hello world”;以下操作哪个是不合法的?( )A.s>>>=1;B.int i = s.length();C.String ts = s.trim();D.String t = s+”!”;10.下列关于作用域的说法中,正确的是( )。

A.不同方法中声明的不同变量,可以互相访问B.在不同方法中可以声明相同数据类型的同名局部变量C.在同一个类中可以声明相同数据类型的同名类变量D.在同一个程序块中可以声明相同数据类型的同名变量11.下列关于类、包和源文件的说法中,错误的一项是( )。

1.什么是对象、类，它们之间的联系？答：1）对象是包含现实世界物体特征的抽象实体，它反映系统为之保存信息和与它交互的能力。

对象是一些属性及服务的封装体，在程序设计领域，可以用“对象=数据+作用于这些数据上的操作”来表示。

现实生活中对象是指客观世界的实体；在程序中对象是指一组变量和相关方法的集合。

2）类是既有相同操作功能和相同的数据格式的对象的集合与抽象！3）两者的关系：对象是类的具体实例.。

2.什么是面向对象的程序设计方法？它有那些基本特征？答：面向对象程序设计从所处理的数据入手，以数据为中心而不是以服务为中心来描述系统。

它把编程问题视为一个数据集合，数据相对于功能而言，具有更强的稳定性。

它的特征：抽象，封装，继承，多态。

4．请解释类属性、实例属性及其区别。

答：实例属性，由一个个的实例用来存储所有实例都需要的属性信息，不同实例的属性值可能会不同。

5．请解释类方法、实例属性及其区别。

答：实例方法表示特定对象的行为，在声明时前面不加static修饰符，在使用时需要发送给一个类实例。

类方法也称为静态方法，在方法声明时前面需加static修饰符，类方法表示具体实例中类对象的共有行为。

区别：实例方法可以直接访问实例变量，调用实例方法，实例方法可以直接访问类变量，调用类方法；类方法可以直接调用类变量和类方法，类方法不能直接调用实例变量和实例方法；6．类的访问控制符有哪几种？具体含义及其区别。

答：类的访问控制符只有public（公共类）及无修饰符（默认类）两种。

区别：当使用public修饰符时表示所有其他的类都可以使用此类；当没有修饰符时，则只有与此类处于同一包中的其他类可以使用类。

7类成员的访问控制符有哪几种?他们对类成员分别有哪些访问限制的作用?答:类成员的访问控制符有public,private,protecte及无修饰符.public(公有的):用public修饰的成分表示公有的,也就是它可以被其他任何对象访问(前提是对累成员所在的类访问有访问权限).Private(保护的)：类中限定为private的成员只能被这个类本身访问，在类外不可见。

训练题二一、选择题1.下列哪种类成员修饰符的变量只能在本类中被访问?( D )A. protectedB. publicC. defaultD. private2.在java语言的哪一个包是编译器自动导入的?( A )A. ngB. java.awtC. jva.ioD. java.applet3.给出下面的程序代码:class Test3{ private float a;public static void m(){ // …}}如何使成员变量a被方法m()直接访问?( C )A.将private float a改为protected float aB.将private float a改为public float aC.将private float a改为static float aD.将private float a改为float a4.已知有下面的类说明:public class Test4{ private float f=1.0f;.int m=12;static int n=1;public static void main(String[] args){ Test4 e=new Test4();}}在main()方法中，下面哪个的使用是正确的( A )?A. e.fB. this.nC. Test4.mD. Test4.f5.有一个类A，下面为其构造函数的声明，其中正确的是( B )。

A. void A(int x){ … }B. A(int x) { … }C. a(int x){ … }D. void a(int x){ … }6.在下面的程序源代码文件Test6.java中，哪个是正确的类的定义?( B )A.public class test6{B. public class Test6{public int x=0; public int x=0;public test(int x) public Test6(int x){ this.x=x; { this.x=x;} }} }B.class T1{ } D. class T2{ }class T2{ } protected class Test6 extends T2 public class Test6 extends T1, T2 { public int x=0;{ public int x=0; public Test6(int x)public Test6(int x) { this.x=x;{ this.x=x; } }} }7.main()方法是Java Application程序执行的入口点，关于main()方法的方法头下面哪一项是合法的?( B )A. public static void main()B. public static void main(String args[])B. public static int main(String[] arg) D. public void main(String args[])8.下列程序的执行结果是( A )public class Test8{ public void aMethod(){ static int i=0;i++;System.out.println(i);}public static void main(String args[]){ Test8 obj=new Test8();obj.aMethod();}}A. 编译错误B. 0C. 1D. 运行成功，但不输出9.下面哪一项的方法调用能填入程序中的横线外?( C )class CC9{ static void method(){ System.out.println(“in CC9”); }}class CC9_1{ void method(){ System.out.println(“in CC9_1”); }}public class ex9{ public static void main(String[] args){ ex9 e=new ex9();e.method();}public void method(){ CC9 o1=new CC9();CC9_1 o2=new CC9_1();______________________}}A. o1.method();B. CC9.method();C. CC9.method();D. o1.method(); ex9.method(); CC9_1.method(); o2.method(); CC9_1.method();10.为了区分类中重载的同名的不同方法，要求( A )A. 采用不同的形式参数列表B. 使用不同的参数名C. 修改访问权限D. 返回值的数据类型不同11.若需要定义一个静态域，应使用哪一个修饰符?( A )A. staticB. synchronizedC. privateD. protected12.设i,j为类X定义的double型成员变量名，下列X的构造函数中不正确的是(D )A. X(double k){ i=k; }B. X(double m, double n){ i=m; j=n; }C. X(){ i=6; }D. double X(double k){ i=k; return i; }13.设A为已定义的类名，则下列声明A类的对象a的语句中正确的是( A )A. public A a=new A();B. public A a=A();C. A a=new class();D. a A;14.为AB类的一个无返回值的方法method书写方法头，使得使用类名，AB作为前缀就可以调用它，该方法头的形式为( D )A. abstract void method()B. public void method()C. final void method()D. static void method()15.下面哪个保留字可以定义常量变量，说明这个变量赋值后永不改变? ( C )A. protectedB. staticC. finalD. super16.下列哪个不是创建数组的正确语句? ( C )A. float f[][]=new float[6][6];B. float []f[]=new float[6][6];C. float f[][]=new float[][6];D. float [][]f=new float[6][];17.设X，Y为已定义的类名，下列声明X类的对象x1的语句中正确的是( A )A. static X x1;B. public Y x1=new X(int 123);C. Y x1;D. X x1=X();18.下列关于类说法不正确的是( D )A. 类是同种对象的集合和抽象B. 类属于Java语言中的复合数据类型C. 对象是Java语言中的基本的结构单位D. 类就是对象19.下面关于Java语言中的方法说法不正确的是( C )A. Java中的方法的参数传递是传值调用，而不是地址调用B.方法体是对方法的实现，包括变量声明和Java合法语句C.如果程序定义了一个或多个构造方法，在创建对象时，也可以用系统自动生成空的构造方法D.类的私有方法不能被其子类直接访问解析：如果程序定义了一个或多个构造函数，在创建对象时，必须用自定义的构造方法来初始化，若没有定义构造方法，则使用默认的构造方法。

第三章面向对象程序设计一、选择题1.下列不属于面向对象编程的三个特征的是(B)A.封装B.指针操作C.多态性D.继承2.类所实现的接口以及修饰不可以是(D)A.publicB.abstractC.finalD.void3.下列类的定义，错误的是(D)A.public class test extends Object{……}B.final class operators{……}C.class Point{……}D.void class Point{……}4.关键字supper的作用是(D)A.用来访问父类被隐藏的成员变量B.用来调用父类中被重载的方法C.用来调用父类的构造函数D.以上都是5.关于对象的删除，下列说法正确的是(C)A.必须由程序员完成对象的清除B.java把没有引用的对象作为垃圾收集起来并释放C.只有当程序中调用System.gc()方法时才能进行垃圾收集D.java中的对象都很小，一般不进行删除操作。

二、填空题1.把对象实例化可以生成多个对象，使用____new_____运算符为对象分配内存空间。

2.java程序引入接口的概念，是为了弥补只允许类的____单继承____的缺憾。

3.java语言以___类____为程序的基本单位，它是具有某些共同特性实体的集合，是一种抽象的概念。

4.抽象方法只能存在于抽象类中。

抽象方法用关键字___abstract_____来修饰。

5.java语言中____Object___是所有类的根.6.在java中有一种叫做_____构造函数__的特殊方法,在程序中用它来对类成员进行初始化.7.new是___创建___对象的操作符.8.我们在java程序中,把关键字____super____加到方法名称的前面,来实现子类调用父类的方法9.在java程序里,同一类中重载的多个方法具有相同的方法名和_不同的____的参数列表.重载的方法可以有不同的返回值类型10.java语言通过接口支持__多重____继承,使类继承具有更灵活的扩展性11.java语言中,调用方法时,参数传递是___值___调用,而不是地址调用12.接口是一种只含有抽象方法或___常量___的一种特殊抽象类一、填空题1.在子类中使用关键字_______做前缀可调用被子类覆盖的父类中的方法。

java访问权限public、protected、友好型、private问题总结
现在假设有⼀个Tom类
(1)Tom类⾥⽤private修饰的成员变量和⽅法称为私有变量和私有⽅法。

在任何⼀个其他类中⽤Tom类创建的对象，都不能通过对象访问私有变量和私有⽅法；也不能通过类名访问私有类变量和私有类⽅法。

(2)Tom类⾥⽤public修饰的成员变量和⽅法称为共有变量和共有⽅法。

在任何⼀个其他类中⽤Tom类创建的对象，可以通过对象访问共有成员变量和共有⽅法；也可以通过类名访问共有类成员变量和共有类⽅法。

(3)Tom类⾥没有⽤访问权限修饰词修饰的，叫做友好型变量和友好型⽅法。

在任何其他类⾥⽤Tom类创建的对象，只有该类与Tom类是在同⼀个包下⾯，则可以通过对象访问友好型变量和友好型⽅法，也可以通过类名访问友好型类变量和友好型类⽅法。

(4)protected修饰的称为受保护型，访问权限情况和友好型⼀样，只是在继承上⼜区别，在此就不讨论了。

(5)访问权限从⾼到低：public protected 友好型 private
(6) 类（class）的修饰不能⽤private和protected,只有public和友好型。

public修饰类，这个类称为public类，在任何⼀个类中都可以⽤public类创建对象。

不加访问权限关键字的类叫做友好类，要想在某⼀个类中⽤友好类创建对象，要保证这个类要和友好类在⼀个包。

一、选择题（每小题1.5分，共30分）1、编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( B )。

A 、 .javaB 、 .classC 、 .htmlD 、 .exe 2、设 x = 1 , y = 2 , z = 3，则表达式 y ＋＝z －－/＋＋x 的值是( A )。

A 、 3 B 、 3. 5 C 、 4 D 、 5 3、选出以下定义合法的标识符：( D )A 、float b 、2ac C 、#3c D 、$abc4、若a 的值为3时，下列程序段被执行后，c 的值是多少？（ C ） c = 1;if ( a>0 ) if ( a>3 ) c = 2; else c = 3; else c = 4; A 、1 B 、2 C 、3 D 、4 5、下面程序的运行结果是（ A ）int i=5;System.out.print( i++); System.out.print (++i); System.out.print (--i); System.out.print (i--);A 、5644B 、6543C 、6654D 、56546、对整型变量a=16,b=5,下列表达式的值为true 的是（ D ） A 、!(b==a/3) B 、b!=a%11 C 、a>1&&b<1 D 、!=b||a>b7、对于子类的构造函数说明，下列叙述中不正确的是（ D ）。

A 、子类无条件地继承父类的无参构造函数。

B、子类可以在自己的构造函数中使用super关键字来调用父类的含参数构造函数，但这个调用语句必须是子类构造函数的第一个可执行语句。

C、在创建子类的对象时，将先执行继承自父类的无参构造函数，然后再执行自己的构造函数。

D、子类不但可以继承父类的无参构造函数，也可以继承父类的有参构造函数。

8、以下程序的功能是：求n!。

Java学习笔记10---访问权限修饰符如何控制成员变量、成员⽅法及类的访问范围1.Java有三种访问权限修饰符，分别为public、protected、private，还有⼀种为缺省权限修饰符的情况，记为default。

其中，可以由public 和default来修饰类；这四种修饰符都可以修饰成员变量和成员⽅法。

每⼀种修饰符对应不同的访问范围，下⾯以下图为例详细说明。

图1private只可以覆盖圆1，即只有本类可以访问；default可以覆盖到圆3，即本类、同包⼦类、同包其他类都可以访问，简单说就是与本类同包的所有类都可以访问；protected可以覆盖到圆4，即本类、同包⼦类、同包其他类、其他包中的⼦类都可以访问，简单说就是与本类同包的类及其他包中的⼦类都可以访问；public可以覆盖到圆5，即本类、同包⼦类、同包其他类、其他包⼦类、其他包其他类都可以访问，简单说就是所有类都可以访问；注：在与⽗类不同包的⼦类中，如果通过⼦类对象访问和调⽤⽗类中由protected修饰的变量和⽅法，确实可以；但如果通过⽗类的对象访问和调⽤的话，则不可以访问protected修饰的变量和⽅法，具体见下⽂的(6)和(7)。

具体原因还未了解。

2.下⾯以简单的程序验证上述结论。

前提：包human中定义了类Person，Student，DustMan；其中，Student是Person的⼦类，DustMan不是Person的⼦类。

包teacher中定义了类Teacher，GateMan；其中，Teacher是Person的⼦类，GateMan不是Person的⼦类。

Person中定义了四个成员变量和四个成员⽅法，分别以public，protected，缺省，private修饰，详见下⾯代码：String name;public String education;private String hobby;protected String residence;public void testModifierPublic() {System.out.println("Public");}protected void testModifierProtected() {System.out.println("Protected");}void testModifierDefault() {System.out.println("Default");}private void testModifierPrivate() {System.out.println("Private");}(1),在Person类中定义Person类对象pOwn，分别访问和调⽤这些成员变量和成员⽅法，详见下⾯的代码：public static void main(String[] args) {Person pOwn = new Person("xi",20,"female","bachelor","recite","NJ");System.out.println("public education: " + cation);System.out.println("protected residence: " + pOwn.residence);System.out.println("default name: " + );System.out.println("private hobby: "+ pOwn.hobby);pOwn.testModifierPublic();pOwn.testModifierProtected();pOwn.testModifierDefault();pOwn.testModifierPrivate();}输出结果为：public education: bachelorprotected residence: NJdefault name: xiprivate hobby: recitePublicProtected结果分析：Person类对象可以在本类中访问和调⽤由public、protected、default、private修饰的成员变量和成员⽅法。

Java关键字(keyword)和保留字(reserved word)的用法在java中有48个关键字和2个保留字。

经过学习，借助了谷歌的力量我将这些关键字和保留字整理如下。

一．访问限定。

1.public关键字: public的意思是公有的，public作为关键字可以放在类前，表示这个类可以被其他包中的类的对象所访问。

Public限定的类在文件中只允许有一个，且类名必须与文件名相同。

如果public用来修饰方法，表示方法可以被其他包中的类调用。

如果public用来修饰属性，则可直接通过对象名.属性来访问对象的属性。

2.private关键字: private的意思是私有的，其可调用性范围最小。

在方法的前面加上private，则方法只能由内部的方法或者构造器调用，通常，属性都是用private限定的，而一般的类前，都不加private限定。

在类继承时，父类中的private方法将不能被子类继承。

当我们给某个构造器加上private修饰符时，则不能创建某个类的对象。

3.protected关键字：protected限定符界于public和private之间。

被protected限定的方法，子类可以继承，在同一个包内可以访问，在不同的包内不可以访问。

这些关键字的用法如上所述，但为了更好的理解一些细节的问题，大家可以看一下我对下面这些问题的总结。

那么，一个类中是否可以定义两个或者两个以上的public类？我们可以在eclipse 中运行一下，结果如下：由上可见，在一个类中，Public限定的类在文件中只允许有一个，且类名必须与文件名相同。

若在类里面还要创建一个类的话，那就只能是默认的，不可以加其他访问修饰符，或者，可以在已有的类的内部，再创建一个类，但名字必须不同与文件名。

若属性使用public进行修饰，就可以直接通过对象·属性来访问对象的属性。

输出结果是name=向聘。

这里就是直接通过创建的对象来访问st对象的name属性的。