一.包(package)

1. 包:其实就是文件夹
2. 作用:对类进行分类管理
3. 包定义格式:package 包名(多级包名用. 分开)
4. 导入包：使用不同包下类时，需要写类的全路径为简化，就使用import
5. 导包格式:import 包名;如:import com.Demo.a1;或import com.Demo.*;
6. 如果在同一包下则不需要导包import

二.状态修饰符

一.final(最终态)

1. final关键字词的含义: 最终的, 用它修饰之后表示不能再改变了
2. final能修饰的内容: 修饰类, 修饰方法, 变量
3. 修饰类:

• 表示一个类是最终的类, 表示这个类不能有子类 (不能被其他的类继承)
• 一个类如果被final修饰,这个类中所有的方法都不能被重写

1. 修饰方法:
   一个方法如果被final修饰了,这个方法不能被重写
2. 修饰变量:

• 一个变量如果被final修饰之后,就会变成常量,不能再次赋值,只能赋值一次
• 可以定义和赋值同时进行; 如:final int a = 10
• 定义和赋值分离, 但是也只能赋值一次; final int b; b = 10
• 使用final定义的变量称之为:常量 常量名要是用纯大写的字母多个单词之间使用下划线连接: final int MAX_VAULE = 10; final int MIN = 1

1. 修饰局部变量：

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

1. 代码案例:

public class Student {
    public int age = 21;
}
public class finalDemo {
    public static void main(String[] args) {
        //final修饰基本类型变量
        final int age = 30;//final int age;先修饰再赋值就不会报错
        //      age=100;
        System.out.println(age);//输出age为30
        //final修饰引用类型变量
        final Student s = new Student();//修饰的地址值不变
        s.age = 200;//但内容可以改变
        System.out.println(s);//输出地址值为@49e4cb85
        s.age = 300;
        System.out.println(s);//输出地址值还是没改变为@49e4cb85
        System.out.println(s.age);//输出s.age=300;
//        s=new Student();不能创建新的地址值
    }
}

二.static(静态)

1. static关键字含义:静态;可以修饰成员方法成员变量,成员方法
2. static修饰特点：被类的所有对象共享访问
3. 代码案例:

public class Student {
    public int age;
    public String name;
    public static String university;//static被类的所有对象共享访问
    public void show() {
        System.out.println(age + \",\" + name + \",\" + university);
    }
}
public class StaticDemo {
    public static void main(String[] args) {
        //静态变量访问特点：一般直接通过类名调用也可以通过对象名调用
        //static被类的所有对象共享访问
        Student.university=\"qinghua\";

        Student s = new Student();
        s.age = 20;
        s.name = \"xiaojiang\";
    //    s.university = \"qinghua\";
        s.show();
        Student s2 = new Student();
        s2.age = 21;
        s2.name = \"xiaoning\";
        //    s2.university=\"qinghua\";
        s2.show();
       // s2.university = \"武汉大学\";则xiaoyun为武汉大学
        Student s3 = new Student();
        s3.age = 22;
        s3.name = \"xiaoyun\";
        s3.show();
        //输出20,xiaojiang,qinghua
        //21,xiaoning,qinghua
        //22,xiaoyun,qinghua
    }
}

1. static访问特点:总之静态成员方法只能访问静态成员

• 非静态成员方法:
  • 能够访问静态的成员变量
  • 能够访问非静态的成员变量
  • 能够访问静态的成员方法
  • 能够访问非静态的成员方法
• 静态的成员方法:
  • 能够访问成员变量，但不能直接访问
  • 能够访问成员方法，但不能直接访问

1. 代码案例:

public class Student2 {
    //非静态成员变量
    public String name = \"xiaojiang\";
    //静态成员变量
    public static String university = \"beida\";

    //非静态成员方法
    public void show1() {
        System.out.println(name);
        System.out.println(university);
        show2(); //非静态都可以访问静态的和非静态的成员方法和成员变量
        show3();
    }
    public void show2() {

    }
    //静态成员方法
    public static void show3() {
//        System.out.println(name);
        System.out.println(university);
//        show1();
//        show2();
        show3();//静态只能静态的成员变量，成员方法
        show4();
    }
    public static void show4() {

    }
}

1. 静态应用:

public class Student {
    //非静态成员属性
    public int age;
    //静态成员属性
    public static String name;

    //非静态成员方法
    public void show1() {
        System.out.println(\"非静态show1成员方法\");
    }

    //静态成员方法
    public static void show2() {
        System.out.println(\"静态show2成员方法\");
    }
}
public class Demo {
    public static void main(String[] args) {
        Student s = new Student();
        //通过创建对象调用
        s.show1();
        s.age = 20;
        System.out.println(s.age);
        //还可以通过类名来调用;静态调用静态的成员属性和方法
        //静态的内容既可以使用对象名访问,也可以使用类名访问.但是最好使用类名来访问.
        Student.show2();
        Student.name = \"xiaojiang\";
        System.out.println(Student.name);
    /*输出  非静态show1成员方法
           20
          静态show2成员方法
          xiaojiang  */
    }
}

1. static应用场景Java中常量Constant:

public class Constant {
    //常量 不可以被改变的量(final)
    //常量名称全部都为大写  crtl+shift+u 点击常量可调整大小写
    //常量访问可以通过类名.
    //CODE_10== 成功
    public final static int CODE_10 = 10;
    //CODE_20== 错误
    public final static int CODE_20 = 20;
    //CODE_30== 找不到
    public final static int CODE_30 = 30;
}
public class ConstantDemo {
    public static void main(String[] args) {
        //    Constant constant = new Constant();
        //    constant.CODE=300;
        int code = 10;
        if (Constant.CODE_10 == code) {
            System.out.println(\"成功\");
            return;
        }
        if (Constant.CODE_20 == code) {
            System.out.println(\"错误\");
            return;
        }
        if (Constant.CODE_30 == code) {
            System.out.println(\"找不到\");
            return;
        }
    }
}