包、权限修饰符、final、常量、枚举

一、包

1、定义

包是用来分门别类的管理各种不同类的、类似于文件夹、建包利于程序的管理和维护

2.建包

• package
• 建包语句必须在第一行，一般IDEA工具会帮助创建

3.导包

相同包下的类可以直接访问，不同包下的类必须导包才可以使用，导包格式：import 包名.类名

package com.itheima.d1_package;
import com.itheima.d1_package.it.Student;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        //目标：理解一下两点
        //1.同一个包下的类互相可以直接访问
        System.out.println(User.onlineNumber);
        //2.不同包下的类必须先导包
        Scanner sc=new Scanner(System.in);
        //3.如果这个类中使用不同包下的相同的类名，此时默认导入一个类的包，另一个类要使用全名访问。
        com.itheima.d1_package.it2.Student s2=new com.itheima.d1_package.it2.Student();
    }
}

4.总结

4.1同一个包下的类互相可以直接访问
4.2不同包下的类必须先导包
4.3如果这个类中使用不同包下的相同的类名，此时默认导入一个类的包，另一个类要使用全名访问。

二、权限修饰符

1.定义

• 权限修饰符：用来控制一个成员能够被访问的范围
• 可以修饰成员变量、方法、构造器、内部类、不同修饰符修饰的成员能够被访问的范围将受到限制

2.分类和范围

• private<缺省(默认)<protected<public
  注：该案例中Fu类和Test类在一个包，Zi类和Test2类在一个包，并且Zi类继承Fu类

package com.itheima.d2_modifier;
public class Fu {
    /**
     * 1.定义私有的成员:private 只能本类使用
     */
    private void privateMethod(){
        System.out.println("============private=================");
    }
    /**
     * 2.定义缺省修饰的成员： 本类，同包下其他类（包访问权限）
     */
    void Method(){
        System.out.println("==================缺省================");
    }
    /**
     * 3.protected修饰的成员：本类，同包的其他类，其他包的子类中
     */
    protected void protectedMethod(){
        System.out.println("===============protected====================");
    }
    /**
     * 4.public修饰的成员：本类、同包的其他类、其他包的子类，其他包的无关类
     */
    public void publicMethod(){
        System.out.println("================public================");
    }
    public static void main(String[] args) {
        Fu f=new Fu();
        f.privateMethod();
        f.Method();
        f.protectedMethod();
        f.publicMethod();
    }
}

package com.itheima.d2_modifier;
public class Test {
    //目标：理解权限修饰符的修饰范围，明白每一种修饰后的作用范围
    public static void main(String[] args) {
        Fu f=new Fu();
        f.publicMethod();
        f.protectedMethod();
        f.Method();
      //  f.private();报错，不支持
    }
}

package com.itheima.d2_modifier.itcast;
import com.itheima.d2_modifier.Fu;
public class Zi extends Fu{
    public static void main(String[] args) {
        /**
         * 创建子类对象，而不是父类
         */
        Zi z=new Zi();
      // z.privateMethod();报错
      //  z.Method();报错
        z.protectedMethod();
        z.publicMethod();
        Fu f=new Fu();
      //  f.privateMethod();报错
      //  f.Method();报错
     //   f.protectedMethod();报错
        f.publicMethod();
    }
}

package com.itheima.d2_modifier.itcast;
import com.itheima.d2_modifier.Fu;
/**
 * 其他包的无关类
 */
public class Test2 {
    public static void main(String[] args) {
        Fu f=new Fu();
       // f.privateMethod();报错
     //   f.Method();报错
     //   f.protectedMethod();报错
        f.publicMethod();
    }
}

3.自己定义成员（方法、成员变量、构造器等）一般满足的条件

• 成员变量一般私有
• 方法一般公开
• 若成员只希望本类使用，使用private修饰
• 若成员希望本类，同一个包下的其他类和子类访问，使用private修饰

三、final

1.final作用

• 可以修饰类、方法、变量
• 修饰类：最终类，不能被继承
• 修饰方法：最终方法，不能被重写
• 修饰变量：该变量赋值一次后，不能再被赋值（有且仅能被赋值一次）

