Java权限修饰符

最新推荐文章于 2023-09-20 17:17:58 发布
最新推荐文章于 2023-09-20 17:17:58 发布
阅读量120 收藏
点赞数 1
文章标签： java 面向对象编程 类 抽象类 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45152548/article/details/110311231
版权

目录

修饰符

四种权限修饰符

修饰符当前类同一包内（子类和无关类）不同包（子类）不同包（无关类）
publicYYYY
protectedYYYN
default（默认）YYNN
privateYNNN

public（公共权限）

	可以修饰类,成员变量,成员方法,构造方法
	被public修饰的成员,可以在任何一个类中被调用,不管同包或不同包,是权限最大的一个修饰符
可以修饰的成员：

1、public修饰类：

//public 修饰类
public class Test {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

2、public修饰成员变量：

public class Test {
    //public 修饰变量
    public String str = "hello world";

    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

3、public修饰方法：

public class Test {
    //public 修饰方法
    public void test(){
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        Test t = new Test();
        t.test();
    }
}

4、public修饰构造方法：

public class Test {
    //public 修饰构造方法
    public Test(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        PublicTest t = new Test();
    }
}
访问范围：

public修饰的成员在任意位置都可以访问
1、本类中访问：

/**public 修饰的成员在本类中可以正常访问*/
public class Test {
    //public 修饰变量
    public String str = "public 修饰的变量";

    //public 修饰方法
    public void test(){
        System.out.println("public 修饰的方法");
    }
    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.str);
        t.test();
    }
}

2、同包中的类访问：

package demo;

public class Test {
    //public 修饰变量
    public String str = "public 修饰的变量";

    //public 修饰方法
    public void test(){
        System.out.println("public 修饰的方法");
    }
}

package demo;

/**public 修饰的成员在同包的类中可以正常访问*/
public class TestMain {
    public static void main(String[] args) {
        Test pt = new Test();
        System.out.println(t.str);
        t.test();
    }
}

3、子类中访问：

package demo;

public class Test {
    //public 修饰变量
    public String str = "public 修饰的变量";

    //public 修饰方法
    public void test(){
        System.out.println("public 修饰的方法");
    }
}

package demo.demo01;

import demo.Test;

/**public 修饰的成员在子类中可以正常访问*/
public class TestSub extends Test {
    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.str);
        t.test();
    }
}

4、其它类访问：

package demo;

public class Test {
    //public 修饰变量
    public String str = "public 修饰的变量";

    //public 修饰方法
    public void test(){
        System.out.println("public 修饰的方法");
    }
}

package demo.demo01;

import demo.Test;

/**public 修饰的成员在其它类中可以正常访问*/
public class TestOther {
    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.str);
        t.test();
    }
}

protected（受保护权限）

	可以修饰成员变量,成员方法,构造方法,不能修饰类(外部类,内部类不考虑)
	被private修饰的成员,只能在定义它们的类中使用,在其他类中不能调用。
	如果有不同包的类想调用它们,那么这个类必须是定义它们的类的子类。
可以修饰的成员：

protected 不能修饰类、代码块，可以修饰变量、方法、构造方法

1、protected 可以修饰变量：

public class Test {
    //protected 修饰的变量
    protected String str = "hello world";

    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

2、protected可以修饰方法：

public class Test {
    //protected 修饰的方法
    protected void test(){
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        Test pt = new Test();
        t.test();
    }
}

3、protected可以修饰构造方法：

public class Test {
    //protected 修饰的构造方法
    protected Test(){
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        Test t = new Test();
    }
}
访问范围：

1、被protected修饰的成员，在本类中是可以正常访问的。
2、被protected修饰的成员，在同包的类中是可以正常访问的。
3、被protected修饰的成员，在子类中如果子类与父类同包，则子类对象和父类对象都可以正常访问，如果子类与父类不同包，则子类对象可以正常访问，父类对象不可以访问。
4、被protected修饰的成员，在其他类中是不可以访问的。

1、本类中访问：

public class Test {
    //protected 修饰的变量
    protected String str = "hello world";

    //protected 修饰的方法
    protected void test(){
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.str);
        t.test();
    }
}

2、同包中的类访问：

package demo;

public class Test{
    //protected 修饰的变量
    protected String str = "hello world";

    //protected 修饰的方法
    protected void test(){
        System.out.println("hello world");
    }
}


package demo;

/**protected 修饰的成员在同包的类中可以正常访问*/
public class TestMain {
    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.str);
        t.test();
    }
}

3、子类中访问：

package demo;

public class Test{
    //protected 修饰的变量
    protected String str = "hello world";

