java 访问控制修饰符

面向对象的基本思想之一是封闭实现细节并且公开接口。Java语言采用访问控制修饰符来控制类及类的方法和变量的访问权限，从而只向使用者暴露接口，但隐藏实现细节。访问控制分4种级别。表6-7总结了这4种访问级别所决定的可访问范围。

●公开级别：用public修饰，对外公开。

●受保护级别：用protected修饰，向子类及同一个包中的类公开。

●默认级别：没有访问控制修饰符，向同一个包中的类公开。

●私有级别：用private修饰，只有类本身可以访问，不对外公开。

表6-7 4种访问级别的可访问范围

护、默认和私有。顶层类只可以处于公开或默认访问级别，因此顶层类不能用private

表6-8列出了类、成员方法、构造方法、成员变量和局部变量可用的各种修饰符。其中“√”表示可以修饰。表中的类仅限于顶层类（Top Level Class），而不包括内部类。内部类是指定义在类或方法中的类，下面会对此做详细介绍。

JAVA笔试题--基础很全有答案

第一组 1.下列不可作为java语言修饰符的是（D） A) a1 B) $1 C) _1 D) 11 2.有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可以是（A）Ａ) a1.java B) a1.class C) a1 D) 都对 3.整型数据类型中，需要内存空间最少的是（D） A) short B) long C) int D) byte 4. Java 类可以作为（C） A) 类型定义机制 B) 数据封装机制 C) 类型定义机制和数据封装机制 D) 上述都不对 5.在创建对象时必须（C） A) 先声明对象，然后才能使用对象 B) 先声明对象，为对象分配内存空间，然后才能使用对象 C) 先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象 D) 上述说法都对 6.在调用方法时，若要使方法改变实参的值，可以（B） A) 用基本数据类型作为参数 B) 用对象作为参数 C) A和B都对 D) A和B都不对 7. Java中（C） A) 一个子类可以有多个父类，一个父类也可以有多个子类 B) 一个子类可以有多个父类，但一个父类只可以有一个子类 C) 一个子类可以有一个父类，但一个父类可以有多个子类 D) 上述说法都不对 8.Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？（B） A) 安全性B) 多线性C) 跨平台D) 可移植 9. Character流与Byte流的区别是（C） A) 每次读入的字节数不同B) 前者带有缓冲，后者没有 C) 前者是字符读写，后者是字节读写D) 二者没有区别，可以互换使用

