【Java】包 修饰符 final 常量 枚举 抽象类 接口

包

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

建包的语法格式：

package 公司域名倒写.技术名称。 包名建议全部英文小写，且具备意义

例：

package com.dazz.javabean;

public class Student{

}

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

导包

        相同包下的类可以直接访问，不同包下的类必须导包，才可以使用

导包：import 包名.类名;

假如一个类中需要用到不同类，而这两个类的名称是一样的，那么默认只能导入一个类，另一个类要带包名访问(尽量不要出现)

例：

import com.dazz.t1.Student;

public class Test{

        public static void main(String[] args){

                Student s1 = new Student();

                com.dazz.t2.Student s2 = new com.dazz.t2.Student(); 

        }

}

权限修饰符

        权限修饰符：是用来控制一个成员能够被访问的范围的

作用：

        可以修饰成员变量，方法，构造器，内部类，不同权限的修饰符修饰的成员能够被访问的范围将受到限制

权限修饰符：有四中作用范围由小到大(private<缺省)

  

学完权限修饰符需要具备如下能力：

        能够识别别人定义的成员的访问权限

        自己定义成员(方法，成员变量，构造器等)

                成员变量一般私有化

                方法一般公开

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

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

final

        final关键字是最终的意思，可以修饰(方法，变量，类)

修饰类：表明该类是最终类，不能被继承

修饰方法：表示该方法是最终方法，不能被重写

修饰变量：表示该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次)

注意：

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

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

常量

        是使用了public static final修饰的成员变量，必须有初始值，而且执行的过程中其值不能被改变

常量的作用和好处：可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性

例：

public class Constant{

//常量的命名规范：英文单词全部大写，多个单词下划线连接起来

        public static final String SCHOOL_NAME = "中华大学";

        public static final String SCHOOL_ID = "13140103";

}

常量的执行原理

        在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量

        这样的好处就是让常量程序执行的性能和直接使用字面量是一样的

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

 枚举

        枚举是Java中的一种特殊类型，是为了做信息的标志和信息的分类

定义枚举类的格式：

修饰符 enum 枚举名称{

        第一行都是罗列枚举类实例的名称

}

例：

public enum Season{

        SPRING,SUMMER,AUTUMN,WINTER;

}

 枚举的特征：

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

        枚举都是最终类，不可以被继承

        构造器都是私有的，枚举对外不能创建对象

        枚举类的第一行都是默认罗列枚举对象的名称的

        枚举类相当于是多例模式

反编译观察（javap是反编译）

    定义类时,发现该类的对象只有固定的几个,且每个对象的内容不可改变时,需要定义成枚举类
    定义交通灯:
        1.红灯: 停
        2.绿灯: 行
        3.黄灯: 等一等
    1.格式：
		public enmu 枚举名{}
    2.枚举常量定义
    	(1)枚举中的常量名字大写，多个常量之间逗号分开，最后一个常量可以写分号
    	(2)每一个常量，都表示这个类的对象。
    	(3)枚举常量修饰符为public static final(不需要自己写,也不能写)
    	(4)枚举中有默认的无参数的private修饰的构造方法，如果手写构造方法，也必须是私有修饰的
    	(5)构造方法必须写在常量的后面，这时最后一个常量就必须要写分号
 */
public enum Light01 {
    RED("红灯","停"),
    GREEN("绿灯","行"),
    YELLOW("黄灯","等一等");

    private String color;//代表颜色
    private String info;//代表信息
    //满参构造方法
    /*private */Light01(String color, String info) {
        this.color = color;
        this.info = info;
    }
    //空参构造
    /*private */Light01() {
    }

    //覆盖重写toString方法
    //自己定义的枚举类,默认继承Enum类
    //重写的是Enum类中的toString方法
    @Override
    public String toString() {
        return "Light01{" +
                "color='" + color + '\'' +
                ", info='" + info + '\'' +
                '}';
    }

