【Java学习】语法：包、权限修饰符、final、常量、枚举、抽象类、接口

一、包

什么是包?

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

package com.it.javabean;
public class student{ }
1
2

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

导包

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

二、权限修饰符

什么是权限修饰符?

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

权限修饰符的分类和具体作用范围:

• 权限修饰符:有四种作用范围由小到大(private ->缺省->protected - > public )
  

三、final

final的作用

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

final修饰变量的注意

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

四、常量

常量

• 常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变。
• 常量的作用和好处:可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性。

常量的执行原理

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

优雅

• 见名知意，信息的标志与分类，可读性高，实现软编码。

五、枚举

enum枚举的概述

• 枚举是Java中的一种特殊类型
• 枚举的作用:“是为了做信息的标志和信息的分类”。

枚举的特征:

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

public enum Orientation{
	UP,DOWN,LEFT,RIGHT;
}
1
2
3

switch 与 枚举自动结合使用

六、抽象类

1、抽象类、抽象方法是什么样的?

• 都是用abstract修饰的;抽象方法只有方法签名，不能写方法体。
• 一个类中定义了抽象方法，这个类必须声明成抽象类。

2、抽象类基本作用是啥?

• 作为父类，用来被继承的。

3、继承抽象类有哪些要注意?

• 一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

案例
系统需求

• 某加油站推出了2种支付卡，一种是预存10000的金卡，后续加油享受8折优惠，另一种是预存5000的银卡,后续加油享受8.5折优惠。
• 请分别实现2种卡片进入收银系统后的逻辑，卡片需要包含主人名称，余额，支付功能。

代码只写了金卡：
Card.java

package com.ith.d6_abstract_test;

public abstract class Card {
    private String userName;
    private double money;

    /**
     * 支付方法
     * 抽象方法
     */
    public abstract void pay(double money2);


    public String getUserName() {
        return userName;
    }


    public void setUserName(String userName) {
        this.userName = userName;
    }

    public double getMoney() {
        return money;
    }

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

GoldCard.java

package com.ith.d6_abstract_test;

public class GoldCard extends Card {
    @Override
    public void pay(double money2) {
        System.out.println("您当前消费：" + money2);
        System.out.println("您卡片当前余额是："+getMoney());
        double rs = money2*0.8;
        System.out.println("您实际支付：" + rs);
        setMoney(getMoney()-rs);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

Test.java

package com.ith.d6_abstract_test;

public class Test {
    public static void main(String[] args) {
        GoldCard c = new GoldCard();
        c.setMoney(10000);
        c.setUserName("lll");

        c.pay(9000);
        System.out.println("剩余：" + c.getMoney());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

输出

您当前消费：9000.0
您卡片当前余额是：10000.0
您实际支付：7200.0
剩余：2800.0
1
2
3
4

特征和注意事项

• 类有的成员（成员变量、方法、构造器）抽象类都具备

• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

• 一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

• 不能用abstract修饰变量、代码块、构造器。

• 最重要的特征:得到了抽象方法，失去了创建对象的能力（有得有失)

模板方法：
中学生与小学时都写一篇模板作文
Student.java

package com.ith.d7_abstract_template;

public abstract class Student {
    /**
     * 模板方法
     */
    public void write(){
        System.out.println("开头");
        System.out.println("正文：");
        //模板
        System.out.println(writemain());
        System.out.println("结尾~~");

    }

    public abstract String writemain();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

StudentChild.java

package com.ith.d7_abstract_template;

public class StudentChild extends Student{

    @Override
    public String writemain() {
        return "StudentChild" ;
    }
}

1
2
3
4
5
6
7
8
9
10

StudentMiddle.java

package com.ith.d7_abstract_template;

public class StudentMiddle extends Student{

    @Override
    public String writemain() {
        return "StudentMiddle" ;
    }
}

1
2
3
4
5
6
7
8
9
10

Test.java

package com.ith.d7_abstract_template;

public class Test {
    public static void main(String[] args) {
        StudentMiddle s = new StudentMiddle();
        s.write();
        System.out.println("-----------");
        StudentChild s2 = new StudentChild();
        s2.write();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

输出

开头
正文：
StudentMiddle
结尾~~
-----------
开头
正文：
StudentChild
结尾~~

1
2
3
4
5
6
7
8
9
10

七、接口

接口的用法:

• 接口是用来被类实现(implements)的，实现接口的类称为实现类。实现类可以理解成所谓的子类。

修饰符class 实现类implements接口1,接口2,接口3，... {}
实现的关键字:implements
1
2

• 从上面可以看出，接口可以被类单实现，也可以被类多实现。

接口实现的注意事项:

• 一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类。

接口可以多继承
代码 gitee->zijin-jdd -> java_-strengthen_project ->d10_interface_extends

1、JDK8开始后新增了那些方法?

• 默认方法:default修饰，实现类对象调用。
• 静态方法:static修饰，必须用当前接口名调用
• 私有方法: private修饰，jdk9开始才有的，只能在接口内部被调用。

2、接口注意事项

• 1、接口不能创建对象（重要）
• 2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。
• 3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
• 4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
• 5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。