一、static关键字

day02【static、final、权限关键字，代码块，接口，枚举】.pptx

一、static关键字

static静态的引入

static属于一个修饰符号，用来修饰成员变量、成员函数的

static修饰函数的格式：
修饰符 返回值类型  函数名( 参数 )
{
函数体;
}

class Student
{
  public static void sleep()
  {
          System.out.println("睡觉。。。。。。");
  }
}
public class StuDemo2 {
    public static void main(String[] args) {      
        // 调用静态方法
        Student.sleep();
    }
}

静态代码块

静态代码块：定义在成员位置，使用static修饰的代码块{ }。

位置：类中方法外。
执行：随着类的加载而执行且执行一次。

public class ClassName{
   //静态代码块
    static {
          // 执行语句 
    }
}

作用：给类变量进行初始化赋值 小结：1.当 static 修饰成员变量或者成员方法时，该变量称为静态变量，该方法称为静态方法。该类的每个对象都共享同一个类的静态变量和静态方法。任何对象都可以更改该静态变量的值或者访问静态方法。但是不推荐这种方式去访问。因为静态变量或者静态方法直接通过类名访问即可，完全没有必要用对象去访问。
2.无static修饰的成员变量或者成员方法，称为实例变量，实例方法，实例变量和实例方法必须创建类的对象，然后通过对象来访问。
3.static修饰的成员属于类，会存储在静态区，是随着类的加载而加载的，且只加载一次，所以只有一份，节省内存。存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。它优先于对象存在，所以，可以被所有对象共享。
4.无static修饰的成员，是属于对象，对象有多少个，他们就会出现多少份。所以必须由对象调用。
5.静态方法中不能使用和对象有关的所有内容：this super….

二、包和权限修饰符

权限修饰符

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，我们之前已经学习过了public 和 private，接下来我们研究一下protected和缺省（default默认）修饰符的作用。

public：公共的，所有地方都可以访问。
protected：当前类，当前包，当前类的子类可以访问。
缺省（没有修饰符）：当前类，当前包可以访问。
private：私有的，当前类可以访问。 public > protected > 缺省 > private

不同权限的访问能力

:::info | | public | protected | 缺省（空的） | private |
| ———— | ——— | ————- | ——— | ———- |
| 同一类中 | √ | √ | √ | √ |
| 同一包中的类 | √ | √ | √ | |
| 不同包的子类 | √ | √ | | |
| 不同包中的无关类 | √ | | | | ::: 注意事项： :::danger 注意：
1）如果父类中的函数使用protected关键字修饰，那么这个函数可以被不同包下的子类访问，而不同包中的其他类不能访问。
2）protected只能修饰成员函数或成员变量，不能修饰类。
3) 四种访问权限，能够跨包访问的只有 public protected(必须是子类) :::

三、final关键字

final：不可改变。可以用于修饰类、方法和变量。

类：被修饰的类，不能被继承。即final修饰的类不能有子类。
方法：被修饰的方法，不能被子类重写。
变量：被修饰的变量，不能更改变量的值。

使用方式：

java
final class 类名 {
}
修饰方法
修饰符 final 返回值类型 方法名(参数列表){
    //方法体
}
修饰变量**局部变量——基本类型**
public class FinalDemo1 {
    public static void main(String[] args) {
        // 声明变量，使用final修饰
        final int a;
        // 第一次赋值 
        a = 10;
        // 第二次赋值
        a = 20; // 报错,不可重新赋值
    }
}

四、代码块

1 构造代码块

构造代码块：

位置：定义在成员位置的代码块{}
执行：每次创建对象都会执行构造代码块
作用：一般是一个类的多个构造方法重复的代码放到构造代码块中

public class Teacher {
    String name;
    int age;

    //定义计数器
    static int count = 0;
    //构造代码块
    //构造代码块会在构造方法之前执行，并且每次执行构造方法都会先执行构造代码块
    {
        System.out.println("构造代码块");
        //统计
        count++;
    }

    //无参构造
    public Teacher(){
        System.out.println("构造方法");
    }
    //有参构造
    public Teacher(String name, int age){
        this.name = name;
        this.age = age;
    }
}

