private void guanliyuan

合集下载

private 总结用法

1、访问权限符：(1)public：对于成员来说：任何其他类都可以访问它们〃不管在同一个包中还是在另外的包中。

对于类来说：也是一样。

(2)friendly：对于成员老说：如果一个类的成员没有任何权限修饰〃那么它门就是缺省包访问权限〃用friendly来表示〃注意friendly不是Java中的关键字〃这里是个人喜欢的方式用它表示而已。

同一个包内其它类可以访问〃但包外就不可以。

对于同一个文件夹下的、没有用package的classes〃Java会自动将这些classes初见为隶属于该目录的default package〃可以相互调用class中的friendly成员。

如以下两个class分别在同一个文件夹的两个文件中〃虽然没有引入package〃但隶属于相同的default package。

class Sundae{//以下两个方法缺省为friendlySundae(){}Void f() {System.out.println(“Sundae.f()”);}public class IceCream{public static void main(String[] args){Sundae x = new Sundae();x.f();}}对于类来说：同一个包中的类可以用。

总之〃类只可以声明为public或者friendly。

(3)private：对于对于成员来说：只能在该成员隶属于的类中访问。

class Sundae{private Sundae(){}//只能在Sundae class中被调用Sundae(int i) {}static Sundae makASundae() {return new Sundae();}}public class IceCream{public static void main(String[] args){// Sundae class中构造函数Sundae()是private〃// 所以不能用它进行初始化//Sundae x = new Sundae();Sundae y = new Sundae(1);//Sundae(int)是friendly〃可以在此调用Sundae z = Sundae.makASundae();}}对于类来说：类不可以声明为private。

简述private、protected、public、internal修饰符的访问权

1.简述 private、 protected、 public、 internal 修饰符的访问权限, 并简述考虑资源占用的情况下, 对修饰符的使用需要注意些什么.3.try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?4.您了解设计模式么？请列出您所知道的设计模式的名称。

5.在下面的例子里using System;class A{public A(){PrintFields();}public virtual void PrintFields(){}}class B:A{int x=1;int y;public B(){y=-1;}public override void PrintFields(){Console.WriteLine("x={0},y={1}",x,y);}}当使用new B()创建B的实例时，产生什么输出？6.下面这段代码输出什么？为什么？int i=5;int j=5;if (Object.ReferenceEquals(i,j))Console.WriteLine("Equal");elseConsole.WriteLine("Not Equal");9. 阅读以下说明和图，回答问题1至问题4。

【说明】某高校欲开发一个成绩管理系统，记录并管理所有选修课程的学生的平时成绩和考试成绩，其主要功能描述如下：1. 每门课程都有3到6个单元构成，每个单元结束后会进行一次测试，其成绩作为这门课程的平时成绩。

课程结束后进行期末考试，其成绩作为这门课程的考试成绩。

2. 学生的平时成绩和考试成绩均由每门课程的主讲教师上传给成绩管理系统。

3. 在记录学生成绩之前，系统需要验证这些成绩是否有效。

首先，根据学生信息文件来确认该学生是否选修这门课程，若没有，那么这些成绩是无效的；如果他的确选修了这门课程，再根据课程信息文件和课程单元信息文件来验证平时成绩是否与这门课程所包含的单元相对应，如果是，那么这些成绩是有效的，否则无效。

private作用和使用

private作⽤和使⽤定义package cn.itcast.day07.demo03;/*问题描述：定义person的年龄时，⽆法阻⽌不合理的数据被设置进来。

解决⽅案，⽤private关键字将需要保护的成员变量进⾏修饰⼀旦使⽤private进⾏修饰，那么当类当中任然可以随意访问。

但是！超出本类将⽆法使⽤。

间接访问private成员变量，就是定义了⼀对Getter/Setter⽅法必须setXxx或者getXxx命名规则对于Getter来说，不能有参数，返回值和成员变量对应；对于Setter来说，不能有返回值，参数类型和成员变量对应；*/public class Person {private String name ;//private int age;//public void show(){System.out.println("我叫；"+ name +"年龄"+age);}//这个成员⽅法，专门⽤于向age设置数据public void setAge(int num){if (num <100 && num >=9){age = num;}else {System.out.println("数据不正确");}}//这个成员⽅法，专门获取age的数据public int getAge(){return age;}//这个成员⽅法，专门⽤于向age设置数据public void setName(String re){name = re;}//这个成员⽅法，专门获取age的数据public String getName(){return name;}}调⽤package cn.itcast.day07.demo03;public class Demo03Person {public static void main(String[] args) {Person person = new Person();person.show();//默认//person.age=234;//直接访问private内容，错误写法!person.setName("asdsa");person.setAge(8);person.show();}}。

staticvoid和void区别（转）

staticvoid和void区别（转）static关键字1．作用于变量：用static声明局部变量-------局部变量指在代码块{}内部定义的变量，只在代码块内部有效（作用域），其缺省的存储方式是自动变量或说是动态存储的，即指令执行到变量定义处时才给变量分配存储单元，跳出代码块时释放内存单元（生命期）。

用static声明局部变量时，则改变变量的存储方式（生命期），使变量成为静态的局部变量，即编译时就为变量分配内存，直到程序退出才释放存储单元。

这样，使得该局部变量有记忆功能，可以记忆上次的数据，不过由于仍是局部变量，因而只能在代码块内部使用（作用域不变）。

用static声明外部变量-------外部变量指在所有代码块{}之外定义的变量，它缺省为静态变量，编译时分配内存，程序结束时释放内存单元。

同时其作用域很广，整个文件都有效甚至别的文件也能引用它。

为了限制某些外部变量的作用域，使其只在本文件中有效，而不能被其他文件引用，可以用static关键字对其作出声明。

总结：用static声明局部变量，使其变为静态存储方式，作用域不变；用static声明外部变量，其本身就是静态变量，这只会改变其连接方式，使其只在本文件内部有效，而其他文件不可连接或引用该变量。

2．作用于函数：使用static用于函数定义时，对函数的连接方式产生影响，使得函数只在本文件内部有效，对其他文件是不可见的。

这样的函数又叫作静态函数。

使用静态函数的好处是，不用担心与其他文件的同名函数产生干扰，另外也是对函数本身的一种保护机制。

如果想要其他文件可以引用本地函数，则要在函数定义时使用关键字extern，表示该函数是外部函数，可供其他文件调用。

另外在要引用别的文件中定义的外部函数的文件中，使用extern声明要用的外部函数即可。

参考资料：①《 C程序设计（第二版）》，谭浩强②《 Pointers on C 》，Kenneth A.Reekvoid和void指针void的含义void即“无类型”，void *则为“无类型指针”，可以指向任何数据类型。

private static void语句

文章标题：深入理解private static void语句在软件开发中，private static void语句是一个非常重要的概念。

它在面向对象的编程中起着至关重要的作用，影响着程序的结构和性能。

在本文中，我们将深入探讨private static void语句的含义、用途和原理，并共享个人的见解和理解。

1. private static void 的含义让我们来了解一下private static void语句的含义。

在Java等面向对象的编程语言中，private是一种访问修饰符，表示该成员只能在所属的类内部访问，不能被其他类直接访问。

static表示该方法或成员属于类级别，而不是实例级别，可以通过类名直接访问，无需创建对象。

而void表示该方法没有返回值。

private static void语句表示一个只能在所属类内部访问，属于类级别的方法，没有返回值。

2. private static void 的用途接下来，让我们来探讨private static void语句的用途。

通常情况下，private static void方法用于封装一些内部的逻辑，不希望被外部直接调用，同时又不需要返回数值。

一个工具类中的一些辅助方法就可以使用private static void来实现。

private static void方法也常用于实现一些初始化的逻辑，或者进行一些内部状态的管理，起到了将代码封装、模块化的作用。

3. private static void 的原理再来，我们来探讨private static void语句的原理。

在Java虚拟机中，private static void方法是以特定的字节码形式存在的。

在编译阶段，私有静态方法会被编译成普通的静态方法，只是在类的内部调用时需要用到额外的访问标识符。

这些方法的字节码会随着类的加载而加载到方法区中，可以被类的所有实例共享。

4. 个人观点和理解我想共享一下我对private static void语句的个人观点和理解。

Java中public，private，final，static等概念的解读

Java中public，private，final，static等概念的解读作为刚⼊门Java的⼩⽩，对于public，private，final，static等概念总是搞不清楚，到底都代表着什么，这⾥做⼀个简单的梳理，和⼤家分享，若有错误请指正，谢谢~访问权限修饰符public和private是访问权限修饰符，⽤于控制外界对类内部成员的访问。

public：表明对象成员是完全共有的，外界可以随意访问。

private：表明对象成员是完全私有的，不容许外界的任何访问。

具体关于public，private的内容请移步：，进⼀步有关protected的内容请移步：类成员变化修饰符static和final是控制类成员变化的修饰符。

static：静态成员修饰符，其修饰的静态变量脱离具体对象独⽴存在，在内存中之后⼀份拷贝，所有的对象都公⽤这⼀个存储空间，所以对static修饰的静态变量进⾏的修改对该类的所有对象都起作⽤。

static修饰的静态函数代表所有对象的统⼀操作，只能调⽤静态变量。

static是针对⾯向对象中的“多态”⽽提出来的，static修饰的静态成员不存在多态性。

final：final⽤来修饰⽅法和属性表⽰特殊的意义。

修饰⽅法时表⽰⽅法不能被重写；修饰属性时表⽰属性不能被改变，这⾥属性⼜分为对象和基本类型，修饰基本类型表⽰基本类型赋值以后不能再被赋值，修饰对象表⽰这个属性不能再指向其他对象（引⽤不变），但是他指向的这个对象本⾝还是可以被改变的。

既然final⽅法不可重写，那下⾯这段程序是否有错呢？class Base {private final void method() {System.out.println("In Base...");}}class Sub extends Base {public void method() {System.out.println("In Sub...");}}答案：正确的。

仓库管理系统

课程设计仓库管理系统课程面向对象程序设计实践课程号j1620202学生姓名卢云和学号201311672214所在学院信息学院所在班级1132班任课教师陈海生提交时间2014年 6 月 12 日论文（设计）任务书附件：仓库管理系统一、功能设计1.建立文件（1）存储文件可以使用默认文件名或指定文件名。

（2）可以不保存输出记录，但需要确认是否保存输入记录。

（3）如果已经有文件，只能在其后追加。

（4）新增的记录继续存入原文件中。

2.文件的存取和显示（1）可以单独存取文件。

（2）可以随时显示内存中记录的全部内容。

（3）可以直接存取指定文件3.删除记录（1）可以按“商品名称”方式删除并且将记录修改更新。

（2）能给出被删除记录的信息。

（3）如果库存已经是空的，删除时应给出提示信息返回主菜单。

（4）如果没有要删除的这个商品信息，输出没有找到的提示信息（5）删除操作仅限内存，只有执行存记录操作时候，才能覆盖原记录。

4.查询记录（1）可以按“商品名称”、“商品价格”或“商品种类”三种方式查询记录。

（2）能给出查询记录的信息。

（3）如果查询的信息不存在，输出“没有找到”的信息。

5.使用菜单实现的功能正确选择6.测试程序（1）应列出测试大纲对程序进行测试（2）应保证测试用例能测试到程序的各种边缘情况。

编写此程序至少要用二个以上的下列面向对象工具：类、继承和派生、友元函数、构造函数、虚函数、模板、文件输入输出二、设计过程1．创建类：class cangku //仓库类{public:string name;//商品名称double price;//商品价格string kind;//商品种类long count;//商品数量cangku(){};};class guanli:private cangku //管理类{public:string name1;//商品名称1double price1;//商品价格1string kind1;//商品种类1long count1;//商品数量1guanli(){}; //管理函数1int show_guanli(); //界面void in_ruku(); //入库void out_chuku(); //出库void chaxun_cha(); //查询void chaxun_name(); //按商品名称查询void chaxun_price(); //按商品价格查询void chaxun_kind(); //按商品种类查询void del_shanchu(); //删除};2．定义各个函数：void guanli::in_ruku(){…} //入库void guanli::out_chuku(){…} //出库void guanli::chaxun_cha(){…} //查询void guanli::chaxun_name(){…} //按商品名称查询void guanli::chaxun_price(){…} //按商品价格查询void guanli::chaxun_kind(){…} //按商品种类查询void guanli::del_shanchu(){…} //删除3.定义主函数：Int main(){…}4．知识点：类，对象，继承，函数的调用，文件输入输出等。

c语言private函数

c语言private函数在C语言中，没有像Java或C++中的"private"关键字来定义私有函数。

C语言是一种过程式编程语言，没有提供访问修饰符来限制函数的访问权限。

然而，有一些方法可以模拟私有函数的概念。

1.文件范围函数：在一个C源文件中定义的函数默认是只在该文件范围内可见，其他源文件无法调用这些函数。

在一个源文件中定义一组私有函数，可以通过将它们放在文件开头或者在函数定义前加上static关键字来实现。

定义为静态的函数只在当前文件中可见，其他文件无法调用。

```cstatic void privateFunction1( { // 私有函数1//函数实现}static void privateFunction2( { // 私有函数2//函数实现}```在同一文件中的其他函数可以自由地调用这些静态函数，但在其他文件中是不可见的。

可以将私有函数的声明放在源文件的头部，但不在头文件中暴露。

使用注释或命名约定来告诉其他人不要调用这些函数。

```c/* Private function declaration */void privateFunction(; // 私有函数，在头文件中不声明void publicFunctio//公有函数privateFunction(; // 调用私有函数}void privateFunctio//私有函数的定义}```将私有函数的声明和定义放在同一个源文件中，可以确保只有在该文件内才能调用它。

3.通过指针传递函数：可以在C语言中将函数传递给其他函数作为参数。

通过定义一个公有函数，它接收私有函数作为参数，然后在公有函数中调用私有函数。

```cvoid privateFunctio//私有函数的实现}void publicFunction(void (*pFunc)()//公有函数，接收函数指针作为参数pFunc(; // 调用传递进来的函数指针}```这种方法可以将私有函数的实现隐藏在外部代码之外，只允许调用公有函数来间接调用私有函数。

private构造函数析构函数

private构造函数析构函数很多情况下要求当前的程序中只有⼀个object。

例如⼀个程序只有⼀个和数据库的连接，只有⼀个⿏标的object。

通常我们都将构造函数的声明置于public区段，假如我们将其放⼊private区段中会发⽣什么样的后果？这意味着什么？（1）构造函数定义private当我们在程序中声明⼀个对象时，编译器为调⽤构造函数(如果有的话)，⽽这个调⽤将通常是外部的，也就是说它不属于class对象本⾝的调⽤，假如构造函数是私有的，由于在class外部不允许访问私有成员，所以这将导致编译出错。

然⽽，对于class本⾝，可以利⽤它的static公有成员，因为它们独⽴于class对象之外，不必产⽣对象也可以使⽤它们。

此时因为构造函数被class私有化，所以我们要创建出对象，就必须能够访问到class的私有域；这⼀点只有class的成员可以做得到；但在我们建构出其对象之前，怎么能利⽤它的成员呢？static公有成员，它是独⽴于class对象⽽存在的，“我们”可以访问得到。

假如在某个static函数中创建了该class的对象，并以引⽤或者指针的形式将其返回（这⾥不以对象返回，主要是构造函数是私有的，外部不能创建临时对象），就获得了这个对象的使⽤权。

下⾯是例⼦：class OnlyHeapClass{public:static OnlyHeapClass* GetInstance(){// 创建⼀个OnlyHeapClass对象并返回其指针return (new OnlyHeapClass);}void Destroy();private:OnlyHeapClass() { }~OnlyHeapClass() {}};int main(){OnlyHeapClass *p = OnlyHeapClass::GetInstance();... // 使⽤*pdelete p;return 0;}这个例⼦使⽤了私有构造函数，GetInstance()作为OnlyHeapClass的静态成员函数来在内存中创建对象：由于要跨函数传递并且不能使⽤值传递⽅式，所以我们选择在堆上创建对象，这样即使getInstance()退出，对象也不会随之释放，可以⼿动释放。

【JAVA的四种访问类别】public，protected，package-private。。。

【JAVA的四种访问类别】public，protected，package-
private。

Java中有三个很常⽤的关键字：public protected 和 private。

我们可以称呼他们为访问控制(级别)，也可称呼为作⽤域。

怎么称呼都不重要，重要的是理解他们的作⽤及⽤法。

Java访问级别包含两个部分:1)对类和访问级别 2)对成员的访问级别。

在对类的访问进⾏限制的时候，关键字可以是public或者不明确指定类修饰符（package-private）。

在对类⾥⾯的成员做访问限制时，可以使⽤public，protected，package-private（不指明关键字），private
下⾯的表格总结了不同的关键字在修饰成员时候的访问级别。

访问级别决定了类中的字段和⽅法的可访问性。

public void与public static void区别
public void定义的是普通的⽅法，⽽public static void 定义的是静态的⽅法。

普通的⽅法需要new对象去调⽤，⽽静态的⽅法可以直接⽤类名去调⽤。

————————————————
版权声明：本⽂为CSDN博主「Franco蜡笔⼩强」的原创⽂章，遵循CC 4.0 BY-SA版权协议，转载请附上原⽂出处链接及本声明。

原⽂链接：https:///w372426096/article/details/78012551。

private void语法

private void语法private void语法是一种Java语言的修饰符，它用于声明一个方法或变量。

它表示只能在声明它的类内部使用这个方法或变量，而不能在其他类中使用。

因此，private void语法可以将类的某些功能和数据隐藏起来，以便只有本类的对象才能访问它们，避免其他类恶意干扰。

首先，private void语法有助于实现封装。

封装是一种思想，即将类中的数据和方法封装起来，以便它只能通过特定的方式访问。

通过使用private void语法，可以有效地将类中的数据和方法封装起来，并且只有本类的对象才能访问它们。

这样，可以有效地保护类中的数据和方法，避免外部类恶意干扰。

其次，private void语法也可以使类的代码更加简洁。

当一个类中的方法和变量无需被外部类调用时，可以直接使用private void语法将它们封装起来。

这样，类的代码会变得更加简洁，更易于阅读和维护。

此外，使用private void语法可以确保类中的方法和变量被正确使用。

如果一个类中的方法和变量不被正确使用，可能会出现各种意外的错误，而且这些错误可能很难检测到。

但是，使用private void语法封装的方法和变量只能在本类中使用，因此可以有效地减少类中方法和变量被不正确使用的可能性。

最后，使用private void语法还可以节省计算机的资源。

类中的方法和变量被封装起来之后，只有本类的对象能够访问它们，其他类的对象就无法访问它们，因此可以有效节省计算机的资源。

总之，private void语法是Java语言中一种常见的修饰符，它可以有效地将类中的数据和方法封装起来，使类的代码更加简洁，并有助于确保类中的方法和变量被正确使用，从而节省计算机的资源。

因此，private void语法在Java语言中有着重要的作用。

private protected语法

private protected语法在编程中，`private` 和 `protected` 是访问修饰符，它们用于控制类成员（例如变量、方法等）的可见性和访问权限。

这些修饰符决定了类成员的访问级别。

以下是 `private` 和 `protected` 的一些要点：1. Private Access修饰符：`private` 修饰符表示该成员只能在它所属的类中被访问。

私有成员对于类的外部是不可见的，因此无法从类的外部直接访问。

这是封装的一个重要组成部分，因为它确保了数据隐藏在类的内部。

2. Protected Access修饰符：`protected` 修饰符表示该成员可以在它所属的类以及其他任何派生自该类的子类中被访问。

保护成员在类的外部是不可见的，但在派生自该类的子类中是可见的。

这使得派生类能够继承和修改基类的行为或数据。

示例：下面是一个简单的示例，展示了 `private` 和 `protected` 的用法：```csharppublic class MyClass {// 私有成员，只能在 MyClass 中访问private int privateVar = 10;// 保护成员，可以在 MyClass 和派生自 MyClass 的子类中访问 protected int protectedVar = 20;public void DoSomething() {// 可以访问 privateVar 和 protectedVar// ...}}public class MySubClass : MyClass {public void SubClassMethod() {// 可以访问 protectedVar，但不能访问 privateVar// ...}}```在这个示例中，`privateVar` 是私有的，只能在 `MyClass` 中访问。

而`protectedVar` 是保护的，可以在 `MyClass` 和任何派生自 `MyClass` 的子类中访问。

c++ private构造函数

C++中的private构造函数是指类的构造函数被声明为private，这意味着该类不能被实例化，只能在类内部被调用。

private构造函数在C++中有着重要的作用，本文将详细介绍private构造函数的特点、用途以及示例。

一、private构造函数的特点1. private构造函数是指类的构造函数被声明为private，这样在类外部就无法创建该类的实例，只能在类内部通过特定方法创建实例。

2. private构造函数通常与静态成员函数或友元函数一起使用，通过这些函数来创建类的实例。

二、private构造函数的用途1. 实现单例模式：通过private构造函数和静态成员函数创建实例，实现单例模式，保证程序中只有一个实例存在。

2. 控制对象的创建方式：通过友元函数或静态成员函数来创建类的实例，可以对对象创建过程进行限制和控制，提高程序的安全性和可维护性。

三、private构造函数的示例下面通过一个示例来说明private构造函数的用法：```cpp#include <iostream>using namespace std;class Singleton {private:Singleton() {} // private构造函数public:static Singleton getInstance() {static Singleton instance; // 在静态成员函数中调用private构造函数return instance;}};int main() {Singleton obj = Singleton::getInstance(); // 通过静态成员函数创建实例// Singleton obj2; // 无法编译通过，private构造函数无法在外部调用return 0;}```在上面的示例中，Singleton类的构造函数被声明为private，因此外部无法直接调用构造函数来创建实例，而是通过静态成员函数getInstance来获取实例。

private static void语句

private static void语句（原创版）目录1.静态方法的定义与使用2.静态变量的定义与使用3.静态块的定义与使用正文在 Java 编程语言中，静态（static）是一种关键字，用于定义静态成员。

静态成员属于类，而不是类的实例。

因此，静态成员不依赖于类的实例，可以直接通过类名来访问。

本文将介绍 Java 中静态方法、静态变量和静态块的定义与使用。

1.静态方法的定义与使用静态方法属于类，可以通过类名直接调用。

静态方法不能访问非静态成员，包括非静态变量和非静态方法。

静态方法的定义格式如下：```javastatic returnType methodName(parameterList) {// method implementation}```例如：```javapublic class MathUtils {public static int add(int a, int b) {return a + b;}}```在上述代码中，我们定义了一个名为 MathUtils 的类，其中包含一个静态方法 add，用于计算两个整数的和。

要调用这个静态方法，我们可以这样写：```javaint sum = MathUtils.add(3, 4);```2.静态变量的定义与使用静态变量属于类，被所有类的实例共享。

静态变量在类加载时分配内存，并且只分配一次，直到程序结束才被释放。

静态变量的定义格式如下：```javastatic dataType variableName = initialValue;```例如：```javapublic class Constants {public static final int MAX_VALUE = 100;public static final String DEFAULT_STRING = "Default";}```在上述代码中，我们定义了一个名为 Constants 的类，其中包含两个静态变量：一个整数类型的 MAX_VALUE 和一个字符串类型的DEFAULT_STRING。

调用private方法吗

调用private方法吗是的，可以调用私有方法。

在面向对象编程中，一个类的方法可以被分为公有方法和私有方法。

公有方法是可以被类的外部代码直接调用的方法，而私有方法只能在类的内部被访问和调用。

为什么要使用私有方法呢？私有方法通常是为了隐藏类的内部实现细节，使得类的使用者只需关注公有方法的调用即可，而不需要了解和关心私有方法的具体实现。

私有方法可以在类的内部被直接调用，可以被公有方法使用，从而可以提高代码的复用性和可维护性。

在Java中，私有方法的定义使用关键字private来修饰，只有在同一个类的内部才能被访问和调用。

私有方法的作用域仅限于定义它的类，对于外部代码而言是不可见的。

那么如何在类的内部调用私有方法呢？在类的内部，可以直接使用私有方法的名称来调用它，就像调用其他方法一样。

私有方法可以像普通方法一样传递参数，并且可以有返回值。

调用私有方法与调用其他方法没有什么本质区别，只是私有方法只能在同一个类的内部被调用。

以下是一个示例代码，演示了如何在一个Java类的私有方法中实现两个整数相加的功能，并在公有方法中调用私有方法来实现两个数相加的功能。

javapublic class MyClass {public int addTwoNumbers(int a, int b) {int sum = privateMethod(a, b);return sum;}private int privateMethod(int a, int b) {return a + b;}public static void main(String[] args) {MyClass obj = new MyClass();int result = obj.addTwoNumbers(10, 20);System.out.println("Sum: " + result);}}在上述示例中，MyClass类定义了一个公有方法addTwoNumbers，该方法接收两个整数参数，并调用了私有方法privateMethod来实现两个数相加的功能。

深入理解C++中public、protected及private用法

深⼊理解C++中public、protected及private⽤法深⼊理解C++中public、protected及private⽤法这篇⽂章主要介绍了C++中public、protected及private⽤法,对于C++⾯向对象程序设计来说是⾮常重要的概念,需要的朋友可以参考下初学C++的朋友经常在类中看到public，protected，private以及它们在继承中表⽰的⼀些访问范围，很容易搞糊涂。

今天本⽂就来⼗分分析⼀下C++中public、protected及private⽤法。

相信对于⼤家深⼊掌握C++程序设计会有很⼤的帮助。

这⾥我们⾸先要明⽩下⾯⼏点。

1.类的⼀个特征就是封装，public和private作⽤就是实现这⼀⽬的。

所以：⽤户代码（类外）可以访问public成员⽽不能访问private成员；private成员只能由类成员（类内）和友元访问。

2.类的另⼀个特征就是继承，protected的作⽤就是实现这⼀⽬的。

所以：protected成员可以被派⽣类对象访问，不能被⽤户代码（类外）访问。

现来看看如下⽰例：#include<iostream>#include<assert.h>using namespace std;class A{public:int a;A(){a1 = 1;a2 = 2;a3 = 3;a = 4;}void fun(){cout << a << endl; //正确cout << a1 << endl; //正确cout << a2 << endl; //正确，类内访问cout << a3 << endl; //正确，类内访问}public:int a1;protected:int a2;private:int a3;};int main(){A itema;itema.a = 10; //正确itema.a1 = 20; //正确itema.a2 = 30; //错误，类外不能访问protected成员itema.a3 = 40; //错误，类外不能访问private成员system("pause");return 0;}先记住：不管是否继承，上⾯的规则永远适⽤！有public, protected, private三种继承⽅式，它们相应地改变了基类成员的访问属性。

Javaclass的前面添加public和不添加public有什么区别？

Javaclass的前⾯添加public和不添加public有什么区别？
*⽤于修饰类和变量，指定其适⽤范围的关键字有：
1. public：表⽰公开的类和变量，既所有的类都可以引⼊使⽤的。

2. protected：表⽰受保护的类，只有⼦类和本类可以引⼊使⽤。

3. 默认package：表⽰同包中和本类中可以引⼊使⽤。

4. private：表⽰私有的，只在本类中可以引⼊使⽤。

所以显⽽易见，如果⼀个class前⾯如果添加了public修饰则可以被所有类引⼊使⽤，如果没有加任何修饰词，那么就只能够被同包中的类和本类引⼊使⽤。

*在java中public void与public static void有什么区别 ?
public void 修饰⾮静态⽅法，该⽅法属于对象，在对象初始化（new Object()）后才能被调⽤；public static void 修饰静态⽅法，该⽅法属于类，使⽤类名.⽅法名直接调⽤。

⾮静态⽅法之间可以互相调⽤，⾮静态⽅法也可以调⽤静态⽅法；但是静态⽅法中不可以直接调⽤（未初始化的）⾮静态⽅法。

public static void main 属于静态⽅法，遵循上述原则。

特殊之处，Java 可以通过对象名调⽤静态⽅法（对象名.静态⽅法），不会导致语法错误（syntax error），但是不推荐这样使⽤，因为静态⽅法与⾮静态⽅法在被调⽤时应当明确区分，⽽且其他 OOP 语⾔如 C#，Swift，Objective-C 都没有这样的语法。