Java中的修饰符
一、包
1、包的概述和使用：
包其实就是文件夹，包的作用就是对类进行分类管理
2、包的定义格式：
格式：package 包名：（多级包（即包下有包）用.分开）
范例：package com.itheima;
3、手动创建：
在盘符合适位置创建一个新的文件夹命名为com -> 在这个文件夹中在创建一个文件夹itheima -> 最后再将txt文件写在itheima里面并写好内容更改后缀为.java
这是在.java文件中建立的包，注意.java文件的目录，一般开始生成的class文件在同级目录下要移到二级包里面
此时在命令行提示符中进行运行：
javac 类名.java 表示编译
java 一级包名.二级包名.类名 表示运行（注意class文件要在这个路径中）
4、自动建包：
javac -d . 类名.java 表示自动在当前目录下创建一个包
java 一级包名.二级包名.类名 表示运行（注意class文件要在这个路径中）
二、导包
1、导包的意图：
使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了
为了简化带包操作，Java就提供了导包的功能
2、导包的格式：
格式：import 类路径;
示例：import java.util.Scanner;
3、参考代码：
package cn.itcast;
/*
老师类
*/
public class Teacher {
public void teach(){
System.out.println("用爱成就每一位学员");
}
}
package com.itheima;
/*
测试类
*/
//导包 简化书写
//import java.util.Scanner;
import cn.itcast.Teacher;
public class Demo {
public static void main(String[] args){
//1、导包前
// Teacher t = new Teacher(); //以前是因为都是在一个包下的类 可以直接写
/* //需要带上包名
cn.itcast.Teacher t1 = new cn.itcast.Teacher();
t1.teach();
cn.itcast.Teacher t2 = new cn.itcast.Teacher();
t2.teach();*/
// java.util.Scanner sc = new java.util.Scanner(System.in);
//2、导包后
Teacher t1 = new Teacher();
t1.teach();
}
}
三、修饰符
1、修饰符的分类：
权限修饰符
状态修饰符
2、权限修饰符：
| 修饰符 | 同一个类中 | 同一个包中的子类和无关类 | 不同包中的子类 | 不同包中的无关类 |
|---|---|---|---|---|
| private | 可以 | |||
| 默认 | 可以 | 可以 | ||
| protected | 可以 | 可以 | 可以 | |
| public | 可以 | 可以 | 可以 | 可以 |
参考代码：
package cn.itcast;
/*
父类
*/
public class Base {
private void show1(){
System.out.println("private");
}
void show2(){
System.out.println("默认");
}
protected void show3(){
System.out.println("protected");
}
public void show4(){
System.out.println("public");
}
public static void main(String[] args){
//！！！注意：现在所在的作用域是在当前类中
//创建父类对象，测试看有哪些方法可以使用
Base b = new Base();
b.show1();
b.show2();
b.show3();
b.show4();
//结论在本类中 四种权限都可以访问
}
}
package cn.itcast;
/*
子类 同一个包下
*/
public class Son extends Base{
public static void main(String[] args){
//创建子类对象，测试看有哪些方法可以使用
Son s = new Son();
s.show2();
s.show3();
s.show4();
//可以看到private 访问权限不可以被访问
//private 修饰符只能在本类中访问 并且无法通过继承获取
}
}
package cn.itcast;
/*
测试类 (同一个包下)
*/
public class Demo {
public static void main(String[] args) {
//创建父类对象，测试看有那些方法可以使用
Base b = new Base();
b.show2();
b.show3();
b.show4();
}
}
package com.itheima;
/*
子类 不在同一个包下
*/
//导包
import cn.itcast.Base;
public class Son extends Base {
public static void main(String[] args) {
Son s = new Son();
s.show3();
s.show4();
//protected 与 publi
}
}
package com.itheima;
/*
测试类二：不在同一个包下
*/
//导包
import cn.itcast.Base;
public class Demo {
public static void main(String[] args) {
//创建父类对象，测试看有哪些方法可以使用
Base b = new Base();
b.show4();
//只能访问 public
}
}
3、状态修饰符：
1、final（最终态）
1、final关键词是最终的意思，可以修饰成员方法，成员变量，类
修饰方法：表明该方法是最终方法，不能被重写
修饰变量：表明该变量是常量，不能再次被赋值
修饰类：表明该类是最终类，不能被继承
参考代码：
package com.itheima_01;
/*
父类
*/
public class Base {
public final void method(){ //被final注释的方法是最终方法，是不可以进行重写的
System.out.println("父类 method");
}
}
//public final class Base { //如果一个类被final修饰 就已经代表这个类为最终类 不可以被继承
// public final void method(){
// System.out.println("父类 method");
// }
//}
package com.itheima_01;
/*
子类
*/
public class Son extends Base{
public final int age = 20; //说明被final修饰后 为常量
public void show(){
// age = 100; //重新赋值 被final修饰以后就不能被重新赋值了
System.out.println(age);
}
// @Override
// public void method(){
// System.out.println("子类 method");
// }
}
package com.itheima_01;
/*
测试类
*/
public class Demo {
public static void main(String[] args) {
//创建子类对象
Son s = new Son();
s.method(); //尽管在子类中没有重写这个方法，但是还是能够在父类中找到
s.show();
}
}
2、final修饰局部变量
变量是基本类型：final修饰指的是基本类型的数据值不能发生改变
变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的
注意：类对象保存的值是地址值（对应给成员变量在堆区开辟的内存空间），但是其指向应该是类，引用本质是指针常量即指针的指向不能修改，内容可以更改。
参考代码：
package com.itheima_02;
/*
创建一个学生类 用于给FinalDemo类中提供引用类型
*/
public class Student {
public int age = 20; //用于测试
}
package com.itheima_02;
/*
测试类：final修饰局部变量
*/
public class FinalDemo {
public static void main(String[] args){
//final修饰基本类型变量
final int age = 20;
//age = 100;
System.out.println(age);
//final修饰引用类型变量
final Student s = new Student();
//此处注意区分：final修饰的是 s这个引用类型 存储的是地址值 s.age是这个地址下的内容
s.age = 100;
System.out.println(s.age);
//同样也是 内容将无法修改
// s = new Student(); //重新分配地址值
}
}
2、static（静态）
1、static 关键字是静态的意思，可以修饰成员方法，成员变量
2、static修饰的特点
被类的所有对象共享
这也是我们判断是否使用关键字的条件（可共享的数据被修饰）
可以通过类名 或者 对象名调用
由于其共享，此时具体的对象对其没有必要性，因为已经不需要对其进行对象的区分了
（推荐使用类名调用）
参考代码：
package com.itheima_01;
/*
学生类
*/
public class Student {
//属性
public String name; //姓名
public int age; //年龄
// public String university = "传智大学"; //学校
public static String university; //static修饰 表示这份数据所有类对象共享
public void show(){
System.out.println(name + "," + age + "," + university);
}
}
package com.itheima_01;
/*
测试类
*/
public class StaticDemo {
public static void main(String[] args) {
//对于共享成员变量而言 已经不用通过对象进行赋值了(关键在于其的共享性)
Student.university = "传智大学";
Student s1 = new Student();
s1.name = "张三";
s1.age = 30;
//共享成员变量 只要一个赋值或修改，其它所有变量都会保留后一次改动的数据
// s1.university = "传智大学";
s1.show();
Student s2 = new Student();
s2.name = "李四";
s2.age = 33;
//当这些学生 都来自同一个大学这一份大学的数据 对于这些学生而言都是共享的
// s2.university = "传智大学";
s2.show();
}
}
3、static访问特点
非静态的成员方法：
能访问静态的成员变量
能访问非静态的成员变量
能访问静态的成员方法
能访问非静态的成员方法
静态的成员方法
能访问静态的成员变量
能访问静态的成员方法
这也是之前，在main方法所在类中定义方法要用static修饰的原因
静态成员方法只能访问静态成员
参考代码：
package com.itheima_02;
/*
static访问特点
*/
public class Student {
//非静态成员变量
private String name = "张三";
//静态成员变量
private static String university = "传智大学";
//非静态成员方法
public void show1(){
}
//非静态成员方法
public void show2(){
//非静态方法可以访问 静态、非静态方法和变量
System.out.println(name);
System.out.println(university);
show1();
show3();
}
//静态成员方法
public static void show3(){
}
//静态成员方法
public static void show4(){
//由此可见 静态方法 只能访问：静态属性和静态方法
// System.out.println(name);
System.out.println(university);
// show1();
show3();
}
}