    //protected 修饰的方法
    protected void test(){
        System.out.println("hello world");
    }
}


package demo.demo01;

import demo.Test;

public class TestSub extends Test {
    public static void main(String[] args) {
        Test t = new Test();
        //System.out.println(t.str);//访问不到
        //t.test();//访问不到
        
        TestSub tb = new TestSub();
        System.out.println(tb.str);//可以访问
        tb.test();//可以访问
    }
}

4、其他类中访问：

package demo;

public class Test{
    //protected 修饰的变量
    protected String str = "hello world";

    //protected 修饰的方法
    protected void test(){
        System.out.println("hello world");
    }
}


package demo.demo01;

import demo.Test;

public class TestSub extends Test {

}


package demo.demo01;

import demo.Test;

public class TestOther {
    public static void main(String[] args) {
        Test t = new Test();
        //System.out.println(t.str);//访问不到
        //t.test();//访问不到

        TestSub ts = new TestSub();
        //System.out.println(ts.str);//访问不到
        //ts.test();//访问不到
    }
}

default（默认权限，即，不写）

	类,成员变量,成员方法,构造方法都能使用默认权限,即不写任何关键字
	默认权限即同包权限,同包权限的元素只能在定义它们的类中使用,以及同包的类中被调用
可以修饰的成员：

可以修饰任何成员

1、可以修饰类：

//default修饰的类
class DefaultTest {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

2、可以修饰变量：

package mjl2020051802;

class DefaultTest {
    //default修饰的变量
    String str = "hello world";

    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

3、可以修饰方法：

class DefaultTest {
    //default修饰的方法
    void test(){
        System.out.println("hello world");
    }
    public static void main(String[] args) {
        DefaultTest dt = new DefaultTest();
        dt.test();
    }
}

4、可以修饰构造方法：

class DefaultTest {
    //default修饰的构造方法
    DefaultTest(){
        System.out.println("hello world");
    }
    public static void main(String[] args) {
        DefaultTest dt = new DefaultTest();
    }
}
访问范围：

1、被default修饰的成员，在本类中是可以正常访问的
2、被default修饰的成员，在同包的类中是可以正常访问的
3、被default修饰的成员，在子类中如果子类与父类同包，则子类对象和父类对象都可以访问，如果子类与父类不同包，则子类对象和父类对象都不可以访问
4、被default修饰的成员，在其它类中不可以被访问
注：被default修饰的类，在同包中可以引入，在非同包中不可以引入

1、本类中访问：

class DefaultTest {
    //default修饰的变量
    String str = "hello world";
    //default修饰的方法
    void test(){
        System.out.println("hello world");
    }
    public static void main(String[] args) {
        DefaultTest dt = new DefaultTest();
        System.out.println(dt.str);
        dt.test();
    }
}

2、同包的类中访问：

package demo;

class DefaultTest {
    //default修饰的变量
    String str = "hello world";
    //default修饰的方法
    void test(){
        System.out.println("hello world");
    }
}


package demo;

public class TestMain {
    public static void main(String[] args) {
        DefaultTest dt = new DefaultTest();
        System.out.println(dt.str);
        dt.test();
    }
}

3、子类中访问：

package demo;

class DefaultTest {
    //default修饰的变量
    String str = "hello world";
    //default修饰的方法
    void test(){
        System.out.println("hello world");
    }
}


package demo;

public class DefaultTestSub extends DefaultTest {
    public static void main(String[] args) {
        DefaultTest dt = new DefaultTest();
        System.out.println(dt.str);
        dt.test();

        DefaultTestSub dts = new DefaultTestSub();
        System.out.println(dts.str);
        dts.test();
    }
}

4、其它类中访问：

package demo;

public class DefaultTest {
    //default修饰的变量
    String str = "hello world";
    //default修饰的方法
    void test(){
        System.out.println("hello world");
    }
}


package demo.demo01;

import demo.DefaultTest;

public class DefaultTestOther {
    public static void main(String[] args) {
        DefaultTest dt = new DefaultTest();
        //System.out.println(dt.str); //不可以访问
        //dt.test();//不可以访问
    }
}

private（私有权限）