静态代码块


        static{

        }

局部代码块

定义在方法中:
{

}

执行顺序演示

public class AAA {
    //静态代码块
    //静态代码块只会执行一次 并在最开始第一个执行
    static{
        System.out.println(2);
    }
    //构造代码块
    //在每次执行构造方法之前先执行构造代码块
    {
        System.out.println(3);
    }
    //构造方法
    public AAA() {
        System.out.println(1);
    }

}

public class Demo04{
    public static void main(String[] args) {
        //创建对象
        AAA a1 = new AAA();
        AAA a2 = new AAA();
    }
}

执行结果：    2 3 1 3 1

五、接口

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8）。接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，接口。

public interface 接口名称 {
    // 抽象方法
    // 默认方法
    // 静态方法
}
含有抽象方法
public interface InterFaceName {
    public abstract void method();
}
含有默认方法和静态方法
public interface InterFaceName {
    public default void method() {
        // 执行语句
    }
    public static void method2() {
        // 执行语句    
    }
}

非抽象子类实现接口：

必须重写接口中所有抽象方法。
继承了接口的默认方法，即可以直接调用，也可以重写。
```
class 类名 implements 接口名 {
 // 重写接口中抽象方法【必须】
   // 重写接口中默认方法【可选】
}
```
抽象方法的使用
定义接口：
```java 定义接口：

public interface LiveAble { // 定义抽象方法 public abstract void eat(); public abstract void sleep(); }

定义实现类： public class Animal implements LiveAble { @Override public void eat() { System.out.println(“吃东西”); }

@Override
public void sleep() {
    System.out.println("晚上睡");
}

}

小贴士：子接口重写默认方法时，default关键字可以保留。子类重写默认方法时，default关键字不可以保留
<a name="iLDAs"></a>
### 接口小结
接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用**public static final**修饰。- JDK8前接口中的方法全是抽象方法，默认会自动加上**public abstract**修饰<br />- JDK 8开始，接口不再纯洁，支持**静态方法，默认方法**，私有方法。<br />- 接口中，没有构造器，**不能创建对象**。<br />- 类与接口是多实现的 implements<br />- 接口与接口是多继承的 extends<br />- 接口体现的规范。
<a name="gTUrv"></a>
## 六、枚举
```java
enum Sex {
    BOY, GIRL; // 男，女
}

1)从反编译的代码可以看出编译器确实帮助我们生成了一个Sex类(注意该类是final类型的，将无法被继承)而且该类继承自java.lang.Enum类，Enum类是一个抽象类 2)除此之外，编译器还帮助我们生成了2个Sex类型的实例对象分别对应枚举中定义的2个性别，这也充分说明了我们前面使用关键字enum定义的Sex类型中的每种性别枚举常量也是实实在在的Sex实例对象。

枚举补充

枚举的本质是一个类，所以枚举中还可以有成员变量，成员方法等。 1）枚举的属性上面不能书写任何代码，如果属性下面有代码，需要使用分号结束属性的编写 2）只要我们使用枚举类型，那么属性属于静态的，并且给属性赋值，会创建对象，执行无参构造方法 3）如果想执行有参构造，可以给属性后面添加小括号，并赋值实际参数 4）枚举中的构造函数必须是私有的

枚举表示性别：
public enum Sex {
    MAIL, FEMAIL;
}
枚举表示方向：
public enum Orientation {
    UP, RIGHT, DOWN, LEFT;
}


枚举表示季度
public enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

枚举类在第一行罗列若干个枚举对象，是常量。（多例）- 枚举是不能在外部创建对象的，枚举的构造方法默认是私有的。
- 枚举通常用于做信息的标志和分类。

javaSe

Static、fianl、代码块、接口、枚举

一、static关键字

static静态的引入

静态代码块

二、包和权限修饰符

权限修饰符

不同权限的访问能力

三、final关键字

使用方式：

四、代码块

静态代码块

局部代码块

执行顺序演示

五、接口

非抽象子类实现接口：

抽象方法的使用

定义接口：

枚举补充