12_Java中的修饰符

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();
    }
}