包、权限修饰符、final、常量、枚举、抽象类、接口

目录

 包、权限修饰符、final、常量、枚举、抽象类、接口

包

权限修饰符

final关键字的介绍

常量

枚举

抽象类

接口

---

包

什么是包？
    包是用来分门别类的管理各种不同类的，类似于文件夹、建包有利于程序的管理和维护
    建包的语法格式：package 公司域名倒写.技术名称。建议全部英文小写，且具备意义
        package com.Java.javabean;
    建包语句必须放在第一行，一般IDEA工具会帮助创建
导包
    相同包下的类可以直接访问，不同包下的类必须导包才可以使用
    导包格式：import 包名.类名;

权限修饰符

什么是权限修饰符？
    权限修饰符：是用来控制一个成员能够被访问的范围的
    可以修饰成员变量、方法、构造器、内部类，
    不同权限修饰符的成员能够被访问的范围将受到限制
权限修饰符的分类和具体作用范围：private->缺省->protected->public（小到大）
自己定义成员一般私有，方法一般公开

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

final关键字的介绍

final关键字是的最终意思，可以修饰（方法、类、变量）
final修饰的特点
    修饰方法：表明该方法是最终方法，不能被重写
    修饰类：表明该类是最终类，不能被继承
    修饰变量：表明该变量是常量，不能再次被赋值
final修饰变量的细节补充
    变量是基本类型：final修饰指的是基本类型的数据值不能发生改变
    变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，
    但是地址里面的内容是可以发生改变的
    成员变量如果被final修饰，需要在构造方法结束之前完成赋值
final修饰变量的命名规则
    如果变量名是一个单词，所有字母大写
    如果变量名是多个单词，中间用下划线分割，所有字母大写

常量

常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行过程中其值不能被改变
常量的作用和好处：
    可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性
常量的执行原理
    在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量
    这样做的好处是让使用常量的程序的执行性能与直接使用字面量是一样的

public class Test {
    public static final String NAME = "小明";//常量

    public static void main(String[] args) {
        System.out.println(NAME);
        System.out.println(NAME);
        System.out.println(NAME);
        System.out.println(NAME);
        System.out.println(NAME);
    }
}

枚举

枚举的概述
    枚举是Java中的一种特殊类型
    枚举的作用：是为了做信息的标志和信息的分类
定义枚举的格式：
    修饰符 enum 枚举名称{
        第一行都是罗列枚举实例的名称
    }

    enum Season{
        SPRING,SUMMER,AUTUMN,WINTER
    }

抽象类

抽象类
    某个父类知道所有子类要完成某功能，但是每个子类完成的情况都不一样，
    父类就只定义该功能的基本要求，具体实现由子类完成，
    这个类就可以是一个抽象类，抽象类其实是一种不完全的设计图
    抽象类必须使用abstract修饰
    修饰符 abstract class 类名{}
抽象方法
    就是抽象类中定义的子类必须完成的功能的基本要求
    没有方法体，只有方法签名，必须abstract修饰
    修饰符 abstract 返回值类型 方法名称（形参列表）；

//抽象类
public abstract class Animal {
    public abstract void run();//抽象方法
}

//子类
public class Dog extends Animal {
    @Override
    public void run() {
        System.out.println("狗跑的很快~~~");
    }
}

//测试
public class Test {

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.run();
    }
}

抽象类的作用是什么样的？什么时候定义抽象类？
    可以被子类继承、充当模板的、同时也可以提高代码复用性
    如果父类知道子类要完成某个功能，实现要交给子类时
抽象方法是什么样的？
    只有方法签名，没有方法体，使用了abstract修饰
继承抽象类需要有哪些注意？
    一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法
    否则这个类必须定义成抽象类

 

 

//抽象父类
public abstract class Card {
    private String name;//主人名称
    private double money;

    public abstract void pay(double money);//抽象方法

    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 pay(double money) {
        //金卡优惠金额
        double result = money * 0.8;
        double lastMoney = getMoney() - result;//当前账户余额
        System.out.println(getName() + "当前账户总金额:" + getMoney() + ",消费了：" + result + "，消费后剩余：" + lastMoney);
        setMoney(lastMoney);
    }
}

//测试
public class Test {

    public static void main(String[] args) {
        GoldCard goldCard = new GoldCard();
        goldCard.setName("小明");
        goldCard.setMoney(1000);
        goldCard.pay(300);
    }
}

 

 

抽象类的特征
得到类抽象方法，失去了创建对象的能力
抽象类为什么不能创建对象？
    类有的成员（成员变量、方法、构造器）抽象类都具备
    抽象类中不一定有抽象方法，有抽象方法一定是抽象类
    一个类继承了抽象类必须重写抽象类的全部抽象方法，否则这个类也必须定义成抽象类
    不能用abstract修饰变量、代码块、构造器

接口

什么是接口？
    接口就是体现规范的，其中用抽象方法定义的一组行为规范，接口是更加彻底的抽象
    体现现实世界中“如果你是这类事物...则必须完成某些行为...”的思想
接口的定义与特点
接口格式：
接口用关键字interface来定义
    public interface 接口名{
        //常量
        //抽象方法
    }
JDK8之前接口中只能是抽象方法和常量，没有其他成分了
接口不能实例化
接口中的成员都是public修饰的，写不写都是，因为规范的目的是为了公开化

public interface SportManInterface {
    /**
     * 接口中的成员，JDK1.8之前只有常量和抽象方法
     * public static final可以省略不写，接口会默认加上的
     * 抽象方法public abstract 可以省略不写，接口会默认加上
     */
    //public static final String NAME = "java";
    String NAME = "java";//常量

    //public  abstract void run();
    void run();//抽象方法
}

接口的用法
    接口是用来被类实现（implement）的,实现接口的类被称为实现类
    实现类可以理解成所谓的子类
    修饰符 class 实现类 implement 接口1，接口2，...{
    }
    实现类的关键字：implement
    接口类可以被类单实现，也可以被类多实现

JDK8版本后，Java对接口成员方法进行了新增
第一种：默认方法
    类似于之前写的普通实例方法：必须用default修饰
    默认会public修饰，需要用接口的实现类的对象来调用
    default voidrun（）{
        System.out.println(“--开始跑--”);
    }
第二种：静态方法
    默认public修饰，必须static修饰
    注意：接口的静态方法必须用本身的接口名来调用
    static void inAddr(){
        System.out.println(“--来啦--”);
    }
第三种：私有方法
    就是私有的实例方法：必须使用private修饰（JDK1.9开始有）
    只能在本类中被其他的默认方法或私有方法访问
    private void go（）{
        System.out.println(“--准备--”);
    }

public interface SportManInterface {
    //默认方法：接口不能创建对象，所以这个方法只能过继给实现类，由实现类的对象调用
    default void run() {
        go();//调用私有方法
        System.out.println("跑的真快~~~");
    }

    /**
     * 静态方法：默认public修饰，必须static修饰
     * 注意：接口的静态方法必须用本身的接口名来调用
     */
    static void inAddr() {
        System.out.println("学习Java新增方法~~~");
    }

    /**
     * 私有方法：只能在本类中被其他的默认方法或私有方法访问
     */
    private void go() {
        System.out.println("开始跑~~~");
    }
}

//定义实现类
class PingPongMan implements SportManInterface {
}

class Tests {
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan();//创建实现类对象
        p.run();//调用接口的默认方法

        SportManInterface.inAddr();//使用接口名来调用静态方法
    }
}

接口的注意事项
    接口不能创建对象
    一个类实现多个接口，多个接口中有同样的静态方法不冲突
    一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的
    一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可
    一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承