protected访问权限

合集下载

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

简述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. 在记录学生成绩之前,系统需要验证这些成绩是否有效。

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

c#基础试题

c#基础试题

C#基础题一、问答题:1、简述 private、 protected、 public、 internal 修饰符的访问权限答:private访问仅限于包含类型。

protected访问仅限于包含类或从包含类派生的类型。

public访问不受限制。

internal访问仅限于当前程序集。

2、override与重载的区别答:1、 override是声明方法或属性重写基类中的方法或属性。

指类和类的关系,new,virtual。

重载是在一个类中用相同的名称但是不同的参数类型创建一个以上的过程、实例构造函数或属性。

2、重载的成员用于提供属性或方法的不同版本,这些版本具有相同名称但是接受不同数量的参数或者接受不同数据类型的参数。

重写的属性和方法用于替换在派生类中不适合的继承的属性或方法。

重写的成员必须接受同一数据类型和参数数量。

派生类继承重写的成员。

3、C#中接口和类的异同答:1、 (1)、接口定义所有派生类应该遵守的语法协议,而类实现了接口定义的部分。

(2)、接口也定义属性、方法和事件,它们被称为接口的成员。

注意接口只包含成员的声明,类和结构实现这些接口成员。

(3)、接口在你想让后面的类都遵守标准的函数结构的时候被使用,这里类将实现功能。

2、(1)、接口描述的是可属于任何类或结构的一组相关功能。

接口可由方法、属性、事件、索引器或这四种成员类型的任意组合构成。

接口不能包含字段。

接口成员一定是公共的。

类只能继承一个,接口可以多个继承。

接口只有方法签名,不能有其他普通变量。

类可以。

(2)、类和结构可以按照类继承基类或结构的类似方式继承接口,但有两个例外:类或结构可继承多个接口。

类或结构继承接口时,仅继承方法名称和签名,因为接口本身不包含实现。

3、接口具有下列属性:接口类似于抽象基类:继承接口的任何非抽象类型都必须实现接口的所有成员。

不能直接实例化接口。

接口可以包含事件、索引器、方法和属性。

接口不包含方法的实现。

类和结构可从多个接口继承。

protected和private区别

protected和private区别

protected和private区别
1、public:public表明该数据成员、成员函数是对所有用户开放的,所有用户都可以直接进行调用
2、private:private表示私有,私有的意思就是除了class自己之外,任何人都不可以直接使用。

3、protected:protected对于子女、朋友来说,就是public的,可以自由使用,没有任何限制,而对于其他的外部class,protected就变成private。

扩展资料:
三种类型的继承,父类的成员均被子类继承(之前的百科关于这点的描述是错误的),只是由类实例化的对象对其继承的成员的访问权限会有所变化。

三种不同方式的继承,描述的是子类实例化对象对其成员的访问权限,并非是描述子类时,子类对继承自父类的成员的访问权限。

公有继承继承自父类的成员保持不变。

私有继承继承自父类的成员全部变为私有成员。

保护继承继承自父类的公有成员变为保护成员,其余不变。

java中修饰符的限制范围

java中修饰符的限制范围

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:表示同步,适用于需要线程安全的方法或代码块。

C++中protected的访问权限

C++中protected的访问权限

C++中protected的访问权限转载,释然读C++ Primer ⼼中疑惑:关于C++中protected的访问权限的讨论已经是⼀个很陈旧的话题了,陈旧到⼤家都不愿意去讨论,觉得他见到到吃饭睡觉那么⾃然。

我再次读《C++ Primer》的时候,其中关于protected 成员的描述是这样的:protected MembersThe protected access label can be thought of as a blend of private and public :Like private members, protected members are inaccessible to users of the class.Like public members, the protected members are accessible to classes derived from this class.In addition, protected has another important property:A derived object may access the protected members of its base class only through a derived object. The derived class has no special access to the protected members of base type objects.在没有继承的情况下,protected跟private相同。

在派⽣类的时候才出现分化。

上⾯那段英⽂前两条都很好理解,基类对象不能访问基类的protected成员,派⽣类中可以访问基类的protected成员。