	可以修饰成员变量,构造方法,成员方法,不能修饰类(外部类,内部类不考虑)
	被private修饰的成员,只能在定义它们的类中使用,在其他类中不能调用。
可以修饰的成员：

private不可以修饰类和代码块，可以修饰变量，方法和构造方法（与protected一致）

1、可以修饰变量：

public class PrivateTest {
    //private 修饰的变量
    private String str = "hello world";

    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

2、可以修饰方法：

public class PrivateTest {
    //private 修饰的方法
    private void test(){
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        PrivateTest pt = new PrivateTest();
        pt.test();
    }
}

3、可以修饰构造方法：

public class PrivateTest {
    //private 修饰的构造方法
    private  PrivateTest(){
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        PrivateTest pt = new PrivateTest();
    }
}
访问范围：

1、被private修饰的成员，在本类中可以正常访问
2、被private修饰的成员，在同包的类中是不可以访问的
3、被private修饰的成员，在子类中是不可以访问的
4、被private修饰的成员，在其他类中是不可以访问的

1、本类中访问

public class PrivateTest {
    //private 修饰的变量
    private String str = "hello world";

    //private 修饰的方法
    private  void test(){
        System.out.println("hello world");
    }

    public static void main(String[] args) {
        PrivateTest pt = new PrivateTest();
        System.out.println(pt.str);
        pt.test();
    }
}

2、同包的类访问：

package demo;

public class PrivateTest {
    //private 修饰的变量
    private String str = "hello world";

    //private 修饰的方法
    private  void test(){
        System.out.println("hello world");
    }
}


package demo;

public class TestMain {
    public static void main(String[] args) {
        PrivateTest pt = new PrivateTest();
        //System.out.println(pt.str);//不可以访问
        //pt.test();//不可以访问
    }
}

3、子类中访问：

package demo;

public class PrivateTest {
    //private 修饰的变量
    private String str = "hello world";

    //private 修饰的方法
    private  void test(){
        System.out.println("hello world");
    }
}


package demo.demo01;

import demo.PrivateTest;

public class PrivateTestSub extends PrivateTest {
    public static void main(String[] args) {
        PrivateTest pt = new PrivateTest();
        //System.out.println(pt.str);//不可以访问
        //pt.test();//不可以访问
    }
}

4、其它类访问：

package demo;

public class PrivateTest {
    //private 修饰的变量
    private String str = "hello world";

    //private 修饰的方法
    private  void test(){
        System.out.println("hello world");
    }
}


package demo.demo01;

import demo.PrivateTest;

public class PrivateTestOther {
    public static void main(String[] args) {
        PrivateTest pt = new PrivateTest();
//        System.out.println(pt.str);//不可以访问
//        pt.test();//不可以访问
    }
}

状态修饰符

static修饰符：

	静态变量：
	static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
	静态方法：
	static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

1、static关键字可以修饰类（static不能修饰普通类，只能修饰内部类）：

public class StaticTest {
    public static class InnerClass{
        InnerClass(){
            System.out.println("=====我是静态内部类======");
        }
    }
    public static void main(String[] args) {
        InnerClass ic = new StaticTest.InnerClass();
    }
}

2、static关键字可以修饰方法（static关键字修饰的方法可以通过类名直接调用）：

public class StaticTest {
    public static void test(){
        System.out.println("=====我是静态方法=====");
    }
    public static void main(String[] args) {
        StaticTest.test();
    }
}

3、static关键字可以修饰变量（static关键字修饰的变量可以通过类名直接调用）：

public class StaticTest {
    public static String name = "mjl";
    public static void main(String[] args) {
        System.out.println("=====我是静态变量 "+StaticTest.name+" ======");
    }
}

4、static关键字可以修饰代码块：

public class StaticTest {
    static {
        System.out.println("=====我是静态代码块======");
    }

    public static void main(String[] args) {
        StaticTest st = new StaticTest();
    }
}

final修饰符：

	final 变量：
	final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
	final 修饰符通常和 static 修饰符一起使用来创建类常量。

1、final关键字可以修饰变量（被final修饰的变量的值不可以更改）：

public class FinalTest {

    final double PI = 3.1415926;

    public static void main(String[] args) {
        FinalTest ft = new FinalTest();
        System.out.println(ft.PI);
    }
}


final 方法
父类中的 final 方法可以被子类继承，但是不能被子类重写。
声明 final 方法的主要目的是防止该方法的内容被修改。
如下所示，使用 final 修饰符声明方法。

2、final关键字可以修饰方法（被final修饰的方法不可以被重写）：

public class FinalTest {

    public final void test(){
        System.out.println("====我是一个final修饰的方法=====");
    }
    public static void main(String[] args) {
        FinalTest ft = new FinalTest();
        ft.test();
    }
}


final 类
final 类不能被继承，没有类能够继承 final 类的任何特性。

3、final关键可以修饰类（被final修饰的类不可以被继承）：

public final class FinalTest {
    public static void main(String[] args) {
        System.out.println("====我是一个final修饰的类=====");
    }
}

抽象修饰符

abstract修饰符：