2.final修饰变量的注意点

• final修饰的变量是基本类型：存储的数据值不会发生改变
• final修饰的变量是引用类型：变量存储的地址值不会发生改变，但是地址指向的对象内容是可以发生改变的

public class Test2 {
    /**
     *二、final修饰静态成员变量（public static final修饰的也称为常量)
     */
    public static final String schoolName="黑马";
    /**
     *三、final修饰实例成员变量（几乎不用，会导致每个对象的名字都是孙悟空）
     */
    private final String name="孙悟空";
    public static void main(String[] args) {
        //目标：理解final修饰变量的作用 总规则：变量有且仅能被赋值一次（理解语法）
        //变量有两种：
        // 1.局部变量
        // 2.成员变量
        //         ---------实例成员变量
        //         ---------静态成员变量
        //一、final修饰局部变量
        final double rate=3.14;
       // rate=3.19;//第二次赋值，报错
        buy(0.8);
        //schoolName="黑马程序员";//报错第二次赋值
        Test2 t=new Test2();
        System.out.println(t.name);
      //  t.name="猪八戒";报错，第二次赋值
    }
    public static void buy(final double z){
      //  z=0.1;第二次赋值，报错
        //注意：final修饰引用类型的变量，其地址值不能发生变化，当时指向的对象内容可以改变
        final Teacher t=new Teacher("授课");
        //t=null;报错
        System.out.println(t.getHobby());
        t.setHobby("唱歌");
        System.out.println(t.getHobby());
    }
}
class Teacher{
    private String hobby;
    Teacher(String hobby){
        this.hobby=hobby;
    }
    public String getHobby() {
        return hobby;
    }
    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

四、常量

1.常量概述和基本作用

1.1常量

• 常量是用public static final修饰的成员变量，必须有初始化值，并且执行过程中不能被改变

1.2作用

• 可以用于做系统的配置，方便程序的维护，同时提高可读性

1.3常量的命名规范

• 英文单词全部大写，多个单词用下划线连接

1.4常量的执行原理

• 在编译阶段会进行"宏替换"，把使用常量的地方全部替换成真实的字面量
• 这样做的好处是让使用常量的程序的执行性能能与直接使用字面量是一样的

public class ConstantDemo1 {
    public static final String SCHOOL_NAME="传智教育";
    public static final String USER_NAME="admin";
    public static final String PASS_WORD="123456";
    public static void main(String[] args) {
        System.out.println("SCHOOL_NAME");
        System.out.println("SCHOOL_NAME");
        System.out.println("SCHOOL_NAME");
        System.out.println("SCHOOL_NAME");
        if(USER_NAME.equals("")){
        }
    }
}

2.常量做信息标志和分类

• 代码的可读性好，实现了软编码形式

五、枚举

1.概述

枚举是java中国一种特殊的类型

2.枚举的作用

为了做信息的标志和信息的分类

3.定义枚举类的格式

修饰符 enum 枚举名称{
第一行都是罗列枚举类实例的名称
}

/**
 * 枚举类
 */
public enum Season {
    //罗列枚举类的对象名称，建议全部大写
    SPRING,SUMMER,AUTUMN,WINTER;
}

反编译后观察枚举的特征：
反编译代码如下：

public final class Season extends java.lang.Enum<Season> {
  public static final Season SPRING=new Season();
  public static final Season SUMMER=new Season();
  public static final Season AUTUMN=new Season();
  public static final Season WINTER=new Season();
  public static Season[] values();
  public static Season valueOf(java.lang.String);
  static {};
}

4.枚举的特征

• 枚举类都是继承了枚举类型：java.lang.Enum
• 枚举类都是最终类，不能被继承
• 枚举类的构造器都是私有的，枚举对外不能创建对象
• 枚举类第一行默认都是罗列枚举对象名称的
• 枚举类相当于是多例模式

5.枚举的使用场景

枚举做信息标志和分类

• 代码可读性好，入参约束严谨，代码优雅，是最好的信息分类技术！建议使用！