也就是说private成员是不能被继承的,只有public,protected的成员才可以被继承。

就是最后⼀条有些迷惑⼈,派⽣类对象如果要访问基类protected成员只有通过派⽣类对象,派⽣类不能访问基类对象的protected成员。

C++中类继承public,protected和private关键字作用详解及派生类的访问权限

C++中类继承public,protected和private关键字作用详解及派生类的访问权限

C++中类继承public,protected和private关键字作⽤详解及派⽣类的访问权限注意:本⽂有时候会⽤Visual Studio Code⾥插件的⾃动补全功能来展⽰访问权限的范围(当且仅当⾃动补全范围等价于对象访问权限范围的时候),但是不代表⽇常使⽤时只要是出现在⾃动补全范围内的可调⽤对象/成员都是可访问的。

⼀,公有继承#include<cstdio>#include<iostream>#include<string>#include<algorithm>#include<vector>class Base{public:int PublicBase;void PublicPrint() {std::cout << "PublicPrint()" << std::endl;}protected:int ProtectedBase;void ProtectedPrint() {std::cout << "ProtectedPrint()" << std::endl;}private:int PrivateBase;void PrivatePrint() {std::cout << "PrivatePrint()" << std::endl;}};class Derived : public Base{public:void DerivedPrint() {std::cout << "DerivedPrint()" << std::endl;std::cout << ProtectedBase << std::endl;//若要访问protected的数据成员需要通过派⽣类⾥的成员函数访问PublicPrint();ProtectedPrint();}};int main(void){Derived der;der.PublicPrint();der.PublicBase;//der.ProtectedBase; //不能直接访问protected数据成员//der.ProtectedPrint();//意思同上return0;} 公有继承的派⽣类可以直接访问基类的public中的数据成员和成员函数,不能直接访问protected中的数据成员和成员函数,若要访问protected的数据成员需要通过派⽣类⾥的成员函数访问。

Java外部类为什么不能用protected、private修饰

Java外部类为什么不能用protected、private修饰

Java外部类为什么不能⽤protected、private修饰
java只有四种访问控制权限:private、default、protected、public
private:当前类访问权限
default:包访问权限
protected:⼦类访问权限
public:公共访问权限
外部类为什么不能使⽤protected、private修饰:
1.不能⽤private:
对于⼀个外部类,⽤private修饰是没有意义的。

因为如果使⽤private修饰外部类,其它类就不能访问的这个类,那么这个类就不能创建实例,这个类的属性和⽅法就不能被外界访问,所以没有意义。

2.不能⽤protected:
protected是⽤来修饰类中的属性和⽅法的,不是⽤来修饰类的。

假如定义⼀个A类⽤protected修饰,再在与A类不同包的另⼀个保重定义⼀个B类,B类如果要继承A类,前提是B类能够访问到A类。

仔细想想就会发现这是冲突的。

(你要成为A类的⼦类,你的先访问到A类,但你要访问到A类,那你先得成为A类的⼦类。

因为protected修饰的类就是给⼦类访问的)这个逻辑明显是冲突的。

所以不仅是外部类,普通类也不能⽤protected修饰。

这时肯定有⼈会说:把B类放在A类同⼀个包下,那B类不就可以访问到A类了吗?
但是:如果你把B类放在和A类同⼀个包下,那和⽤default修饰A类有什么区别,既然和default没有区别,那⼲嘛还要⽤protected修饰A类,⽽且protected本⾝可以跳出同⼀个包访问的意义也不存在了,所以⽤protected修饰类是没有意义的。

C++类成员的访问权限及继承方式(public,protected,private)

C++类成员的访问权限及继承方式(public,protected,private)

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()<<"。

java中权限修饰符protected的使用注意事项

java中权限修饰符protected的使用注意事项

