对java中的访问限定符的理解1

最新推荐文章于 2024-05-01 19:17:00 发布
最新推荐文章于 2024-05-01 19:17:00 发布
阅读量54 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/pengdonglin137/archive/2013/03/22/2976257.html
版权

image

 

可以这样理解：

“同一类中可见”------“相对于父类，在父类的{}作用域内，父类的对象可以访问全部的成员”；

“同一包中对子类可见”------“相对于父类，与父类在同一包A中，在包A里面的子类的{}作用域内，父类或者子类的对象访问父类成员的情况”；

“同一包中对非子类可见”------“相对于父类，与父类在同一包A中，在包A里面的非子类的{}作用域内，父类或者子类的对象访问父类的成员的情况”；

“不同包中对子类可见”-------“相对于父类(在包A中)，与父类不在同一包(比如包B)中，在包B里面的子类的{}作用域内，子类的对象，访问父类的成员的情况”；

“不再同一包中对非子类可见”------“相对于父类(在包A中)，与父类不在同一包(比如包B)中，在包B里面的非子类的{}作用域内，父类或者子类的对象，访问父类的成员的情况”；

 

下面一行一行的解释：

一、

image

理解：

“同一类中可见”------“相对于父类，在父类的{}作用域内，父类的对象可以访问全部的成员”；

 

 

示例：

image

 

ClassA.java

 

   1:  package com.test.pkg1;
   2:   
   3:   
   4:   
   5:  public class ClassA {
   6:   
   7:      public int a;
   8:      protected int b;
   9:      int c;
  10:      private int d;
  11:      
  12:      public void fun1(){}
  13:      protected void fun2(){}
  14:      void fun3(){}
  15:      private void fun4(){}
  16:      
  17:      
  18:      public static void main(String[] args) {
  19:          
  20:          ClassA classA = new ClassA();
  21:          
  22:          classA.a = 0;
  23:          classA.b = 0;
  24:          classA.c = 0;
  25:          classA.d = 0;
  26:          
  27:          classA.fun1();
  28:          classA.fun2();
  29:          classA.fun3();
  30:          classA.fun4();
  31:          
  32:      }
  33:      
  34:      
  35:  }
  36:   

 

编译无误！

 

二、image

 

 

理解：

“同一包中对子类可见”------“相对于父类，与父类在同一包A中，在包A里面的子类的{}作用域内，父类或者子类的对象访问父类成员的情况”；

 

image

 

ClassA.java

 

   1:  package com.test.pkg1;
   2:   
   3:   
   4:   
   5:  public class ClassA {
   6:   
   7:      public int a;
   8:      protected int b;
   9:      int c;
  10:      private int d;
  11:      
  12:      public void fun1(){}
  13:      protected void fun2(){}
  14:      void fun3(){}
  15:      private void fun4(){}
  16:      
  17:      
  18:      public static void main(String[] args) {
  19:          
  20:          ClassA classA = new ClassA();
  21:          
  22:          classA.a = 0;
  23:          classA.b = 0;
  24:          classA.c = 0;
  25:          classA.d = 0;
  26:          
  27:          classA.fun1();
  28:          classA.fun2();
  29:          classA.fun3();
  30:          classA.fun4();
  31:          
  32:      }
  33:      
  34:      
  35:  }
  36:   
  37:  class ClassB extends ClassA{
  38:      
  39:      public void fun5()
  40:      {
  41:          ClassA classA = new ClassA();
  42:          ClassB classB = new ClassB();
  43:          
  44:          classA.a = 0;
  45:          classA.b = 0;
  46:          classA.c = 0;
  47:          classA.d = 0;
  48:          
  49:          classA.fun1();
  50:          classA.fun2();
  51:          classA.fun3();
  52:          classA.fun4();
  53:          
  54:          classB.a = 0;
  55:          classB.b = 0;
  56:          classB.c = 0;
  57:          classB.d = 0;
  58:          
  59:          classB.fun1();
  60:          classB.fun2();
  61:          classB.fun3();
  62:          classB.fun4();
  63:      }
  64:  }

下面是系统提示：

