访问修饰符
一个编译器错误提示：在命名空间中定义的元素无法显示的声明为 private, protected, protected in ternal。
能在命名空间中定义的元素有：类(class),结构(struct),委托(delegate),接口(interface),枚举(enum)
MSDN提示: protected internal 可访问性的意思是受保护“或”内部，而不是受保护“和”内部。
我们的访问修饰符一共有5个级别
public, private, protected, internal, protected internal
1.命名空间下的元素的默认访问修饰符
根据上面的红色错误提示，可以知道命名空间下只能使用两种访问修饰符public和internal。如果没有显示的给这些元素访问修饰符，其修饰符默认为internal 。
public : 同一程序集的其他任何代码或引用该程序集的其他程序集都可以访问该类型或成员。
internal : 同一程序集中的任何代码都可以访问该类型或成员，但其他程序集不可以访问。
2.各类型中的成员的默认访问修饰符
剩下的修饰符主要是正对继承这个语言特性的,拥有继承的类型有两个类(class)和接口(interface)。pub lic,internal同样可以用于类型成员。
private : 同一类和结构的代码可以访问该类型和成员。
protected : 同一类和派生(继承特性)类中的代码可以访问该类型和成员。
protected internal : 同一程序集中的任何代码或其他程序集中的任何派生类都可以访问该类型或成员。
MSDN提示：
1.) 派生类的可访问性不能高于其基类型。换句话说，不能有从内部类 A 派生的公共类 B。如果允许这种情况，将会使 A 成为公共类，因为 A 的所有受保护的成员或内部成员都可以从派生类访问。
2.) 成员的可访问性决不能高于其包含类型的可访问性。
3.) 可以使用五种访问类型中的任何一种来声明类成员（包括嵌套的类和结构）。
接口(interface)
接口成员访问修饰符默认为public,且不能显示使用访问修饰符。
类(class)
构造函数默认为public访问修饰符。
析构函数不能显示使用访问修饰符且默认为private访问修饰符。
类的成员默认访问修饰符为private;
枚举(enum)
枚举类型成员默认为public访问修饰符，且不能显示使用修饰符。
结构(struct)
结构成员默认为private修饰符。
结构成员无法声明为protected成员，因为结构不支持继承。
嵌套类型
嵌套类型的默认访问修饰符为private。和类，结构的成员默认访问类型一致。
C++类成员的访问权限
前面我们在定义类时多次使用到了public 关键字，表示类的成员具有“公开”的访问权限，这节我们就来详细讲解。 C++通过public、protected、private 三个关键字来控制成员变量和成员函数的访问权限，它们分别表示公有的、受保护的、私有的，被称为成员访问限定符。所谓访问权限，就是你能不能使用该类中的成员。 Java、C# 程序员注意，C++ 中的public、private、protected 只能修 饰类的成员，不能修饰类，C++中的类没有共有私有之分。 在类的内部（定义类的代码内部），无论成员被声明为public、protected 还是private，都是可以互相访问的，没有访问权限的限制。 在类的外部（定义类的代码之外），只能通过对象访问成员，并且通过对象只能访问public 属性的成员，不能访问 private、protected 属性的成员。 本节重点讲解public 和private，protected 将在继承中讲解。 下面通过一个Student 类来演示成员的访问权限： 1.#include
10. 11.public://共有的 12.void setname(char*name); 13.void setage(int age); 14.void setscore(float score); 15.void show(); 16.}; 17. 18.//成员函数的定义 19.void Student::setname(char*name){ 20.m_name = name; 21.} 22.void Student::setage(int age){ 23.m_age = age; 24.} 25.void Student::setscore(float score){ 26.m_score = score; 27.} 28.void Student::show(){ 29.cout<
java中的类修饰符
java中的类修饰符、成员变量修饰符、方法修饰符。 类修饰符： public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。 abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。 final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。 friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。 成员变量修饰符： public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。 private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。 protected （保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。 friendly ，在统一报中的类可以访问，其他包中的类不能访问。 final，最终修饰符，指定此变量的值不能变。 static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。 volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。 方法修饰符： public（公共控制符） private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类） protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。 final，指定该方法不能被重载。 static，指定不需要实例化就可以激活的一个方法。 synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。 native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。
成员函数中访问对象的私有成员问题
问题（知识点）描述： a．在C++的类的成员函数中，允许直接访问该类的对象的私有成员变量。 b．在类的成员函数中可以访问同类型实例的私有变量。 c．拷贝构造函数里，可以直接访问另外一个同类对象（引用）的私有成员。 d．类的成员函数可以直接访问作为其参数的同类型对象的私有成员。 举例描述上述知识： 1).在拷贝构造函数中可以访问引用对象的私有变量：例如: class Point { public: Point(int xx=0,int yy=0){X=xx;Y=yy;} Point(Point &p); private: int X,Y; }; Point::Point (Point &p) { X=p.X; Y=p.Y; } 2).在类的成员函数中可以访问同类型实例的私有变量 class A { public: int getA() const { return a; } void setA(int val) { a = val; } void assign(A& _AA) { this->a = _AA.a; _ AA.a = 10; //可以直接访问 } void display() { cout<<"a:"< 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的过程中，我写类经常会用到public，private 和protected 的，我的基本经验就是一般类的成员变量都是用private，方法用public，类内部用的方法用protected，如果是存在子类的，那我就会把父类中的成员变量变为protected。（其余的看具体实际情况而定） 不过在一些公司的笔试题中，他们会要求你具体的写出像public这些访问限定符的作用域。其实，平常我都没去系统的考虑这些访问限定符的作用域，特别是包内包外的情况，OK，笔试不行了。 这是java基本的知识，也是公司看重的，那没办法啦，我的脑袋记不住东西，那我只能把这些东西写下来方便自己温故知新。 貌似默认（无）是friendly 如果你看到这里还不是很了解上面的表，或者是很久就没看书了，忘记了上面的表的内容的意义，那下面的例子就是帮助你温故知新的好东东。 例如，有一个包demo中的类P，它有一个private 成员变量data，一个public 默认构造方法，一个public 访问方法getData()，一个protected修改方法setData()，还有一个默认访问方式的辅助方法print()。 package demo; public class P{ private int data; public P(){ setData(0); } public int getData(){ return data; } protected void setData(int v){ data = v; } void print(){ System.out.println("used!") } } 本类的不用说了，在本类里面才不管什么访问限定符呢。 如有类Q，扩展了P，所以可以调用P的默认构造方法、访问方法getData()和修改方法 setData()。但类Q不能直接访问P的成员变量data，辅助方法print()也不行（可以把默认，也就是没加任何访问限定符，理解为"包访问 "，在子类中不能直接访问，但在同包中的类却可以访问）。 import demo.P public class Q extends P{ public Q(){ super(); <---------------------------Q可以访问父类的默认构造方法 } public Q(int v){ setData(v); <------------------------Q可以访问父类的protected的方法 } public String toString(){ int v = getData(); <--------------------Q 可以访问父类的public的方法 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中主要修饰符的使用(周双) 武汉理工大学计算机学院软件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() { 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.wendangku.net/doc/9711367103.html,ng包的，那么可以直接使用类名来引用指定的类，而不需要加上包名，因为包https://www.wendangku.net/doc/9711367103.html,ng不用显示使用import，它是缺省引入的； （2）如果要使用的类在其它包（https://www.wendangku.net/doc/9711367103.html,ng除外）中，那么可以通过包名加上类名来引用该 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中的修饰符 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 默认修饰符总结 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方法调用时，其他所有方法不能调 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 三个修饰符 参考答案 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#中方法、类等的默认访问修饰符 [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中各种（类、方法、属性）访问修饰符与修饰符的说明 类： 访问修饰符修饰符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关键 第三章Java语言面向对象的特征 一、选择题 1、下列对封装性的描述中，错误的是 B 。 A．封装体包含了属性和行为B．封装体中的属性和行为的访问权限是相同的C．被封装的某些信息在封装体外是不可见的 D．封装使得抽象的数据类型提高了可重用性 2、在类的修饰符中，规定只能被同一包类所使用的修饰符是 B 。 A．public B．默认C．final D．abstract 3、在成员变量的修饰符中，规定只允许该类自身访问的修饰符是 A 。A．private B．public C．默认D．protected 4、下列关于构造方法的特点的描述中，错误的是 A 。 A．不可重载B．方法名同类名C．无返回类型D．系统自动调用5、下列关于关于静态方法的描述中，错误的是 D 。 A．在类体内说明静态方法使用关键字 B．静态方法只能处理静态变量或调用静态方法 C．静态方法不占用对象的内存空间，非静态方法占用对象的内存空间 D．静态方法只能用类名调用 6、下列关于抽象类的描述中，错误的是 C 。 A．抽象类是用修饰符abstract说明的 B．抽象类是不可以定义对象的 C．抽象类是不可以有构造方法的 D．抽象类通常要有它的子类 7、下列关于接口的描述中，错误的是 B 。 A．接口实际上是由常量和抽象方法构成的特殊类 B．一个类只允许继承一个接口 C．定义接口使用的关键字是interface D．在继承接口的类中通常要给出接口中定义的抽象方法的具体实现 8、下列关于包的描述中，错误的是 A 。 A．包是一种特殊的类 B．包是若干个类的集合 C．包是使用package语句创建的 D．包有有名包和无名包两种 9、下列常用包中，存放用户图形界面类库的包是 A 。 A．java.awt B．https://www.wendangku.net/doc/9711367103.html,ng C．java.util D．java.io 10、下列是系统提供的常用的类，所有类的父类的类是 B 。 A．Math B．Object C．System D．String java 修饰符全解 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 ；私有保护访问控制符：private protected 非访问控制符有4 种：静态域修饰符：static ；最终域修饰符：final ；易失( 共享) 域修饰符：volatile ；暂时性域修饰符：transient 1 ）公共访问控制符public ：用public 修饰的域称为公共域。如果公共域属于一个公共类，则可以被所有其它类所引用。由于public 修饰符会降低运行的安全性和数据的封装性，所以一般应减少public 域的使用。 2 ）私有访问控制符private ：用private 修饰的成员变量( 域) 只能被该类自身所访问，而不能被任何其它类( 包括子类) 所引用。 3 ）保护访问控制符protected ：用protected 修饰的成员变量可以被三种类所引用：①该类自身； ②与它在同一个包中的其它类；③在其它包中的该类的子类。使用修饰符protected 的主要作用是允许其它包中它的子类来访问父类的特定属性。 4 ）私有保护访问控制符private protected ：用修饰符private protected 修饰的成员变量可以被该类本身或该类的子类两种类访问和引用。 5 ）静态域修饰符static ：用static 修饰的成员变量仅属于类的变量，而不属于任何一个具体的对象，静态成员变量的值是保存在类的内存区域的公共存储单元，而不是保存在某一个对象的内存区间。任何一个类的对象访问它时取到的都是相同的数据；任何一个类的对象修改它时, 也都是对同一个内存单元进行操作。 6 ）最终域修饰符final ：最终域修饰符final 是用来定义符号常量的。一个类的域( 成员变量) 如果被修饰符final 说明，则它的取值在程序的整个执行过程中都是不变的。 7 ）易失( 共享) 域修饰符volatile ：易失( 共享) 域修饰符volatile 是用来说明这个成员变量可能被几个线程所控制和修改。也就是说在程序运行过程中，这个成员变量有可能被其它的程序影响或改变它的取值。因此，在使用中要注意这种成员变量取值的变化。通常volatile 用来修饰接受外部输入的域。 8 ）暂时性域修饰符transient ：暂时性域修饰符transient 用来定义一个暂时性变量。其特点是：用修饰符transient 限定的暂时性变量，将指定Java 虚拟机认定该暂时性变量不属于永久状态，以实现java访问权限修饰符
java成员变量和方法的public等访问限定符的访问权限
Java 修饰符-牛耳教育
Java主要修饰符的使用方法总结(周双)
java的四个修饰符
final修饰符
java中的修饰符
Java 默认修饰符 总结
c#类修饰符大全
Chp7 三个修饰符_参考答案
C#中方法、类等的默认访问修饰符
类、方法、属性访问修饰符与修饰符小结
JAVA第三章习题
Java修饰符的学习和实例