java中权限修饰符protected的使⽤注意事项
java中四种权限修饰符, 平时编码中最常⽤的其实public和private, 虽然对protected的概念⼀直都知道, 但真正使⽤时才发现有些偏差. protected表⽰被其修饰的成员可以被本类, 同包下的所有类, 以及本类的所有⼦类所访问.
被本类的所有⼦类访问很容易让⼈产⽣误解, 我在进⾏测试时, 第⼀反应就是在不同包下创建⼀个⼦类, 在main⽅法中new⼀个⽗类对象, 试图通过该对象.成员变量名来调⽤protected的成员变量, 然⽽, 结果是------>编译出错 0.0
查了⼀下资料,才知道, protected所谓的可以被⼦类访问, 是指可以被⼦类通过继承的⽅式直接拿来使⽤, 也就是说, 我需要new⼀个⼦类对象,再调⽤该变量就没问题了.。

详谈PHP中public,private,protected,abstract等关键字的用法

详谈PHP中public,private,protected,abstract等关键字的用法

详谈PHP中public,private,protected,abstract等关键字的⽤法PHP中常⽤的关键字在PHP中包含了很多对函数和类进⾏限制的关键字,常⽤的通常有abstract,final,interface,public,protected,private,static等等,下⾯我们就将对这些进⾏分析整理各个的⽤法。

变量与⽅法的关键字public,private,protectedpublic的权限最⼤,既可以让⼦类使⽤,也可以⽀持实例化之后的调⽤,protected表⽰的是受保护的,访问的权限是只有在⼦类和本类中才可以被访问到private 表⽰的是私有,只能够是在当前的类中可以被访问到<?php///*** Define MyClass*/class MyClass{public $public = 'Public';protected $protected = 'Protected';private $private = 'Private';public function printHello(){echo $this->public;echo $this->protected;echo $this->private;}protected function pro_test(){var_dump(1);}}$obj = new MyClass();echo $obj->public; // 这⾏能被正常执⾏//echo $obj->protected; // 这⾏会产⽣⼀个致命错误//echo $obj->private; // 这⾏也会产⽣⼀个致命错误$obj->printHello(); // 输出 Public、Protected 和 Private$obj->pro_test();//直接报错>变量与⽅法的关键字staticstatic的作⽤就是能够实现值或者⽅法在类中不需实例化的情况下调⽤,同时static修饰的变量具有与值存储的功能,例如我们不使⽤static运⾏的结果如下:<?phpfunction test(){$var=1;echo $var."</br>";$var++;}test();// 1test();// 1test();// 1>如果我们给变量加上static那么就会变成这样<?phpfunction test(){static $var=1;echo $var."</br>";$var++;}test();// 1test();// 2test();// 3这⾥可能不能够体会到PHP这样做的好处,那么我们就先来假设⼀下读者也熟悉JS,在JS中是没有static这个关键字的,所以如果我们要来实现⼀个具有能够保存每⼀次程序运算结果作为下⼀次运算的依据的⼀个程序我们需要这样来写。

方法 protected

方法 protected

方法protectedprotected是一种访问修饰符,在面向对象编程中用于控制类成员的访问级别。

它的作用是在保证数据封装的同时,提供对子类的访问权限。

本文将介绍protected的用途、访问权限、示例以及与其他访问修饰符的比较。

首先,protected的主要用途是在类的继承关系中提供给子类访问父类的成员变量和方法的权限。

在Java语言中,只有public和protected修饰符可以让子类继承父类的成员,且protected只能被子类继承。

protected修饰符比private 更为开放,允许子类具有对父类成员的直接访问权限,但仍然保持了数据封装的特性,避免了对外部的过度暴露。

其次,protected对于多层继承也起到了一定的作用。

当一个子类继承了父类,并且这个子类又被其他子类继承时,protected修饰的成员变量和方法可以在整个继承链上被访问,而private修饰的成员则只能在父类中被访问。

这样可以使得继承链上的子类能够间接地访问父类的成员,保证了继承性的特点。

在访问权限方面,protected的访问权限介于public和private之间。

被protected修饰的成员对于定义它的类以及同一包内的类和子类可见,而对于其他包中的类是不可见的。

这样可以在外部类中限制对父类成员的直接访问,只有继承了父类的子类才能访问。