    //5.方法获取对象中的属性信息,提供get方法
    //每个对象中的属性信息,不允许修改,不能提供set方法
    public String getColor() {
        return color;
    }

    public String getInfo() {
        return info;
    }
}

    枚举类的values方法是一个特殊方法(内置方法),api和源代码中都没有提供
    但是我们可以直接使用,获取到的是该枚举类中的对象数组
    自己定义的枚举类,默认继承Enum类,内部成员方法
        public final String name(): 返回此枚举常量的名称，在其枚举声明中对其进行声明。
        public final int ordinal(): 返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。
 */
public class Demo00Light01 {
    public static void main(String[] args) {
        Light01 red = Light01.RED;
        System.out.println(red);
        System.out.println(red.name() + "::::" + red.ordinal());
        System.out.println(red.getColor() + "::::" + red.getInfo());
        
        Light01 green = Light01.GREEN;
        System.out.println(green);
        System.out.println(green.name() + "::::" + green.ordinal());
        System.out.println(green.getColor() + "::::" + green.getInfo());
        
        Light01 yellow = Light01.YELLOW;
        System.out.println(yellow);
        System.out.println(yellow.name() + "::::" + yellow.ordinal());
        System.out.println(yellow.getColor() + "::::" + yellow.getInfo());
        
        //使用自定义枚举类名Light01调用values方法,获取所有的枚举项组成的数组
        Light01[] values = Light01.values();
        for (Light01 value : values) {
            System.out.println(value.name() + "----" + value.ordinal());
            System.out.println(value.getColor() + "----" + value.getInfo());
        }
    }
}

常量和枚举使用总结

常量做信息标志和分类：

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

枚举做信息标志和分类：

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

抽象类

        在Java中abstract是抽象的意思，如果一个类中某个方法的具体实现不能确定，就可以申明成abstract修饰的抽象类(不能写方法体了)，这个类必须用abstract修饰，被称为抽象类

格式：

修饰符 abstract class 类名{

        修饰符 abstract 返回值类型 方法名称(形参列表);

}

例：

public abstract class Animal{

        public abstract void run();

}

 抽象的使用总结与注意事项

        抽象类可以理解成类的不完整设计图，是用来被子类继承的

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

1.抽象类的作用是什么样的？

        可以被子类继承，充当模板的，同时也可以提高代码复用

2.抽象方法是什么样的？

        只有方法标签，没有方法体，使用了abstract修饰

3.继承抽象类有哪些要注意？

        一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法

        否则这个类也必须定义成抽象类

public class AbstractDemo {
    public static void main(String[] args) {
        GoldCard g = new GoldCard();
        g.setName("大珍珠");
        g.setBalance(10000.0);
        g.pay(300);
    }
}

//抽象类：卡片
abstract class Card{
    private String name;
    private double balance;

    public Card() {
    }

    public Card(String name, double balance) {
        this.name = name;
        this.balance = balance;
    }

    public abstract void pay(double money);

    public String getName() {
        return name;
    }

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

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}

//金卡继承了抽象类
class GoldCard extends Card{

    public GoldCard() {
    }

    public GoldCard(String name, double balance) {
        super(name, balance);
    }
//重写抽象类 方法
    @Override
    public void pay(double money) {
        System.out.println(getName()+"金卡支付");
        double d = super.getBalance()-(money*0.8);
        String gold = "应付："+money+"元，实付："+(money*0.8)+"\n"+
                "金卡剩余："+d;
        System.out.println(gold);
    }

}

抽象类的特征 注意事项 

有得有失：得到了抽象类方法，失去了创建对象的能力

抽象类为什么不能创建对象？
        类有的成员(成员变量，方法，构造器)抽象类都具备

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

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

        不能用abstract修饰变量，代码块，构造器

final abstract

互斥关系

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

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

抽象类：模块方法模式

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

模块方法模式实现步骤