10.以下声明合法的是（ D ） A、default String s； B、public final static native int w( ) C、abstract double d； D、abstract final double hyperbolicCosine( ) 11.关于以下application的说明，正确的是（ C ） 1．class StaticStuff 2．{ 3．static int x=10； 4．static { x+=5；} 5．public static void main（String args[ ]） 6．{ 7．System.out.println(“x=”+ x); 8．} 9．static { x/=3;} 10. } A、4行与9行不能通过编译，因为缺少方法名和返回类型 B、9行不能通过编译，因为只能有一个静态初始化器 C、编译通过，执行结果为：x=5 D、编译通过，执行结果为：x=3 12.关于以下程序代码的说明正确的是（ D ） 1．class HasStatic{ 2．private static int x=100； 3．public static void main(String args[ ]){ 4．HasStatic hs1=new HasStatic( ); 5．hs1.x++; 6．HasStatic hs2=new HasStatic( ); 7．hs2.x++; 8．hs1=new HasStatic( ); 9．hs1.x++; 10．HasStatic.x- -; 11．System.out.println(“x=”+x); 12．} 13．} A、5行不能通过编译，因为引用了私有静态变量 B、10行不能通过编译，因为x是私有静态变量 C、程序通过编译，输出结果为：x=103 D、程序通过编译，输出结果为：x=102 13.以下选项中循环结构合法的是（ C ） A、while (int i<7) { i++;

JAVA语言中的final修饰符

final关键字可用于修饰类，变量和方法，final关键字有点类似c#里的sealed关键字（如果大家学过C#就知道），它用于表示它修饰的类，方法和变量不可改变。 final变量 final修饰变量时，表示该变量一旦获得了初始值就不可改变，final既可修饰成员变量（包括类变量和实例变量），也可以修饰局部变量，形参。严格来说final修饰的变量不要被改变，一旦获得初始值之后，该final变量的值就不能被重新赋值。因为final变量获得初始值之后不能被重新赋，因此final修饰成员变量和修饰局部变量时有一定的不同：下面我将会写到有哪些方面的不同，还有就是为什么会不同。 final修饰成员变量成员变量是随类初始化或对象初始化而初始化的。当类初始化时，系统会为该类属性分配内存，并分配默认值；当创建对象时，系统会为该对象的实例属性分配内存，并分配默认值。也就是说，当执行静态初始化块时可以对类属性赋初始值，当执行普通初始块，构造器时可对实例属性赋初始值。因此，成员变量的初始值可以在定义该变量时指定默认值，可以在初始化块，构造器中指定初始值，否则，成员变量的初始值将是由系统自动分配的初始值。对于final修饰的成员变量而言，一旦有了初始值之后，就不能重新赋值，因此不可以在普通方法中对成员变量重新赋值。成员变量只能在定义该成员变量时指定默认值，或者在静态初始化块，初始化块，构造器中为成员变量指定初始值，如果既没有在定义成员变量时指定初始值，也没有在初始化块，构造器中为成员变量指定初始值，那么这些成员变量的值将一直是0，\u0000，false null这些成员变量也就失去了存在的意义。因此当使用final修饰成员变量的时候，要么在定义成员变量时候指定初始值，要么

java中的类修饰符

java中的类修饰符、成员变量修饰符、方法修饰符。类修饰符： public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。 abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。 final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。 friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。成员变量修饰符： public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。 private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。 protected （保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。 friendly ，在统一报中的类可以访问，其他包中的类不能访问。 final，最终修饰符，指定此变量的值不能变。 static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。

transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。 volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。方法修饰符： public（公共控制符） private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类） protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。 final，指定该方法不能被重载。 static，指定不需要实例化就可以激活的一个方法。 synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。 native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。

java访问权限修饰符

java访问权限修饰符public protected default private用法总结首先声明：java中，default这个修饰符并没有显式的声明，在成员变量和方法前什么修饰符也不用，默认的就是default。为了条理清晰，分三种不同情况来总结。一访问权限修饰符修饰成员变量和方法 public：表明该成员变量和方法是共有的，能在任何情况下被访问。 protected：必须在同一包中才能被访问。(说的比较简单，看个例子就明白了) eg: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); //合法 } } 特别说明：什么是在同一个包中？答：用package打包在一起的class ,叫在同一个包中。(不明白，举个例子) eg:在JDK的src\java\io中，你会看到许多java类，第一句源代码都是package java.io; 没有使用package打包的，在同一目录下的类也会被视做同一个包。 default：在这种情况下中，同protected。区别在第二和第三种情况中。 eg: class A { int weight ; int f( int a,int b ) { // 方法体 } }