这是一种权衡,保证了类的封装性。

下面通过一个示例来进一步说明protected的用法。

假设有一个父类Animal,其中有一个protected成员变量name和一个protected方法sleep。

在子类Dog中,可以直接访问父类的name成员变量和sleep方法。

javapublic class Animal {protected String name;protected void sleep() {System.out.println("Animal is sleeping...");}}public class Dog extends Animal {public void bark() {System.out.println("Dog is barking...");System.out.println("Dog's name is " + name); 可以访问父类的name成员变量sleep(); 可以访问父类的sleep方法}}public class Main {public static void main(String[] args) {Dog dog = new Dog();dog.bark();}}在这个示例中,Dog类继承了Animal类,并通过protected访问修饰符直接访问了Animal类中的成员变量和方法。

protected用法

protected用法

protected用法以下是 7 条关于“protected 用法”的内容:1. 嘿,你知道吗,protected 就像是给特定成员加上了一层特别的保护罩!比如说在一个家庭里,一些珍贵的东西会放在特定的柜子里,只有特定的家人能接触,这和 protected 限制访问权限不是很像吗?它能确保只有该类及其子类能访问这些成员呢。

2. 哇塞,protected 可是有大作用的哟!想象一下,一个团队里有一些重要的策略只让核心成员和他们的接班人知道,这就跟 protected 很像啦!就像只有符合特定条件的才能触及那些受保护的部分,能有效地保证数据的安全性呢。

3. 嘿呀,protected 用法可有意思了!好比一座城堡,有些房间只有特定的人能进,其他人想都别想,这和 protected 让特定类能访问多像呀!比如一个复杂的程序中,有些数据只能由相关的类来操作,很神奇吧!4. 哎呀,protected 可太重要啦!它就好像是一个宝藏的守护机制,只有拿着特定钥匙的人才能找到宝贝。

就像在一个游戏中,有些厉害的道具只有特定角色或他们的后代能使用,这和 protected 的那种特定访问不是一模一样嘛!5. 哇哦,你想想看,protected 不就像是一个珍贵物品的保管方式嘛!只有特定的人才能接近它。

比如在一个班级里,有些特殊的奖励只有特定的学生群体能争取到,这何尝不是一种protected 式的存在呀,它真的很有用呢!6. 嘿家伙们,protected 可真是独特啊!这就好比是一场比赛,只有特定身份的选手能进入特定的区域,其他人根本没门!就像在编程里某些成员只有特定关系的类能触及,多有意思呀!7. 哎呀呀,protected 的用法真的绝了!简直就像一把神奇的钥匙,能打开特定的门。

像在一个故事里,只有主角和他亲近的人能知道某些秘密,这和protected 的有条件访问多么契合呀!总之, protected 的这种用法真的让程序设计更加合理和安全呢!。

protected和private区别

protected和private区别

private 是完全bai私有的,只有当前类中的成员能访du问到.protected 是受保护的,只有当前类的成员与继承该zhi类的类才能访问.这两个dao是访问类中成员权限的限制符.在类外如果想使用类中的成员,只能直接使用public类型的,protected和private都是不能访问的,对于类外使用而言,这两个是完全相同的.区别:二者的bai区别主要在权限问题上,protected 是受保du护的,只有当前类zhi的成员与继承该类的类才能访问;daoprivate 是完全私有的,有当前类中的成员能访问到。

1、protected 英 [prə'tektɪd];美 [prə'tektɪd]adj. 受保护的。

动词protect的过去式和过去分词形式。

句子示例:It's against the law to kill protected animal.屠杀被保护动物是违法的。

As the protected infant industries grow, their costs sometimesfail to decline.当受保护的新兴工业增长时,有时成本无法降低。

2、private 英 ['praɪvət] ;美 ['praɪvət]adj. 私人的;个人的;私下的;私有的;缄默的;为一部份人的;内心的;与工作无关的。

n. 士兵;列兵。

句子示例:She is a very retiring and private person.她是个非常孤独缄默的人。

