初始Java-＞Java修饰符

最新推荐文章于 2024-08-26 08:00:00 发布

我想用眼睛去听风景

最新推荐文章于 2024-08-26 08:00:00 发布

阅读量91

点赞数

分类专栏： java 笔记文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_53358173/article/details/120926589

版权

笔记同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

java

4 篇文章 0 订阅

订阅专栏

文章目录

- - Java修饰符

Java修饰符

1. 访问修饰符

default（默认，什么也不写）：在同一个包内可见，不使用任何修饰符，使用对象：类，接口，变量，方法
private（私有的）：在同一类内可见，使用对象：变量，方法。不能修饰类
public（公有的）：对所有类可见。使用对象：类，接口，变量，方法
protected（受保护的）：在同一包内的类和所有子类可见。使用对象：变量，方法。不能修饰类

1.1 私有访问修饰符private

私有访问修饰符是最严格的访问级别，所以被声明为private的方法，变量和构造方法只能被所属类访问，并且类和接口不能声明为private
声明为private的变量只能通过公共的getter方法被外部类访问，例如

public class Student {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return this.name;
    }

在上诉的例子中，Student类中的name变量为私有变量，其他类不能直接设置和得到该变量的值，只能通过两个public方法：set和get方法来设置或者获取name的值

1.2 公有访问修饰符public

public的类，变量，方法，构造方法和接口能够被其他任何类访问
如果几个相互访问的public类分布在不同的包中，则需要导入相应public所在的包。
java程序的main方法必须是public的，否则解释器无法运行该类

1.3 受保护的访问修饰符protected

子类与基类在同一包中：被声明为protected的变量，方法和构造器能被同一个包中的任何其他类访问
子类与基类不在同一包中：在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法
解释一下第二句什么叫从基类继承而来的protected方法，什么叫基类实例的protected方法

package pack1;

public class Father {
    protected void pri() {
        System.out.println("基类的protected方法");
    }
}

package pack2;

import pack1.Father;
public class Son extends Father {
    public static void main(String[] args) {
        Father f = new Father();
        f.pri(); //这里会报错，因为不能访问基类实例的protected方法
        
        Son sun = new Son();
        sum.pri(); //访问成功，可以访问从基类继承的protected方法
    }
}

1.3 访问控制和继承规则

父类中声明为public的方法在子类中也必须为public
父类中声明为protected的方法在子类中要么声明为protected，要么声明为public，不能声明为private。
父类中声明为private的方法不能被继承

2. 非访问修饰符

非访问修饰符有：

static：用来修饰类方法和类变量
final：用来修饰类，方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量
abstract：用来创建抽象类和抽象方法

2.1 static修饰符

静态变量：static关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝，局部变量不能声明为static变量
静态方法：static用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。

//静态变量的示例
public class Student {
	int id;
	String name;
	static String college = "TH";

	public Student(int id, String name) {
		this.id = id;
		this.name = name;
	}

	void display() {
		System.out.println("id：" + id + " name：" + name + " college：" + college);
	}

	public static void main(String[] args) {
		Student stu1 = new Student(1, "张三");
		Student stu2 = new Student(2, "李四");
		stu1.display();
		stu2.display();

	}

}

//代码执行结果：
//id：1 name：张三 college：TH
//id：2 name：李四 college：TH

public class Student2 {
	int id;
	String name;
	static String college = "TH";

	public static void change() {
		college = "HUA";
	}

	public Student2(int id, String name) {
		this.id = id;
		this.name = name;
	}

	void display() {
		System.out.println("id：" + id + " name：" + name + " college：" + college);
	}

	public static void main(String[] args) {
		Student2 stu1 = new Student2(1, "张三");
		Student2 stu2 = new Student2(2, "李四");
		Student2.change(); //可以直接调用静态方法，不用创建对象
		stu1.display();
		stu2.display();

	}

}

//代码执行结果
//id：1 name：张三 college：HUA
//id：2 name：李四 college：HUA