java 导包命令 java中导包是什么意思

Java语法

一.包

1.什么是包？

• 包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。
• 建包的语法格式：package 公司域名倒写.技术名称。包名建议全部英文小写，且具备意义

package javastudy;

public class Student { }

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

2.导包

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

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.如果这个类中使用不同包下的相同类名，此时默认只能导入一个类的包，另一个类要使用全名
        Student s1 = new Student();
        d1_package.it2.Student s2 = new d1_package.it2.Student();
    }
}

二.权限修饰符

1.什么是权限修饰符？

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

2.权限修饰符的分类和具体作用范围：

权限修饰符：有四种作用范围由小到大（private -> 缺省 -> protected - > public ）

修饰符	同一 个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√

自己定义成员（方法，成员变量，构造器等）一般需要满足如下要求：

成员变量一般私有：

方法一般公开。

如果该成员只希望本类访问，使用private修饰。

如果该成员只希望本类，同一个包下的其他类和子类访问，使用protected修饰。

三.final

1.final的作用：

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

2.final修饰变量的注意

final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。

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

四.常量

1.常量概述和基本作用

• 常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变。
• 常量名的命名规范：英文单词全部大写，多个单词下划线连接起来。
• 常量的作用：通常用来记录系统的配置数据。

常量做信息配置的原理、优势：

• 在编译阶段会进行“宏替换”：把使用常量的地方全部替换成真实的字面量。
• 维护系统容易，可读性更好。

选择常量做信息标志和分类：

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

五.枚举

1.枚举的概述

枚举是Java中的一种特殊类型

2.枚举的作用：“是为了做信息的标志和信息的分类”。

定义枚举类的格式：

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

enum Season{SPRING , SUMMER , AUTUMN , WINTER;}

3.枚举的特征：

枚举类都是继承了枚举类型：java.lang.Enum

• 枚举都是最终类，不可以被继承。
• 构造器都是私有的，枚举对外不能创建对象。
• 枚举类的第一行默认都是罗列枚举对象的名称的。

枚举类相当于是多例模式。

4.注意事项

选择常量做信息标志和分类：

• 虽然可以实现可读性，但是入参值不受约束，代码相对不够严谨。

枚举做信息标志和分类：

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

六.抽象类

1.抽象类概述

抽象类

• 在Java中abstract是抽象的意思，可以修饰类、成员方法。
• abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。
• 修饰符 abstract class 类名{ 修饰符 abstract 返回值类型 方法名称(形参列表)； }
• public abstract class Animal{public abstract void run();}

注意事项

抽象方法只有方法签名，不能声明方法体。

• 一个类中如果定义了抽象方法，这个类必须声明成抽象类，否则报错。

抽象的使用场景

抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承。

当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成。此时这个类就可以声明成抽象类。

2.抽象类的案例

//        系统需求:
//        某加油站推出了2种支付卡，一种是预存10000的金卡，后续加油享受8折优惠，另一种是预存5000的银卡 ,后续加油享受8.5折优惠。
//        请分别实现2种卡片进入收银系统后的逻辑，卡片需要包含主人名称，余额，支付功能。
//        分析实现:
//        创建一张卡片父类：定义属性包括主人名称、余额、支付功能（具体实现交给子类）
//        创建一张白金卡类：重写支付功能，按照原价的8折计算输出。
public class Test {
    public static void main(String[] args) {
        GoldCard c = new GoldCard();
        c.setMoney(10000);
        c.setName("张飞");

        c.payForMoney(1000);
        System.out.println("剩余："+ c.getMoney());
    }
}

public abstract class Card {
    private String name;
    private double money;
    /**
     定义一个支付功能的抽象方法
     */
    public abstract void payForMoney(double money2);

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

public class GoldCard extends Card{
    @Override
    public void payForMoney(double money2) {
        System.out.println("您当前的消费金额为："+money2);
        System.out.println("您的余额为："+getMoney());
        //优惠价
        double rs = money2 * 0.8;
        System.out.println(getName() + ":您实际支付："+rs);
        //更改账户余额
        setMoney(getMoney() - rs);
    }
}

3.抽象类的特征、注意事项小结

特征和注意事项

• 类有的成员（成员变量、方法、构造器）抽象类都具备
• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
• 一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
• 不能用abstract修饰变量、代码块、构造器。

**最重要的特征：**得到了抽象方法，失去了创建对象的能力（有得有失）

final和abstract是什么关系？

互斥关系

abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。

抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。

4.抽象类的应用知识：模板方法模式

使用场景说明：当系统中出现同一个功能多处在开发，而该功能中大部分代码是一样的，只有其中部分可能不同的时候。

模板方法模式实现步骤

1、定义一个抽象类。

2、定义2个方法，一个是模板方法：把相同代码放里面去，不同代码定义成抽象方法

3、子类继承抽象类，重写抽象方法。

模板方法模式提高了代码的复用性。

案例：

public abstract class Student {
    /**
     声明了模板方法模式
     */
    public void write(){
        System.out.println("\t\t《三国志》");
        System.out.println("你看过《三国志》之后有什么感受呢~~~");
        //正文部分（每个类都要写的，每个子类写的情况不一样
        //因此，模板方法把正文部分定义成抽象方法，交给具体的子类来完成）
        System.out.println(writeMain());
        System.out.println("《三国志》真是太好看了");
    }
    public abstract String writeMain();
}

public class StudentChild extends Student{
    @Override
    public String writeMain() {
        return "我二弟天下无敌";
    }
}

public class StudentMiddle extends Student{
    @Override
    public String writeMain() {
        return "我有卧龙凤雏，何惧也！";
    }
}

public class Test {
    public static void main(String[] args) {
        //调用模板方式模式
        StudentChild s1 = new StudentChild();
        s1.write();
        System.out.println("-------------------------------");
        StudentMiddle s2 = new StudentMiddle();
        s2.write();
    }
}