We each have our private views about it.我们每个人对这件事都有自己的看法。

The president is paying a private visit to Europe.总统正在欧洲进行私人访问。

C#基础题

C#基础题
A.Close B.DisposeC.Finalize
ing E.Quit
三、程序题
1、using System;
class A
{
public A(){
PrintFields();
}
public virtual void PrintFields(){}
readonly关键字与count关键字的不同:const 字段只能在该字段的声明中初始化。readonly 字段可以在声明或构造函数中初始化。因此,根据所使用的构造函数,readonly 字段可能具有不同的值。另外,const 字段是编译时常数,而 readonly 字段可用于运行时常数。
readonly 只能在声明时或者构造函数里面初始化,并且不能在 static 修饰的构造函数里面。
16、 值类型和引用类型的区别?
值类型:单元直接存放有效值。如:int I = 3; 则I内存单元就存放3。
引用类型:单元放的是另外一个对象的引用(地址)。如:Form form1=new Form();就是说在内存中开辟了一个对象new Form(),form1内存单元存放的就是那个对象的地址,并非对象本身。
18、情叙述count与readonly的区别
每一个类之多只可以定义一个static构造函数,并且不运行增加访问级别关键字,参数必须为空。
为了不违背编码规则,通常把static成员声明为private,然后通过static property提供读写访问。
count关键字用于修改字段或局部变量的声明。它制定字段或局部变量的值不能被修改。常数声明引入给的类型的一个或多个常数。
4、 在c#中using和new这两个关键字有什么意义,请写出你所知道的意义

Java学习笔记10---访问权限修饰符如何控制成员变量、成员方法及类的访问范围

Java学习笔记10---访问权限修饰符如何控制成员变量、成员方法及类的访问范围

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理解对象可见性(public、private、protected)

java理解对象可见性(public、private、protected)

java理解对象可见性(public、private、protected)
Java借助private、protected、public与默认修饰符提供了成员访问控制。

适⽤于字段、⽅法或类。

private:如果实体使⽤private修饰符声明,那么实体将只能由定义实体的类中的包含的代码访问。

类中属性的可见性⼀般为private,通过公有的Getter()⽅法和Setter⽅法供外界使⽤。

protected:实体只能由定义在如下范围内的代码访问
1. 定义实体的类
2.相同包中和定义类⼀样的类
3.定义类的⼦类,不管⼦类在那个包中定义
默认(或包):实体可以由定义在如下范围内的代码访问
1.定义实体的类
2.定义在同⼀包中的类,类似于定义实体的类
public:实体可以由任意类中的代码访问
访问修饰符与变量范围
关于继承的⼀些规则:
⼦类中继承的成员不能拥有⽐原先赋值的权限更弱的访问权限,只能拥有更强的访问权限。

最弱的访问权限时private,最强的访问权限是public。

访问权限:public>protected>默认>private
1、在超类中声明为public的⽅法必须在所有的⼦类中声明为public;
2、在超类中声明为受保护的⽅法必须要么为protected,要么为public;
3、不声明访问控制的⽅法(不适⽤修饰符)不能在⼦类中声明为private;
4、声明为private的成员⽆法被继承;。

c#面试题及答案

c#面试题及答案

• 1. 简述 private、 protected、 public、 internal 修饰符的访问权限。

答 . private : 私有成员, 在类的内部才可以访问。

protected : 保护成员,该类内部和继承类中可以访问。

public : 公共成员,完全公开,没有访问限制。

internal: 在同一命名空间内可以访问。

• 2 .列举 页面之间传递值的几种方式。

答. 1.使用QueryString, 如....?id=1; response.Redirect()....2.使用Session变量3.使用Server.Transfer• 3. 一列数的规则如下: 1、1、2、3、5、8、13、21、34...... 求第30位数是多少,用递归算法实现。

答:public class MainClass{public static void Main(){Console.WriteLine(Foo(30));}public static int Foo(int i){if (i <= 0)return 0;else if(i > 0 && i <= 2)return 1;else return Foo(i -1) + Foo(i - 2);}}• 4.C#中的委托是什么?事件是不是一种委托?答:委托可以把一个方法作为参数代入另一个方法。

委托可以理解为指向一个函数的引用。

是,是一种特殊的委托• 5.override与重载的区别答:override 与重载的区别。

重载是方法的名称相同。

参数或参数类型不同,进行多次重载以适应不同的需要Override 是进行基类中函数的重写。

为了适应需要。

• 6.如果在一个B/S结构的系统中需要传递变量值,但是又不能使用Session、Cookie、Application,您有几种方法进行处理?答:this.Server.Transfer•7.请编程遍历页面上所有TextBox控件并给它赋值为string.Empty?答:foreach (System.Windows.Forms.Control control inthis.Controls){if (control is System.Windows.Forms.TextBox){System.Windows.Forms.TextBox tb =(System.Windows.Forms.TextBox)control ;tb.Text = String.Empty ;}}•8.请编程实现一个冒泡排序算法?答:int [] array = new int•;int temp = 0 ;for (int i = 0 ; i < array.Length - 1 ; i++){for (int j = i + 1 ; j < array.Length ; j++){if (array[j] < array[i]){temp = array[i] ;array[i] = array[j] ;array[j] = temp ;}}}•9.描述一下C#中索引器的实现过程,是否只能根据数字进行索引?答:不是。

public,protect,private访问权限

public,protect,private访问权限

public,protect,private访问权限
第⼀:private, public, protected 访问标号的访问范围。

private:只能由1.该类中的函数、2.其友元函数访问。

不能被任何其他访问,该类的对象也不能访问。

protected:可以被1.该类中的函数、2.⼦类的函数、以及3.其友元函数访问。

但不能被该类的对象访问。

public:可以被1.该类中的函数、2.⼦类的函数、3.其友元函数访问,也可以由4.该类的对象访问。

注:友元函数包括3种:设为友元的普通的⾮成员函数;设为友元的其他类的成员函数;设为友元类中的所有成员函数。

第⼆:类的继承后⽅法属性变化。

private 属性不能够被继承。

使⽤private继承,⽗类的protected和public属性在⼦类中变为private;
使⽤protected继承,⽗类的protected和public属性在⼦类中变为protected;
使⽤public继承,⽗类中的protected和public属性不发⽣改变;
如下所⽰:
public: protected: private:
public继承 public protected 不可⽤
protected继承 protected protected 不可⽤
private继承 private private 不可⽤
protected继承和private继承能降低访问权限。

c++对象 protect方法

c++对象 protect方法

c++对象 protect方法
在C++中,对象的保护方法通常是通过访问控制修饰符来实现的。

C++中的访问控制修饰符包括public、protected和private。

其中,protected修饰符用于限制对类的成员的访问权限,使得只有派生类可以访问这些成员。

当成员被声明为protected时,它们可以在派生类中进行访问,但在类的外部是不可见的。

使用protected修饰符可以实现对象的保护方法,确保某些成员只能在派生类中使用,而不能被外部访问。

这样可以隐藏对象的内部实现细节,同时允许派生类扩展和重用基类的功能。

另外,C++中还可以通过使用友元函数或友元类来实现对象的保护方法。

友元函数或友元类可以访问类的私有成员,从而在一定程度上保护对象的数据,但需要谨慎使用,因为过多地暴露对象的内部实现细节可能会破坏封装性。

总的来说,C++中可以通过访问控制修饰符和友元函数或友元类来实现对象的保护方法,从而确保对象的数据和实现细节不被随意访问和修改,同时允许派生类进行必要的扩展和重用。

【转】protected成员访问权限

【转】protected成员访问权限

【转】protected成员访问权限前⼏天我⼀个朋友问我,在⼦类中为什么不能访问⽗类的protected⽅法?她在某本书上看到的代码⼤概是如下所⽰:public class A{public string Name = "";protected int Age = 0;}public class AB : A{public void Init(){A a = new A(); = "lifengguo";a.Age = 24;}}但是她编译时总是不能通过,她问我为什么?是我的理解是:Protected是受保护成员,它在它的类中可访问并且可由派⽣类访问。

上⾯的⼀句包含了三层意思:1、类的本⾝可以访问;2、派⽣类中可以访问;3、类的实例是不能够访问Protected成员的。

下⾯代码是在类的本⾝使⽤了Protected成员public class A{public string Name = "";protected int Age = 0;public A(){Name = "lifengguo";Age = 24;}}下⾯的代码是在派⽣类中使⽤了Protected成员public class AB : A{public AB(){ = "黎锋果";base.Age = 24;}}下⾯的代码是类的实例访问类的成员:public class C{public void Init(){A a = new A();AB ab = new AB(); = "lifengguo"; //OK = "黎锋果"; //OKa.Age = 24; //Errorab.Age = 24; //Error}}。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
意想不到的结果,protected方法不是可以被继承类访问吗?
必须明确,类Test3确实是继承了类MyObject3(包括它的clone方法),所以在类Test3中可以调用自己的clone方法。但类MyObject3的protected方法对其不同包子类Test3来说,是不可见的。
这里再给出《java in a nutshell》中的一段话:
Test.java
classMyObject {}
publicclassTest {
publicstaticvoidmain(String[] args) {
MyObject obj =newMyObject();
obj.clone();// Compile error.
}
}
此时出现上文提到的错误:The method clone from the type Object is not visiuable.
再看示例2:
Test2.java
classMyObject2 {
protectedObject clone()throwsCloneNotSupportedException {
returnsuper.clone();
}
}
publicclassTest2 {
publicstaticvoidmain(String[] args)throwsCloneNotSupportedException {
MyObject3 obj =nele error.
Test3 tobj =newTest3();
tobj.clone();// Complie OK.
}
}
这里我用Test3类继承MyObject3,注意这两个类是不同包的,否则就是示例2的情形。在Test3类中调用Test3类的实例tobj的clone()方法,编译通过。而同样调用MyObject3类的实例obj的clone()方法,编译错误!
我们已经清楚Object.clone()是protected方法。这说明,该方法可以被同包(ng)下和它(ng.Object)的子类访问。这里是MyObject类(默认继承ng.Object)。
同样Test也是ng.Object的子类。但是,不能在一个子类中访问另一个子类的protected方法,尽管这两个子类继承自同一个父类。
MyObject2 obj =newMyObject2();
obj.clone();// Compile OK.
}
}
这里,我们在MyObject2类中覆盖(override)父类的clone()方法,在另一个类Test2中调用clone()方法,编译通过。
编译通过的原因显而易见,当你在MyObject2类中覆盖clone()方法时,MyObject2类和Test2类在同一个包下,所以此protected方法对Test2类可见。
package1
classMyObject3 {
protectedObject clone()throwsCloneNotSupportedException {
returnsuper.clone();
}
}
package2
publicclassTest3extendsMyObject3 {
publicstaticvoidmain(String args[]) {
protected access requires a little more elaboration. Suppose class A declares a protected field x and is extended by a class B, which is defined in a different package (this last point is important). Class B inherits the protected field x, and its code can access that field in the current instance of B or in any other instances of B that the code can refer to. This does not mean, however, that the code of class B can start reading the protected fields of arbitrary instances of A! If an object is an instance of A but is not an instance of B, its fields are obviously not inherited by B, and the code of class B cannot read them.
分析到这里,我们在回忆一下Java中的浅复制与深复制文中,章节2.2中的声明,②在派生类中覆盖基类的clone()方法,并声明为public。现在明白这句话的原因了吧(为了让其它类能调用这个类的clone()方法,重载之后要把clone()方法的属性设置为public)。
下面再来看示例3:
Test3.java
顺便说两句,国内的很多Java书籍在介绍访问权限时,一般都这样描述(形式各异,内容一致):
方法的访问控制:
public
protected
default
private
同类
T
T
T
T
同包
T
T
T
子类(不同包)
T
T
不同包中无继承关系的类
T
所以我想说的是,多读些英语原版书籍。
相关文档
最新文档