Java修饰符

• 包
• 导包
• 修饰符

---

包
包的概述和使用：
其实就是文件夹
作用：对类进行分类管理

包的定义格式
格式：package包名:(多级包用.分开)
范例：package com.itheima;

带包的Java类编译和执行

• 手动建包：
  按照以前的格式编译Java文件 Javac HelloWorld.java
  手动创建包 在E盘建立文件夹com，然后在com下建立文件夹itheima
  把class文件放到包的最里面 把HelloWorld.class文件放到com下的itheima这个文件夹下
• 自动建包：
  javac-d.HelloWorld.java java com.itheima.HelloWorld

---

导包
导包的概述和使用
使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了，为了简化带包的操作，Java就提供了导包的功能
导包的格式：
格式：import 包名;
范例：importcn.itcast.Teacher
eg:

package cn.itcast;

public class Teacher {
    public void teach(){
        System.out.println("用爱成就每一位学员");
    }
}

package com.itheima;
import cn.itcast.Teacher;

public class Demo {
    public static void main(String[] args){
        Teacher t=new Teacher();
        t.teach();
    }
}

终端：
用爱成就每一位学员

---

修饰符
修饰符的分类

• 权限修饰符
• 状态修饰符

权限修饰符

状态修饰符

• final(最终态)
• static(静态)

final
final关键字是最终的意思，可以修饰成员方法，成员变量，类

final修饰的特点：
修饰方法：表明该方法是最终方法，不能被重写
修饰变量：表明该变量是常量，不能再次被赋值
修饰类：表明该类是最终类，不能被继承

eg：

package Java;

public class Fu {
    public void method(){
        System.out.println("Fu method");
    }
}

package Java;

public class Zi extends Fu{
    public void method(){
        System.out.println("Zi method");
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        Zi z=new Zi();
        z.method();
    }
}

终端：
Zi method

eg：

package Java;

public class Fu {
    public final void method(){
        System.out.println("Fu method");
    }
}

package Java;

public class Zi extends Fu{
    public int age=20;

    public void show(){
        System.out.println(age);
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        Zi z=new Zi();
        z.method();
        z.show();
    }
}

终端：
Fu method
20

eg：

package Java;

public class Fu {
    public final void method(){
        System.out.println("Fu method");
    }
}

package Java;

public class Zi extends Fu{
    public int age=20;

    public void show(){
        age=100;
        System.out.println(age);
    }
}

package Java;
/*
测试类
*/
public class Demo {
    public static void main(String[] args){
        Zi z=new Zi();
        z.method();
        z.show();
    }
}

终端：
Fu method
100

final修饰局部变量

• 变量是基本类型：final修饰指的是基本类型的数据值不能发生改变
• 变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

eg：

package Java;

public class Student {
    public int age=20;
}

package Java;

public class FinalDemo {
    public static void main(String[] args){
        //final修饰基本类型变量
        final int age=20;
        System.out.println(age);

        //final 修饰引用类型变量
        Student s=new Student();
        System.out.println(s.age);
    }
}

终端：
20
20

eg：

package Java;

public class Student {
    public int age=20;
}

package Java;

public class FinalDemo {
    public static void main(String[] args){
        //final修饰基本类型变量
        final int age=20;
        System.out.println(age);

        //final 修饰引用类型变量
        Student s=new Student();
        s.age=100;
        System.out.println(s.age);
    }
}

终端：
20
100

eg：

package Java;

public class Student {
    public int age=20;
}

package Java;

public class FinalDemo {
    public static void main(String[] args){
        //final修饰基本类型变量
        final int age=20;
        System.out.println(age);

        //final 修饰引用类型变量
        final Student s=new Student();
        s.age=100;
        System.out.println(s.age);
    }
}

终端：
20
100

static
static关键字是静态的意思，可以修饰成员方法，成员变量

static修饰的特点

• 被类的所有对象共享
  这也是我们判断是否使用静态关键字的条件
• 可以通过类名调用
  当然，也可以通过对象名调用

eg：

package Java;

public class Student {
    public String name;
    public int age;
    public String university;

    public void show(){
        System.out.println(name+","+age+","+university);
    }
}

package Java;

public class StaticDemo {
    public static void main(String[] args){
        Student s1=new Student();
        s1.name="鱼皮";
        s1.age=23;
        s1.university="东华大学";
        s1.show();
    }
}

终端：
鱼皮,23,东华大学

package Java;

public class Student {
    public String name;
    public int age;
    public String university;

    public void show(){
        System.out.println(name+","+age+","+university);
    }
}

package Java;

public class StaticDemo {
    public static void main(String[] args){
        Student s1=new Student();
        s1.name="鱼皮";
        s1.age=23;
        s1.university="东华大学";
        s1.show();

        Student s2=new Student();
        s2.name="鱼二";
        s2.age=24;
        s2.university="东华大学";
        s2.show();
    }
}

终端：
鱼皮,23,东华大学
鱼二,24,东华大学

eg：

package Java;

public class Student {
    public String name;
    public int age;
    //public String university;
    public static String university;

    public void show(){
        System.out.println(name+","+age+","+university);
    }
}

package Java;

public class StaticDemo {
    public static void main(String[] args){
        Student s1=new Student();
        s1.name="鱼皮";
        s1.age=23;
        s1.university="东华大学";
        s1.show();

        Student s2=new Student();
        s2.name="鱼二";
        s2.age=24;
        //s2.university="东华大学";
        s2.show();
    }
}

终端：
鱼皮,23,东华大学
鱼二,24,东华大学

static访问特点
非静态的成员方法

• 能访问静态的成员变量
• 能访问非静态的成员变量
• 能访问静态的成员方法
• 能访问非静态的成员方法

静态的成员方法
能访问静态的成员变量
能访问静态的成员方法

总结成一句话就是：静态成员方法只能访问静态成员

eg：

package Java;

public class Student {
    //非静态成员变量
    public String name="鱼皮";
    //静态成员变量
    public 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();
    }
}