image

 

三、

image

 

 

 

理解：

“同一包中对非子类可见”------“相对于父类，与父类在同一包A中，在包A里面的非子类的{}作用域内，父类或者子类的对象访问父类的成员的情况”；

 

image

 

ClassA.java

   1:  package com.test.pkg1;
   2:   
   3:   
   4:   
   5:  public class ClassA {
   6:   
   7:      public int a;
   8:      protected int b;
   9:      int c;
  10:      private int d;
  11:      
  12:      public void fun1(){}
  13:      protected void fun2(){}
  14:      void fun3(){}
  15:      private void fun4(){}
  16:      
  17:      
  18:      public static void main(String[] args) {
  19:          
  20:          ClassA classA = new ClassA();
  21:          
  22:          classA.a = 0;
  23:          classA.b = 0;
  24:          classA.c = 0;
  25:          classA.d = 0;
  26:          
  27:          classA.fun1();
  28:          classA.fun2();
  29:          classA.fun3();
  30:          classA.fun4();
  31:          
  32:      }
  33:      
  34:      
  35:  }
  36:   
  37:  class ClassB extends ClassA{}
  38:   
  39:  class ClassC{
  40:      
  41:      public void fun5()
  42:      {
  43:          ClassA classA = new ClassA();
  44:          ClassB classB = new ClassB();
  45:          
  46:          classA.a = 0;
  47:          classA.b = 0;
  48:          classA.c = 0;
  49:          classA.d = 0;
  50:          
  51:          classA.fun1();
  52:          classA.fun2();
  53:          classA.fun3();
  54:          classA.fun4();
  55:          
  56:          classB.a = 0;
  57:          classB.b = 0;
  58:          classB.c = 0;
  59:          classB.d = 0;
  60:          
  61:          classB.fun1();
  62:          classB.fun2();
  63:          classB.fun3();
  64:          classB.fun4();
  65:      }
  66:  }

下面是系统提示：

image

 

四、image

 

 

理解：

“不同包中对子类可见”-------“相对于父类(在包A中)，与父类不在同一包(比如包B)中，在包B里面的子类的{}作用域内，子类的对象，访问父类的成员的情况”；

 

image

 

ClassA.java

   1:  package com.test.pkg1;
   2:   
   3:   
   4:   
   5:  public class ClassA {
   6:   
   7:      public int a;
   8:      protected int b;
   9:      int c;
  10:      private int d;
  11:      
  12:      public void fun1(){}
  13:      protected void fun2(){}
  14:      void fun3(){}
  15:      private void fun4(){}
  16:      
  17:      
  18:      public static void main(String[] args) {
  19:          
  20:          ClassA classA = new ClassA();
  21:          
  22:          classA.a = 0;
  23:          classA.b = 0;
  24:          classA.c = 0;
  25:          classA.d = 0;
  26:          
  27:          classA.fun1();
  28:          classA.fun2();
  29:          classA.fun3();
  30:          classA.fun4();
  31:          
  32:      }
  33:      
  34:      
  35:  }
  36:   

ClassB.java

   1:  package com.test.pkg2;
   2:   
   3:  import com.test.pkg1.ClassA;
   4:   
   5:   
   6:  class ClassB extends ClassA{
   7:      
   8:      public void fun5()
   9:      {
  10:          ClassA classA = new ClassA();
  11:          ClassB classB = new ClassB();
  12:          
  13:          classA.a = 0;
  14:          classA.b = 0;
  15:          classA.c = 0;
  16:          classA.d = 0;
  17:          
  18:          classA.fun1();
  19:          classA.fun2();
  20:          classA.fun3();
  21:          classA.fun4();
  22:          
  23:          classB.a = 0;
  24:          classB.b = 0;
  25:          classB.c = 0;
  26:          classB.d = 0;
  27:          
  28:          classB.fun1();
  29:          classB.fun2();
  30:          classB.fun3();
  31:          classB.fun4();
  32:      }
  33:  }

下面是系统提示：

image

只需看关于ClassB的对象的提示。

 

五、image

 

 

理解：