1.把功能定义成一个模板方法，放在抽象类中，模板方法中只定义通过且能确定的代码

2.模板方法中不能确定的功能定义成抽象方法让具体子类去实现。 

3.模板方法使用final修饰，是让子类使用，不是让子类重写的(防止子类重写)

抽象类的定义(包含了模块方法模式)

public abstract class Student(){
    public final void write(){
        System.out.println("我的老师");
        System.out.println("你的老师，是什么样的呢？");
        wrtieMain();
        System.out.println("感谢老师教授了我这么多知识！！！");
    }

    public abstract void wrtieMain();
}

子类定义

public StudentChild extends Student{
    @Override
    public void wirteMain(){
        System.out.println("我的老师很酷，给我教了很多的有趣代码!")
    }
}

测试类

public class Test{
    public static void main(String[] arge){
        StudentChild s = new StudentChild();
        s.write();
    }
}

 模块方法模式解决了什么问题？

        极大地提高了代码的复用性

        模块方法已经定义了通用结构，模块不能确定的定义成抽象方法

        使用者只需要关心自己需要实现的功能即可

接口 

        接口就是规范(interface关键字)

接口的定义格式：

public interface 接口名{

        //常量

        //抽象方法

}

JDK8前：

        JDK8之前接口中只能是抽象方法和常量，没有其他成分了。

        接口不能实例化

        接口中的成员都是public修饰的，写不写都是，因为规范的目的是为了公开化

接口的基本使用：被实现

接口的用法：

接口是用来被类实现(implenments)的，实现接口的类称为实现类。

实习类可以理解成所谓的子类

例：

修饰符 class 实现类 implements 接口1,接口2,接口3{

}

注意：

接口可以被类单实现，也可以被类多实现

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

总结：

        类与类的关系：单继承

        类于接口的关系：多实现

        接口于接口的关系：多继承，一个接口可以同时继承多个接口

接口多继承的作用：

         规范合并，整合多个接口为同一个接口，便于子类实现

JDK8开始接口新增方法

        JDK8版本开始，Java只对接口的成员方法进行新增，允许接口中直接定义带有方法体的方法

第一种：默认方法

        类似之前写的普通实例方法：必须用default修饰

        默认会public修饰，需要用接口的实现类的对象来调用

例：

public default void run(){

        System.out.println("我其实就是普通方法·")

}

---

第二种：静态方法

        默认会public修饰，必须static修饰

        注意：接口的静态方法必须用本身的接口名来调用

 例：

public static void eat(){

        System.out.println("吃生蚝啊！！！");

}

---

第三种：私有方法

        就是私有的实例方法：必须使用private修饰，JDK9.0才开始有的

        只能在本类中被其他的默认方法或者私有方法访问

例：

private void go(){

        System.out.println("出发吧！")

} 

注意：

        JDK8新增的3种方法我们开发很少用，通常解读Java源码涉及

        我们需要理解，识别语法，明白调用关系即可

接口的注意

        1.接口不能创建对象

        2.一个类实现多个接口，多个接口中有同样的静态方法不冲突

        3.一个继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认使用父类

        4.一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重复写该方法即可

        5.一个接口继承多个接口，是没有问题的，但是多个接口中存在规范冲突则不能多继承

public class Test {
}
//1、接口不能创建对象
//接口不能创建对象！抽象！

//2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。
class a implements a1,a2{
    @Override
    public void run() {

    }
}
interface a1{
    void run();
}
interface a2{
    void run();
}

//3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
class b extends b1 implements b2{
    @Override
    public void run() {
    }
}
class b1{
    public void run(){}
}
interface b2{
    void run();
}
//4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
class c implements c1,c2{

    @Override
    public void run() {

    }
}
interface c1{
    void run();
}
interface 2{
    void run();
}
//5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。
/*
class d implements d1,d2{

    @Override
    public void run() {

    }
}
interface d1{
    void run();
}
interface d2{
    int run();
}*/