	抽象类：
	不能修饰构造方法,不能修饰成员变量,可以修饰类,成员方法
	被修饰的类不能被实例化，只能被继承，被修饰的成员方法在子类中必须被重写
	抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
	一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
	抽象类可以包含抽象方法和非抽象方法。

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法	
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();。

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}
奇怪i
关注
JAVA学习第五天-继承导包权限修饰符
30+开始学JAVA
11-23 133
继承 继承中，变量的访问会以与运行位置最接近的定义值为准。 super可以直接访问父类的成员变量，this可以访问本类中的成员变量; 子类构造方法被调用的时候，父类会默认初始化，其中的无餐构造方法会默认被调用；如果父类中没有无参构造方法，可以用super(带参）来访问带参构造方法，或给出一个无参构造方法。 父类中private的方法子类中是无法继承的； 类只支持单继承，可以多层继承； 导包 import+包名+class名，就可以了 权限 包内的类间除了private其他类型的方法都可以相互访问； 不同包
Java 权限修饰符
明月映雪的博客
03-27 101
权限修饰符： 权限修饰符就是控制被修饰的成员的范围可见性。 public(公共) protected(受保护) default(缺省) private (大到小) 同一个类 true true true true 同一个包 true ...
Java语言的访问权限修饰符 private default protected public
03-15 698
Java语言的访问权限修饰符 private default protected public2010-01-13 13:55Java语言的访问权限修饰符 private default protected publicJava类需要打包，打包后可以进行访问权限控制。本文中，将对Java语言中的访问权限修饰符，进行简单介绍。一个Java应用有很多类，
权限修饰符
weixin_45116982的博客
06-03 161
权限修饰符 private 本类 default(默认) 本类 同包类 protected 本类 同包类 不同包子类 protected的访问权限 同包下的类 不同包的子类,并且只能通过子父类关系访问,只有子类中才可以使用 public 本类 同包类 不同包子类 不同包下的其他类 以上权限修饰符只能修饰成员(static),成员修饰...
理解java中的类的各种权限修饰符
02-28
### 理解Java中的类的各种权限修饰符 在Java编程语言中，权限修饰符用于控制类、方法、变量等成员的访问级别。这有助于提高代码的安全性和封装性。本文将详细探讨Java中的五种权限修饰符：`public`、`protected`、`...
JAVA访问权限修饰符详解
weixin_43870755的博客
09-20 417
private：只对本类开放，其他类不能继承也不能访问public：对所有类公开，其他类既能继承也能直接访问protected：对本包下开放，其他包不开放，但能通过其他包下子类继承得到default： 对本包下开放，其他包不开放，不能通过其他包下子类继承得到，但能通过本包下的子类继承得到一句话概括,protected和default都对本包开放，对其他包不开放，就是不可见，在其他包下只有protected通过继承能传递到其他类中。
java 权限修饰符
最新发布
09-22
Java中常见的权限修饰符有public、protected、default和private。其中，public修饰符表示该成员可以在任何地方被访问，protected修饰符表示该成员可以被当前类、同一包中的其他类以及不同包中的子类访问，default...
【Java学习记录】权限修饰符
kxcz11728455的博客
08-01 122
java入门权限修饰符
泛型的方法
qq_50873246的博客
08-03 254
泛型的方法
权限访问修饰符
孤獨的鬥士的博客
02-03 446
访问权限控制： private： 表示私有的，表示类访问权限，只能在本类中访问，离开本类之后，就不能直接访问 default： 表示包私有，表示包访问权限，访问者的包必须和当前定义的类的包相同才能访问 protected：   表示子类访问权限，同包中的可以访问，即使不同包，但是有继承关系，也可以访问 public： 表示全局的，表示公共访问权限，若某字段/方法，使用了public修饰，则
Java的权限修饰符
好好学习 天天向上
12-17 170
一.类的权限修饰符 当类申明为public时，它对任何地方的类都是可见的 一个类没有申明权限时，即默认设为package-private，它只对在自己的包内的所有类可见 二.类中成员的权限修饰符 当成员声明为public时，它对任何地方的类都是可见的 当成员没有显式声明权限时，即默认设为package-private，它只对在自己的包内的所有类可见 当成员声明为private时，它只对本类是可见的 当成员申明为protected时，除了对自己所在的包内所有类是可见的，还对其他包内的本类的子类是可见的
访问修饰符权限
a_saltedfish_dream的博客
10-15 420
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值