“不再同一包中对非子类可见”------“相对于父类(在包A中)，与父类不在同一包(比如包B)中，在包B里面的非子类的{}作用域内，父类或者子类的对象，访问父类的成员的情况”；

 

image

 

ClassA.java

   1:  package com.test.pkg1;
   2:   
   3:   
   4:   
   5:  public class ClassA {
   6:   
   7:      public int a;
   8:      protected int b;
   9:      int c;
  10:      private int d;
  11:      
  12:      public void fun1(){}
  13:      protected void fun2(){}
  14:      void fun3(){}
  15:      private void fun4(){}
  16:      
  17:      
  18:      public static void main(String[] args) {
  19:          
  20:          ClassA classA = new ClassA();
  21:          
  22:          classA.a = 0;
  23:          classA.b = 0;
  24:          classA.c = 0;
  25:          classA.d = 0;
  26:          
  27:          classA.fun1();
  28:          classA.fun2();
  29:          classA.fun3();
  30:          classA.fun4();
  31:          
  32:      }
  33:      
  34:      
  35:  }
  36:   

ClassB.java

   1:  package com.test.pkg2;
   2:   
   3:  import com.test.pkg1.ClassA;
   4:   
   5:   
   6:  class ClassB extends ClassA{
   7:      
   8:      
   9:  }
  10:   
  11:   
  12:  class ClassC{
  13:   
  14:      public void fun5()
  15:      {
  16:          ClassA classA = new ClassA();
  17:          ClassB classB = new ClassB();
  18:          
  19:          classA.a = 0;
  20:          classA.b = 0;
  21:          classA.c = 0;
  22:          classA.d = 0;
  23:          
  24:          classA.fun1();
  25:          classA.fun2();
  26:          classA.fun3();
  27:          classA.fun4();
  28:          
  29:          classB.a = 0;
  30:          classB.b = 0;
  31:          classB.c = 0;
  32:          classB.d = 0;
  33:          
  34:          classB.fun1();
  35:          classB.fun2();
  36:          classB.fun3();
  37:          classB.fun4();
  38:      }
  39:  }

系统提示：

image

转载于:https://www.cnblogs.com/pengdonglin137/archive/2013/03/22/2976257.html