假设B与A在同一个包中，则 class B { void g() { A a=new A(); A.weight=100;//合法 A.f(3,4); //合法 } } private:只能在本类中访问。 eg: class Test { private int money; Test() { money=2000; } private int getMoney() { return money; } public static void main(String args[]) { Test te=new Test(); te.money=3000; //合法 int m=te.getMoney(); //合法 System.out.println("money="+m); } } PS：实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。二访问权限修饰符修饰类 1，不能用protected和private修饰类。 2，用default修饰的类叫友好类，在另外一个类中使用友好类创建对象时，要保证它们在同一包中。三访问权限修饰符与继承这里的访问修饰符指的是修饰成员变量和方法。可以分为两种情况： 1，子类与父类在同一包中此时只有声明为private的变量与方法不能被继承(访问)。

Java

基本语法编写Java程序时，应注意以下几点： ?大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。 ?类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。 ?方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。 ?源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。 ?主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。 Java标识符 Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。关于Java标识符，有以下几点需要注意： ?所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始 ?首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下划线（_）或数字的任何字符组合 ?关键字不能用作标识符 ?标识符是大小写敏感的 ?合法标识符举例：age、$salary、_value、__1_value ?非法标识符举例：123abc、-salary

Java修饰符像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符： ?访问控制修饰符: default, public , protected, private ?非访问控制修饰符: final, abstract, strictfp 在后面的章节中我们会深入讨论Java修饰符。 Java变量 Java中主要有如下几种类型的变量 ?局部变量 ?类变量（静态变量） ?成员变量（非静态变量） Java数组数组是储存在堆上的对象，可以保存多个同类型变量。在后面的章节中，我们将会学到如何声明、构造以及初始化一个数组。 Java枚举 Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。实例

Java 修饰符-牛耳教育

Java 修饰符 Java语言提供了很多修饰符，主要分为以下两类：访问修饰符非访问修饰符修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：public class className { // ... } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String[] arguments) { // 方法体} 访问控制修饰符 Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持4 种不同的访问权限。 ? default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。 ? ? private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）

? ? public : 对所有类可见。使用对象：类、接口、变量、方法 ? ? protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。 ? 我们可以通过以下表来说明访问权限：访问控制修饰符当前类同一包内子孙类(同一包) 子孙类(不同包) 其他包 public Y Y Y Y Y protected Y Y Y Y/N（说明）N default Y Y Y N N private Y N N N N 默认访问修饰符-不使用任何关键字使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为public。

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

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之前增加若干类的修饰符来修饰限定所定义的类的特性。类的修饰符分为访问控制符和非访问控制符两大类，下面主要讨论类的费访问控制符。 1.1抽象类凡是用abstract修饰符修饰的类被称为抽象类。抽象类就是没有具体对象的概念类。比如电话卡有很多类型，磁卡、IC卡、IP卡、200卡、300卡、校园201卡。不同种类的卡有各自的特点，例如磁卡和IC卡没有卡号和密码；使用200卡每次通话要多扣除0.1元的附加费等。同时它们也拥有一些共同的特点，如每张卡都有剩余的金额，都有通话的功能。为此，可以定义一种集合了所有种类的电话卡的公共特点的抽象电话卡如下： Abstract class PhoneCard { double balance; void performDial() {

java的四个修饰符

1. Java中的访问控制表1-1 （1）在java中有public、protected、private三种显示的修饰符用于控制可见性，package不是显示的修饰符，它是隐含的，即如果在类、变量等前没加显示的可见性修饰符，那它就是package级别的。如果在类的定义中没有指定package，那么java会把它放在缺省包中，一般来说这个缺省的包就是当前目录。（2）在子类中的方法如果重载了父类的方法，那么该方法的可见级别应更底或者相同，如父类中的方法是public，那么子类中方法必须是public。（3）在java中，一般来说，变量成员最好是private，对它们的访问可以通过public的方法，在这些方法中可以做些控制以保证数据的一致性。这些方法名一般以get和set做为前缀。 2. 包包名一般为小写，而类名的第一个字母一般为大写，这样在引用时，可以明显的分辨出包名和类名。如果在类的定义之前没有使用package定义包名，那么该类就属于缺省的包。 2.1 Hello Package 首先通过一个简单的package的定义来学习package的使用： package testPackage; public class Test { public static void main(String args[]) { mNode node = new mNode();

node.print("hello"); } } 说明：（1）使用package关键字指明类所在的包；（2）package语句必须在文件的最前面；（3）编译时可使用javac –d . Test.java自动产生包需要目录；（4）可以使用java testPackage.Test来执行编译后的代码； 2.2 包的几个作用：（1）可以更好的组织类，包与文件夹类似，文件夹可以将不同的文件放在同一个文件夹中，而包也可以将不同的类文件放在同一包中；（2）减少类名的冲突问题，这也与文件夹类似，同一文件夹中的文件不能重名，不同文件中的文件可以重名，同一包中的类名不能重复，不同包中的类名可以重复；（3）对包中的类起了一定的保护作用，详见java的访问控制； 2.3 import的使用（1）直接引用指定的类，如import java.util.Vector；（2）引用一个包中的多个类，如import java.awt.*。更确切的说，它并不是引用java.awt 中的所有类，而只引用定义为public的类，并且只引用被代码引用的类，所以这种引用方法并不会降低程序的性能；（3）*号代替类名，在不能代替包名，如import java.awt.*，只引用java.awt下的类，而不引用java.awt下的包；（4）import java.awt.F*，这种使用方法是错误的；（5）import语句在所有类定义之前，在package定义之后；（6）import只告诉编译器及解释器哪里可以找到类、变量、方法的定义，而并没有将这些定义引入代码中； 2.4 包中类的使用有以下几种机制可以使用包中的类：（1）如果要使用的类是属于https://www.360docs.net/doc/209518517.html,ng包的，那么可以直接使用类名来引用指定的类，而不需要加上包名，因为包https://www.360docs.net/doc/209518517.html,ng不用显示使用import，它是缺省引入的；（2）如果要使用的类在其它包（https://www.360docs.net/doc/209518517.html,ng除外）中，那么可以通过包名加上类名来引用该

final修饰符

Final修饰符 Final关键字可以修饰类、变量、和方法，用于表示它修饰的类、变量、方法不可改变。 1，final修饰成员变量成员变量是随类的初始化或随对象的初始化而初始化。当类初始化时，系统会为该类的属性分配内存空间，并分配默认值，当初始化对象时，系统会为该对象的实例属性分配内存空间，并分配默认值。也就是说，当执行静态初始化块时，可以给该类的属性赋初始值，当执行普通初始化块、构造器时可对实例属性赋初始值。因此，成员变量的初始值可以在定义该变量时指定默认值，可以在初始化块、构造器中指定初始值，否则，成员变量的初始值将是由系统自动分配的初始值。对于final修饰的成员变量而言，一旦有了初始值，就不能重新赋值，因此不可在普通方法中对成员变量重新赋值，成员变量只能在只能在定义该变量时指定默认值，或者在静态初始化块、初始化块、构造器中为成员变量指定初始值，如果即没有在定义该变量时指定初始值，也没有在初始化块，构造器中指定初始值，则改变量的值一直是0、false null 0.000 因此final修饰的类是属性，实例属性修改的地方归纳如下：类属性：可在静态初始化快中，声明该属性时指定初始值。

实力属性：可在非静态初始化块、声明该属性、构造器中指定初始值。 2、final修饰的基本类型和引用类型变量的区别 Final修饰的基本类型变量时，不能对基本变量重新赋值，因此基本类型变量不能被改变。但对引用类型而言，它保存的仅仅是一个引用，final只保证这个引用的引用地址不会被改变，即一直引用同一对象，但这个对象完全可以改变。所以final 修饰的引用变量无法在编译时获取值，而是在运行时获取值。 3、final方法 Final修饰的方法为不可重写的方法。对于一个private修饰的方法，因为它在当前类中可见，其子类无法访问该方法，所以子类无法重写该方法，如果子类中定义了一个与private方法相同名字、相同返回类型，相同的参数列表，也不是方法的重写，而是重新定义了一个新的方法。因此，即使使用final修饰的private的访问权限的方法，其子类依然可以定义一个与该方法具有相同的方法名、相同的参数列表、相同的返回类型。 4、final类 Final修饰的类不可有子类，不可继承

JAVA笔试题 Java选择题道

1.下列不可作为j a v a语言修饰符的是（D） A) a1 B) $1 C) _1 D) 11 2.有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可以是（A）Ａ) a1.java B) a1.class C) a1 D) 都对 3.整型数据类型中，需要内存空间最少的是（D） A) short B) long C) int D) byte 4. Java 类可以作为（C） A) 类型定义机制 B) 数据封装机制 C) 类型定义机制和数据封装机制 D) 上述都不对 5.在创建对象时必须（C） A) 先声明对象，然后才能使用对象 B) 先声明对象，为对象分配内存空间，然后才能使用对象 C) 先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象 D) 上述说法都对 6.在调用方法时，若要使方法改变实参的值，可以（B） A) 用基本数据类型作为参数 B) 用对象作为参数 C) A和B都对 D) A和B都不对 7. Java中（C） A) 一个子类可以有多个父类，一个父类也可以有多个子类 B) 一个子类可以有多个父类，但一个父类只可以有一个子类 C) 一个子类可以有一个父类，但一个父类可以有多个子类 D) 上述说法都不对 8.Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？（B） A) 安全性B) 多线性C) 跨平台D) 可移植 9. Character流与Byte流的区别是（C） A) 每次读入的字节数不同B) 前者带有缓冲，后者没有 C) 前者是字符读写，后者是字节读写D) 二者没有区别，可以互换使用 10.以下声明合法的是（ D ） A、default String s； B、public final static native int w( ) C、abstract double d； D、abstract final double hyperbolicCosine( ) 11.关于以下application的说明，正确的是（ C ） 1．class StaticStuff 2．{ 3．static int x=10； 4．static { x+=5；} 5．public static void main（String args[ ]） 6．{

java中的修饰符

java中的修饰符 static 表示静态，它可以修饰属性，方法和代码块。 1，static修饰属性（实例变量）（类变量），这个属性就可以用类名.属性名来访问，这个属性成为本类的类变量，为本类对象所共有。这个属性全类公有。（共有的类变量与对象无关，只和类有关）。例： Java代码 1.public class Test{ 2.private static int testnum; 3./* 4.如果实力变量前加上了static修饰符那么，这个变量叫做类变量 5.*/ 6.…… 7.} 类加载的过程，类本身是保存在文件中（字节码文件保存着类的信息）的，java 通过I/O流把类的文件（字节码文件）读入JVM（java虚拟机），这个过程称为类的加载。JVM（java虚拟机）通过类路径（CLASSPATH）来找要加载的字节码文件。类变量，在加载时自动初始化，初始化规则和实例变量相同。注意：类中的实例变量在创建对象时被初始化，static修饰的属性，类变量，在类加载时创建并进行初始化，类加载的过程只进行一次。类变量只会被创建并初始化一次。 2，static修饰方法（静态方法），使这个方法成为整个类所公有的方法，用类名.方法名访问。例： Java代码 1.public class Test{ 2.private static int num; 3.public int testage; 4.public static int test（）{ 5.num++; 6.Test t=new Test(); 7.t.age 8./* 9.在静态方法中只能防问静态属性,但是可以通过一上的

Java 默认修饰符总结

Java 默认修饰符总结 1.类（class）可见性修饰符：public—在所有类中可见，在其他包中可以用import导入。缺省—就是没有修饰符，在同一个包中的类中可见，在其他包中不能用 import导入。修饰符：final—终态类，表示该类不能被继承 abstract—抽象类，不能新建对象 2.变量（variable） Java中变量有两种，方法变量和字段变量方法变量只能用一个修饰符：final—表示常量，不能修改下面是字段变量的修饰符可见性修饰符：public—在任何类中可见 protected—在子类中或同一个包中可见 private—只在本类中可见，子类中也不可见缺省—在同一个包中可见，子类不在一个包中，子类中也不可见修饰符：static—静态变量，被类的所有实例共享 final—常量，定义后不能修改 *transient—告诉编译器，在类对象序列化的时候，此变量不需要持久保存 *volatile—指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理这两带*的不是很常用，但也是Java的修饰符，我也不是很清楚 3.方法(method) 可见性修饰符：public—在任何类中可见 protected—在子类中或同一个包中可见 private—只在本类中可见，子类中也不可见缺省—在同一个包中可见，子类不在一个包中，子类中也不可见修饰符：static—静态方法，并不需要创建类的实例就可以访问静态方法final—常方法，所有子类不能覆盖该方法，但可以重载 abstract—抽象方法，在抽象类中没有实现的方法 native—本地方法，参见Java Native Interface(JNI) synchronized —在多线程中，synchronized方法调用时，其他所有方法不能调

Java的类一些常识

Java的类一些常识 “1、请解释Java语言的跨平台特性。解析：虽然不知道什么是跨平台也可以使用Java语言进行编程，但是对于一个Java编程员来说，理解跨平台特性能够更深入掌握Java语言，所以企业中往往要求应聘者至少理解这个特性。参考答案：Java的跨平台特性也被称为可移植性、平台无关性，或者一次编写处处运行。他的意思就是如果用Java语言编写一个应用，那么就可以在不同平台上运行，而不需要为不同平台单独运行开发。之所以能实现跨平台的特性。主要得益于Java虚拟机（JVM），JVM解释器在运行Java应用时根据当前平台进行解释，解释成符合当前平台规范的机器码，所以可以实现同样的应用在不同平台上都能运行。 “2、请列举JAVA语言的主要特点解析：了解一门语言，往往从熟悉该语言的主要特点开始入手，所以企业也常常通过应聘者对JAVA语言特点的掌握程度而判断其语言基础是否扎实。参考答案：JAVA语言有很多特点，主要包括：①跨平台性：一个应用可以不经过修改直接运行到不同的平台上。②面向对象：JAVA语言是一门面向对面的语言，可以使用对象的属性和行为，可以使用面向对象的思想进行分析设计，并实现整个应用。③解释执行JAVA应用时，JVM中的解释器将解释类文件，生成符合当前平台的字节码。④自动回收：JAVA 应用中的垃圾回收是自动进行的，JVM中的后台线程将监视内存中数据的使用，当内存中的数据不再被引用时，将被作为垃圾回收，而不需要程序员动手回收。 “3、请说明一个JAVA类中主要包含哪几个元素？并说明每种元素的作用。解析：无论简单还是复杂的JAVA应用，都是由若干个类组成，所以类是JAVA应用的组成单位。了解一个类中包含的主要元素能够对类有一个清晰的认识。一个类中往往会有五种元素，即属性、方法、构造方法、块以及内部类、其实块和内部类比较少见。参考答案：JAVA类中主要包含属性、方法、构造方法、块以及内部类。

Java选择题100道

1.下列不可作为java语言修饰符的是（D） A) a1 B) $1 C) _1 D) 11 2.有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可以是（A）Ａ) a1.java B) a1.class C) a1 D) 都对 3.整型数据类型中，需要内存空间最少的是（D） A) short B) long C) int D) byte 4. Java 类可以作为（C） A) 类型定义机制 B) 数据封装机制 C) 类型定义机制和数据封装机制 D) 上述都不对 5.在创建对象时必须（C） A) 先声明对象，然后才能使用对象 B) 先声明对象，为对象分配内存空间，然后才能使用对象 C) 先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象 D) 上述说法都对 6.在调用方法时，若要使方法改变实参的值，可以（B） A) 用基本数据类型作为参数 B) 用对象作为参数 C) A和B都对 D) A和B都不对 7. Java中（C） A) 一个子类可以有多个父类，一个父类也可以有多个子类 B) 一个子类可以有多个父类，但一个父类只可以有一个子类 C) 一个子类可以有一个父类，但一个父类可以有多个子类 D) 上述说法都不对 8.Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？（B） A) 安全性B) 多线性C) 跨平台D) 可移植 9. Character流与Byte流的区别是（C） A) 每次读入的字节数不同B) 前者带有缓冲，后者没有 C) 前者是字符读写，后者是字节读写D) 二者没有区别，可以互换使用 10.以下声明合法的是（ D ） A、default String s； B、public final static native int w( ) C、abstract double d； D、abstract final double hyperbolicCosine( ) 11.关于以下application的说明，正确的是（ C ） 1．class StaticStuff 2．{ 3．static int x=10； 4．static { x+=5；} 5．public static void main（String args[ ]） 6．{ 7．System.out.println(“x=”+ x); 8．} 9．static { x/=3;}

c#类修饰符大全

C#类修饰符大全(转) 类修饰符：public、internal、partial、abstract、sealed、static 成员修符：public、protected、private、internal、sealed、abstract、virtual、override、readonly、const Public：最开放，所有的本程序集以及其他的程序集里面的对象都能够访问 Protected:比较开放，自身成员以及子类成员可访问 Private：只有自身成员才能够访问 Internal：本程序集内的成员可以访问 Partial：部分类，可以将一个类分成几部分写在不同文件中，最终编译时将合并成一个文件，且各个部分不能分散在不同程序集中 Abstract：修饰类的时候表示该类为抽象类，不能够创建该类的实例。修饰方法的时候表示该方法需要由子类来实现，如果子类没有实现该方法那么子类同样是抽象类；且含有抽象方法的类一定是抽象类Sealed：修饰类时表示该类不能够被继承，修饰方法时表示该方法不能被覆写。 Static：修饰类时表示该类时静态类，不能够实例化该类的对象，既然不能实例化该类，那么这个类也就不能够含有对象成员，即该类所有成员为静态；修饰类成员时，该成员为类成员，只能通过【类.成员名】的方式访问当static修饰构造函数时，构造函数不能含有任何参数，不能含有修饰符，构造函数不能对对象成员进行初始化操作。但是能够对静态成员进行初始化或者调用。不能保证他在什么时候执行，却能保证在第一次使用类型前执行。在静态构造函数中初始化的静态成员为最终初始化结果。例如： public static int test = 0; static Person() { test = 3; } static void Main(string[] args) { Console.WriteLine(Person.test);//运行结果为3 }

Chp7 三个修饰符_参考答案

Chp7 三个修饰符参考答案 1.输出结果 300 200 300 400 2.EG 静态方法中不能访问非静态成员，即不能访问非静态变量和调用非静态函数。 3.输出结果 1 2 3 用这种方式可以用来统计总共创建了多少个对象。 4.输出结果为 In Static MyClass() 20 MyClass(int) 10 5.输出结果为 m1 in Super m2 in Sub m1 in Sub m2 in Sub 6.输出结果 In ClassA Static ClassA() In Static MyClass In ClassB Static In ClassC Static ClassB() ClassC() MyClass() ClassB()

ClassC() MyClass() 注：该题较难解释：该题需要创建两个MyClass对象。一般而言，创建对象的过程如下： 1)分配空间 2)递归构造父类对象 3)初始化本类属性 4)调用本类构造方法如果某个类是JVM运行中第一次遇到，则会进行类加载的动作。类加载会初始化该类的静态属性，并执行该类的静态初始化代码块。因此，本题中创建的两个MyClass对象，依次会进行如下步骤： 1)加载MyClass类，并初始化其静态属性 2)为MyClass分配空间 3)递归构造MyClass的父类对象。 4)初始化MyClass属性 5)调用MyClass的构造方法。至此，第一个对象创建完成。之后创建第二个对象时，由于类加载已经完成，因此跳过类加载的步骤，即： 6)为MyClass分配空间 7)递归构造MyClass的父类对象 8)初始化MyClass属性 9)调用MyClass的构造方法。经过9个步骤，两个对象创建完毕。其中，在第1步时，类加载时会初始化其静态属性，之后会执行静态初始化代码块，因此对第1步进行细分： 1.1初始化ca属性 1.2执行MyClass的静态初始化代码块。在1.1执行时，初始化ca属性会创建ClassA对象。由于这是第一次在程序中用到ClassA 对象，因此会执行对ClassA对象的类加载。即：1.1步可以细分为以下步骤： 1.1.1加载ClassA类 1.1.2创建ClassA对象在初始化MyClass属性时，需要创建ClassC对象。而程序执行到第4步时是第一次遇到ClassC类型的对象，因此会执行ClassC的类加载。因此，对第4步和第8步进行细化：第4步：初始化MyClass属性： 4.1 加载ClassC 4.2 为ClassC分配空间 4.3 递归构造ClassC的父类对象 4.4 初始化ClassC属性 4.5 调用ClassC的构造方法第8步，初始化MyClass属性： 8.1 为ClassC分配空间

C#中方法、类等的默认访问修饰符

C#中方法、类等的默认访问修饰符 [csharp]view plaincopyprint? 1.C# 方法默认访问级别 : private 2.C# 类默认访问级别 : internal 1.命名空间下的元素的默认访问修饰符 public : 同一程序集的其他任何代码或引用该程序集的其他程序集都可以访问该类型或成员。 internal : 同一程序集中的任何代码都可以访问该类型或成员，但其他程序集不可以访问。 2.各类型中的成员的默认访问修饰符剩下的修饰符主要是正对继承这个语言特性的,拥有继承的类型有两个类(class)和接口(interface)。public,internal同样可以用于类型成员。 private : 同一类和结构的代码可以访问该类型和成员。 protected : 同一类和派生(继承特性)类中的代码可以访问该类型和成员。 protected internal : 同一程序集中的任何代码或其他程序集中的任何派生类都可以访问该类型或成员。 MSDN提示： 1.) 派生类的可访问性不能高于其基类型。换句话说，不能有从内部类A 派生的公共类B。如果允许这种情况，将会使A 成为公共类，因为A 的所有受保护的成员或内部成员都可以从派生类访问。 2.) 成员的可访问性决不能高于其包含类型的可访问性。 3.) 可以使用五种访问类型中的任何一种来声明类成员（包括嵌套的类和结构）。接口(interface) 接口成员访问修饰符默认为public,且不能显示使用访问修饰符。类(class) 构造函数默认为public访问修饰符。析构函数不能显示使用访问修饰符且默认为private访问修饰符。类的成员默认访问修饰符为private;

Java选择题道

9. Character流与Byte流的区别是（C） A) 每次读入的字节数不同 B) 前者带有缓冲，后者没有C) 前者是字符读写，后者是字节读写 D) 二者没有区别，可以互换使用 10. 以下声明合法的是（ D ） A、default String s； B、public final static native int w( ) C、abstract double d； D、abstract final double hyperbolicCosine( ) 11. 关于以下application的说明，正确的是（ C ） 1． class StaticStuff 2． { 3． static int x=10； 4． static { x =5；} 5． public static void main（String args[ ]） 6． { 7．System.out.println(“x=” x); 8． } 9． static { x/=3;} 10. } A、4行与9行不能通过编译，因为缺少方法名和返回类型 B、9行不能通过编译，因为只能有一个静态初始化器 C、编译通过，执行结果为：x=5 D、编译通过，执行结果为：x=3

类、方法、属性访问修饰符与修饰符小结

Java中各种（类、方法、属性）访问修饰符与修饰符的说明类：访问修饰符修饰符class类名称 extends 父类名称 implement 接口名称（访问修饰符与修饰符的位置可以互换）访问修饰符名称说明备注 public 可以被本项目的所有类访问（使用），其他项目若想使用本项目中的类，必须将本项目打包为 jar包，然后加入到classpath中 public类必须定义在和类名相同的同名文件中 (default) 只能被同一个包中的类访问（使用）默认的访问权限，可以省略此关键字，可以定义在和 public类的同一个文件中修饰符名称说明备注 final 使用此修饰符的类不能够被继承 abstract 如果要使用 abstract类，之前必须首先建一个继承abstract类的新类，新类中实 abstract类中的抽象方法。类只要有一个 abstract方法，类就必须定义为 abstract，但 abstract类不一定非要保护abstract 方法不可（abstract也可以修饰内部类）综上知：类的访问修饰符只有两个：public、package 但是特殊的情况下：成员内部类和静态内部类前面还可以有protected、private访问修饰符（而局部内部类和匿名内部类没有这两种修饰符），同时静态内部类也可以有static修饰符

变量 1.Java中没有全局变量，只有方法变量、实例变量（类中的非静态变量）、类变量（类中的静态变量）。 2.方法中的变量不能够有访问修饰符。所以下面访问修饰符表仅针对于在类中定义的变量。 3.声明实例变量时，如果没有赋初值，将被初始化为null（引用类型）或者0、false（原始类型）。 4.可以通过实例变量初始化器（又叫实例块）来初始化较复杂的实例变量，实例变量初始化器是一个用{}包含的语句块，在类的构造器被调用时运行，运行于父类构造器之后，构造器之前。 5.类变量（静态变量）也可以通过类变量初始化器来进行初始化，类变量初始化器（又叫静态块）是一个用static{}包含的语句块，只可能被初始化一次。访问修饰符名称说明备注 public 可以被任何类访问 protected 可以被所有子类访问，可以被同一包中的所有类访问子类没有在同一包中也可以访问 private 只能够被当前类的方法访问缺省无访问修饰符可以被同一包中的所有类访问如果子类没有在同一个包中，也不能访问 ##上面所说的变量都是成员变量，局部变量前是没有访问修饰符的，因为局部变量的生命周期只在当前函数中，再声明访问修饰符没有意义修饰符名称说明备注 static 静态变量（又称为类变量，其它的称为实例变量）可以被类的所有实例共享。并不需要创建类的实例就可以访问静态变量 final 常量，值只能够分配一次，不能更改注意不要使用 const，虽然它和C、 C++中的const关键