包、权限修饰符、final和常量的用法-CSDN博客

已注销
97 阅读5分钟

一、包

  • 包是用来管理各种不同类的，类似于文件夹，建包利于程序的管理和维护。
  • 包名建议全部英文小写，且具备意义。

导包

  • 相同包下的类可以直接访问，不同包下的类必须导包，才可以访问！
  • 导包格式：import   包名.类名；
  • 假如一个类中需要用到不同类，而且这两个类的名称是一样的，那么默认只能导入一个类，另一个类要带包名访问。
package com.gch.d1_package;

public class User {
    public static int onlineNumber = 121;
}

package com.gch.d1_package.it;

public class Student {
}

package com.gch.d1_package.it2;

public class Student {

}

package com.gch.d1_package;

// 导包
import com.gch.d1_package.it.Student;

import java.util.Scanner;


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

 二、权限修饰符

  • 定义私有成员：private，只能在本类中访问。
  • 定义缺省修饰的成员：只能本类、同包下其他类访问（包访问权限）
  • protected修饰的方法：本类，同包的其他类，其他包的子类访问（子类访问权限，是让子类去访问的）
  • public修饰的方法：本类，同包下的其他类，其他包的子类，其他包的无关类都可以访问（公交车）
package com.gch.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.gch.d2_modifier;

// 同包下的其他类
public class Test {
    public static void main(String[] args) {
        // 目标:讲解权限修饰符的修饰范围,明白每一种修饰后的作用范围
        Fu f = new Fu();
//        f.privateMethod(); // 报错,加了private修饰符只能在当前类访问
        f.method();
        f.protectedMethod();
        f.publicMethod();
    }
}

package com.gch.d2_modifier.itcast;

import com.gch.d2_modifier.Fu;

// 其他包的无关类
public class Test2 {
    public static void main(String[] args) {
        // 使用不同包下的类要导包
        Fu f = new Fu();
//        f.privateMethod(); // 报错,加了private修饰符只能在当前类访问
//        f.method(); 报错,缺省的只能同类或者同包下的其他类
//        f.protectedMethod(); // 报错,protected只能同包下的其他类或者其他包的子类
        f.publicMethod();
    }
}

package com.gch.d2_modifier.itcast;

import com.gch.d2_modifier.Fu;

/**
    其他包的子类
 */
public class Zi extends Fu {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.protectedMethod(); // protected子类访问权限,是让子类访问,父类是不能访问的
        z.publicMethod();

        Fu f = new Fu();
        f.publicMethod(); // 父类只能访问public,是不能访问protected的
    }
}

三、final

final的作用

  • fianl关键字是最终的意思，可以修饰（类、方法、变量）
  • 修饰类：表明该类是最终类，不能被继承(工具类就可以定义成final类)。
  • 修饰方法：表明该方法是最终方法，不能被重写。
  • 修饰变量：表示该变量第一次赋值后，不能被再次赋值，即被final修饰的变量有且仅能被赋值一次。

final修饰变量的注意

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

final修饰的变量用于做系统的配置信息，做信息标志和分类，好处：可读性好，软编码修改方便！

package com.gch.d3_final;

public class Test2 {
    /**
        二.修饰静态成员变量(public static final修饰的也称为常量)
     */
    public static final String schoolName = "黑马";

    /**
        三.修饰实例成员变量(几乎不用)
     */
    private final String name = "小明";

    public static void main(String[] args) {
        // 目标:理解final修饰变量的作用,总规则:变量有且仅能被赋值一次(理解语法)
        // 变量有几种:
        //        1.局部变量
        //        2.成员变量
        //               --- 实例成员变量
        //               --- 静态成员变量

        // 一:修饰局部变量
        final double rate = 3.14;
//        rate = 3.19; // 报错,被final修饰的变量有且仅能被赋值一次
        buy(0.8);
//        schoolName = ""; // 报错,第二次赋值
        // 注意:final修饰引用数据类型的变量,其地址值不能改变,但是地址指向的的对象的内容是可以改变的
        final Teacher t2 = new Teacher("喝水");
//        t2 = null; 直接报错,第二次赋值了
        System.out.println(t2.getHobby()); // 喝水
        t2.setHobby("打球");
        System.out.println(t2.getHobby()); // 打球
    }
    public static void buy(final double z){
//        z = 0.1; // 报错,调用方法的时候就已经赋值了,这是第二次赋值
    }
}
class Teacher{
    private String hobby;

    public Teacher(String hobby) {
        this.hobby = hobby;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

 四、常量

  • 常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行过程中其值不能被改变。
  • 常量名的命名规范：英文单词全部大写，多个单词使用下划线连接起来。
  • 常量在编译阶段会进行"宏替换"：把使用常量的地方全部替换成真实的数据，提高开发效率。
package com.gch.d4_constant;

/**
    目标:学会常量的使用,并理解常量
 */
public class ConstantDemo1 {
    // 写死属于硬编码
    public static final String SCHOOL_NAME = "大学";
    public static final String USER_NAME = "admin";
    public static final String PASSWORD = "123";
    public static void main(String[] args) {
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
        System.out.println(SCHOOL_NAME);
    }
}
avatar
文章
阅读
粉丝