weixin_30455661
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java2核心技术.part1
12-31
第1章Java程序设计概述 1．1 Java程序设计平台 1．2 Java“白皮书”的关键术语 1．2．1简单性 1．2．2面向对象 1．2. 3分布式 1. 2．4健壮性 1. 2．5安仝性 1. 2．6体系结构中立 1．2．7可移植性 1．2．8解释型 ...
Java中的访问限定符
spade_Kwo的博客
07-20 2869
目录复制 访问限定符1.public（公有）2.protected（受保护）3.default（缺省）4.private（私有）5.注意 Java中四种访问限定符具体如下： 访问级别 访问控制修饰符 同一个类 同一个包 子类 不同的包 公开 public 是 是 是 是 受保护 protected 是 是 是 – 缺省 default 是 是 – – 私有 private 是 – – – 上图具体解释如下： 1.public（公有） public为公开的，被public所修饰
Java初级笔记-第五章
aidrv.com
04-05 424
第五章 面向对象的特点 5.1 继承 面向对象的重要特点之一就是继承。类的继承使得能够在已有的类的基础上构造新的类，新类除了具有被继承类的属性和方法外，还可以根据需要添加新的属性和方法。继承有利于代码的复用，通过继承可以更有效地组织程序结构，并充分利用已有的类来完成复杂的任务，减少了代码冗余和出错的几率。   继承通过extends 来表示。 class A extends B 表示类A
java中的四种访问限定修饰符
希望大家一起快乐的学java
07-31 3575
Java的四种权限: public :公共权限 private,:私有权限 protected:受保护权限 default:默认权限 由上图可知: java的四种访问限定修饰符中 public：可以修饰类，构造方法，数据成员，方法成员 可以被同一个类里面的其他类访问； 可以被同一个包下的类访问； 可以被不同包下的类访问； 不管是同一包还是不同包下的子类也可以访问 private：可以修饰构造方法...
Java 访问限定符的含义
wenwenliuyunabcd的博客
01-22 2197
修饰类（类、接口）：public、private、无（default） public：公共的。在任何位置都能访问到这个类。 private：私有类，可作为内部类被所属的类访问，其他类无法访问。 default：只能被同一包下的类访问。 修饰属性和方法：public、protected、无（default）、private public：任何位置都能访问，类或者该类的对象之间访问 prot...
Java中四个访问修饰限定符的用法
weixin_53851750的博客
10-10 676
Java中一共有四个访问修饰限定符，用于修饰方法或者属性，它们分别是public、protected、default、private public public修饰符的访问级别最高，换句话说也就是最不严格，不管在哪个地方都能访问。 protected protected修饰符主要用于互为继承关系的类中，当父类中的属性或者方法用protected修饰符修饰的时候，就只会允许它的子类进行访问。 default default关键字也叫作包访问修饰符，作用就是主要在同一个包底下的类，互相之间就可以进行
疯狂JAVA讲义
10-17
第1章 Java概述 1 1.1 Java语言的发展简史 2 1.2 Java的竞争对手及各自优势 4 1.2.1 C#简介和优势 4 1.2.2 Ruby简介和优势 4 1.2.3 Python的简介和优势 5 1.3 Java程序运行机制 5 1.3.1 高级语言的运行机制 6...
Java2核心技术.part5
01-06
第1章Java程序设计概述 1．1 Java程序设计平台 1．2 Java“白皮书”的关键术语 1．2．1简单性 1．2．2面向对象 1．2. 3分布式 1. 2．4健壮性 1. 2．5安仝性 1. 2．6体系结构中立 1．2．7可移植性 1．2．8...
Java 语言基础 —— 非常符合中国人习惯的Java基础教程手册
04-28
对类的成员可以设定访问权限 ，来限定 其它对象对它的访问，访问权限所以有以下几种:private, protected, public, friendly。 1.8.2 对象 把类实例化,我们可以生成多个对象,这些对象通过消息传递来进行交互(消息 ...
Java访问权限 表格
i929479824的博客
06-11 651
Java接口中方法和域的访问限定
wuqingdeqing的博客
02-11 2733
在做项目的过程中，突然有一个疑问，就是很多时候接口中的方法并没有任何访问限制。若依过往经验推断，说明此方法与类的默认访问属性相同，即包访问可见。但心里总觉得此种解释不甚合理，经过查阅资料明白，在接口声明中，所有方法自动都是public。并且，在实现接口的方法时，必须把方法声明为public，否则编译器会将此方法认为是包访问可见，就会给出试图提供更弱的访问权限的警告。有些程序员出于习惯或提高清晰度的...
Java类的访问限定关键字
lanluyug的博客
09-18 231
public 公开访问 private 类访问 protected 继承类可以访问 default（或者没有关键字） 包可以访问
java的访问限定符
weixin_33724046的博客
12-04 819
2019独角兽企业重金招聘Python工程师标准>>> ...
java中访问限定符_对java中的访问限定符的理解1
weixin_28958485的博客
02-12 188
可以这样理解：“同一类中可见”------“相对于父类，在父类的{}作用域内，父类的对象可以访问全部的成员”；“同一包中对子类可见”------“相对于父类，与父类在同一包A中，在包A里面的子类的{}作用域内，父类或者子类的对象访问父类成员的情况”；“同一包中对非子类可见”------“相对于父类，与父类在同一包A中，在包A里面的非子类的{}作用域内，父类或者子类的对象访问父类的成员的情况”；“...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 1251
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1099
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
yajunjiao的专栏
04-30 471
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Spring Cloud——LoadBalancer
最新发布
????
05-01 1164
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
java中访问限定符_Java 中访问限定符有 , public,private 和 default 等_学小易找答案...
05-19
Java 中的访问限定符指的是控制类、接口、变量、方法等成员的访问权限。Java 中有以下几种访问限定符： 1. public：公共的，任何类都可以访问。 2. private：私有的，只有在当前类中才能访问。 3. protected：受...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值