目录：

1. Java中的关键字
   1. static关键字
   2. final关键字
   3. Java中的权限修饰符
2. 代码块
   1. 构造代码块
   2. 静态代码块
3. 接口
   1. 接口的介绍
   2. 接口的定义和特点
   3. 接口的成员特点
   4. 接口的案例
   5. 接口中成员方法的特点
4. 枚举
5. 随堂小记
   1. 继承
   2. 方法重写
   3. 抽象类
   4. 模板设计模式
   5. static
   6. final
   7. 权限修饰符
   8. 接口
   9. 回顾上午内容：
      1. static关键字
      2. final关键字
      3. 权限修饰符号
      4. 接口
      5. 代码块
      6. 选择语句：
      7. 枚举

1.Java中的关键字

static关键字

• static关键字 :

  • 静态的意思 , 可以修饰变量 , 也可以修饰方法 , 被static修饰的成员 , 我们叫做静态成员

• static特点 :

  • 静态成员被所类的所有对象共享

  • 随着类的加载而加载 , 优先于对象存在

  • 可以通过对象调用 , 也可以通过类名调用 , 建议使用类名

public class Student {
    String name;
    int age;
    static String school;

    public void show() {
        System.out.println(name + "---" + age + "---" + school);
    }
}
/*
    static关键字的特点 :
        1 静态成员被该类的所有对象的进行共享
        2 静态成员可以通过类名调用 , 也可以通过对象进行调用 , 推荐使用类名
        3 静态成员随着类的加载而加载 , 优先于对象存在
 */
public class StudentTest {
    public static void main(String[] args) {
        Student.school = "传智专修学院";

        Student s = new Student();
        s.name = "张三";
        s.age = 23;
        s.show();

        Student s2 = new Student();
        s2.show();

    }
}

• static内存图解

• static关键字的注意事项

  • 静态方法中只能调用静态成员

  • 非静态方法中可以调用任何成员

  • 静态方法中不能存在this关键字

 final关键字

• final关键字 : 翻译中文代表最终的意思 , 是java的一个关键字 也是一个修饰符 , 可以修饰类 , 可以修饰方法 , 也可以修饰变量

• final关键字修饰的特点

  • final修饰的类 : 不能被继承 , 没有子类(太监类)

  • fina修饰的方法 : 不能被重写

  • final修饰的变量

    • 基本数据类型 : 值不能改变

    • 引用数据类型 : 地址不可发生改变 , 对象的属性可改变

    • 注意 :

      • 被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割

      • final修饰成员变量需要注意初始化时机的问题 , 1) 直接赋值 , 2) 在构造方法执行完毕前赋值

package com.itheima.final_demo;

/*
    final的特点
        final修饰的类 , 不能被继承, 也就是没有子类
        final修饰的方法 , 不能被重写
        final修饰的变量
            基本数据类型 : 值不可以发生改变
            引用数据类型 : 地址不可发生改变 , 对象的内容可以发生改变

        注意 :
            1 被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割
            2 final修饰成员变量需要注意初始化时机的问题
              1) 直接赋值
              2) 在构造方法执行完毕前赋值
 */
public class FinalDemo1 {
    public static void main(String[] args) {
        // final修饰的基本数据类型变量 , 值不能被修改
//        final int num = 10;
//        num = 20;
//        System.out.println(num);

        final int[] arr = {1, 2, 3, 4, 5};
        // final修饰的引用数据类型 , 地址不可改发生改变
        // arr = new int[3];
        // final修饰的引用数据类型 , 对象中的内容可以发生改变
        arr[0] = 100;

    }
}

// final修饰的类 , 不能被继承, 也就是没有子类
//final class Person {
//
//}

class Person {
    // final修饰的方法 , 不能被重写
    public final void eat() {

    }
}

class Student extends Person {
    // final修饰成员变量需要注意初始化时机的问题
    // 要么直接赋值 , 要么在构造方法执行完毕前赋值
    // final int num = 10;
    final int num;

    public Student() {
        num = 100;
    }

    //    @Override
//    public void eat() {
//        super.eat();
//    }
}

Java中的权限修饰符

• public -- protected -- 默认的 -- private

package com.itheima.permissions_demo1;

/*
    public -- protected -- 默认的 -- private
 */
public class Fu {
    public void method1() {
    }

    protected void method2() {
    }

    void method3() {
    }

    private void method4() {
    }

    // 同一个包中同一个类
    public void show(){
        method1();
        method2();
        method3();
        method4();
    }

}
===================================================

package com.itheima.permissions_demo1;

public class Test {
    // 同一个包中 , 无关类
    public void show(){
        Fu f = new Fu();
        f.method1();
        f.method2();
        f.method3();
        // f.method4();
    }
}
====================================================
package com.itheima.permissions_demo1;

public class Zi extends Fu {
    // 用一个包中 , 有子类父关系
    public void show(){
        method1();
        method2();
        method3();
        // method4();
    }
}

package com.itheima.permissions_demo2;

import com.itheima.permissions_demo1.Fu;

public class Test {
    // 不同包中 , 无关类
    public void show(){
        Fu f = new Fu();
        f.method1();
        // f.method2();
        // f.method3();
        // f.method4();
    }
}

======================================
    
package com.itheima.permissions_demo2;

import com.itheima.permissions_demo1.Fu;

public class Zi extends Fu {
    // 不同包中 , 有子类父关系
    public void show(){
        method1();
        method2();
        // method3();
        // method4();
    }
}

2.代码块

构造代码块

• 构造方法块 : 用一对大括号表示, 定义在类中方法外

• 执行时机 : 每次构造方法执行前, 都会执行构造代码块

• 作用 : 抽取构造方法中共性内容

package com.itheima.code_block;
/*
    构造代码块
 */
public class Student {
    final int NUM;

    {
        NUM = 10;
        System.out.println("构造代码块...");
    }

    public Student() {
        System.out.println("空参构造...");
    }

    public Student(int a) {
        System.out.println("有参构造...");
    }
}

class StudentTest {
    public static void main(String[] args) {
        Student s = new Student();
        Student s2 = new Student(10);
    }
}

 

静态代码块

• 静态代码块 : 在一对大括号前加上static关键字 , 定义在类中方法外

• 执行时机 : 随着类的加载而加载 , 只加载一次

• 作用 : 一般用于给静态成员初始化

package com.itheima.code_block.static_demo;
/*
  静态代码块 :
      1 定义的位置 : 在一对大括号前加上static , 定义在类中方法外
      2 执行时机 ; 随着类的加载而执行, 只加载一次
      3 可以给类中的静态成员进行初始化数据
 */
public class Test {
  public static void main(String[] args) {
      new Student();
      new Student(10);
  }
}

class Student {
    static {
        System.out.println("静态代码块");
    }

    public Student() {
        System.out.println("空参构造");
    }

    public Student(int a) {
        System.out.println("有参构造");
    }
}

### 2.3 局部代码块

- 成员代码块 : 用一对大括号表 , 可以定义在任何的局部位置 , 方法中居多
- 执行时机 : 正常执行(从上往下依次执行)
- 控制变量的局部变量的声明周期

​```java
package com.itheima.code_block.local_demo;
/*
    局部代码块 :
        1 位置 : 可以定义任何的局部的位置 , 方法中居多
        2 执行时机 : 正常执行(从上往下依次执行)
        3 作用 : 控制变量的生命周期 , 变量在使用完毕, 及时释放内存
 */
public class Test {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1);

        // 局部代码块
        {
            int num2 = 20;
            System.out.println(num1);
            System.out.println(num2);
        }

        System.out.println(num1);
//        System.out.println(num2);// 作用域不够 , 报错

    }
}

3.接口

接口的介绍

• 接口 : 如果一个类中都是抽象方法 , 那么这个类应该是定义规则的类 , 我们应该把此类定义成接口,接口是一种引用数据类型

• 作用 :

  • 用于定义规则

  • 程序的扩展性

接口的定义和特点

• 定义接口的关键字使用interface

  • public interface 接口名{ ... }

• 类与接口之间的关系是实现关系 , 用关键字implements进行连接

  • public class 类名 implements 接口名 { ... }

• 接口不能实例化

• 接口的子类我们叫做实现类

  • 要么重写接口中所有的抽象方法

  • 要么实现类是一个抽象类

• 注意 : 类与接口的关系是实现关系 , 一个类可以实现多个接口,调用逗号分隔 , 还可以继承一个类的同时 , 实现多个接口

package com.itheima.interface_demo;

public interface Inter {
    public abstract void show();
    public abstract void method();
}

interface Inter2 {

}

package com.itheima.interface_demo;

public class InterImpl extends Object implements Inter ,Inter2{
    @Override
    public void show() {
    }

    @Override
    public void method() {
    }
}

package com.itheima.interface_demo;

/*
    1 定义接口的关键字使用interface
      public interface 接口名{ ... }
    2 类与接口的关系是实现关系 , 使用implements进行连接
      public class 类名 implements 接口名{ ... }
    3 接口不能实例化(不能创建对象)
    4 接口的子类,我们叫做实现类
        要么重写接口中所有的抽象方法
        要么这个实现类是一个抽象类

    注意 : 类与接口的关系是实现关系 , 一个类可以实现多个接口
    还可以继承一个类的同时 , 实现多个接口

 */
public class InterfaceDemo1 {
    public static void main(String[] args) {
        // 接口不能实例化(不能创建对象)
        // Inter inter = new Inter();

    }
}

接口的成员特点

• 成员变量 : 都是常量 , 默认修饰符 public static final

• 构造方法 : 没有构造方法

• 成员方法 : 只能是抽象方法 , 默认修饰符public abstract

  • 关于JDK8和JDK9版本对接口增加了一些方法新特性

package com.itheima.interface_demo;

public interface Inter {
    // 是一个常量 , 默认修饰符 public static final
    public static final int num = 10;
    
    // 不存在构造方法
    // public Inter(){}

    public abstract void show();
    public abstract void method();
}

interface Inter2 {

}

public class InterfaceDemo1 {
    public static void main(String[] args) {
        // 接口不能实例化(不能创建对象)
        // Inter inter = new Inter();

        // 成员变量被static修饰
        System.out.println(Inter.num);
        // 是一个常量 , 只能赋值一次
        // Inter.num = 20;
    }
}

接口的案例

package com.itheima.interface_demo.interface_test;

public interface player {
    public abstract void play();
    public abstract void pause();
    public abstract void stop();
}

package com.itheima.interface_demo.interface_test;

public class MP3 implements player {
    @Override
    public void play() {
        System.out.println("MP3开始播放音乐");
    }

    @Override
    public void pause() {
        System.out.println("MP3开始暂停");
    }

    @Override
    public void stop() {
        System.out.println("MP3开始关闭音乐");
    }
}

package com.itheima.interface_demo.interface_test;

public class MP4 implements player {
    @Override
    public void play() {
        System.out.println("MP4播放音乐");
    }

    @Override
    public void pause() {
        System.out.println("MP4暂停音乐");
    }

    @Override
    public void stop() {
        System.out.println("MP4关闭音乐");
    }
}

package com.itheima.interface_demo.interface_test;
/*
   需求 :
   1  创建一个播放接口 player
   2  定义三个抽象方法 , 播放(play),暂停(pause),停止(stop)
   3  定义MP3类,MAP4类,手机类,实现接口,重写抽象方法

 */
public class PlayerTest {
    public static void main(String[] args) {
        MP3 mp3 = new MP3();
        mp3.play();
        mp3.pause();
        mp3.stop();
        System.out.println("=============");
        MP4 mp4 = new MP4();
        mp4.play();
        mp4.pause();
        mp4.stop();
    }
}

 

接口中成员方法的特点

• DK8版本之前 : 只能是抽象方法

• JDK8版本 :

  • 默认方法

    • JDK8可以在接口中定义非抽象方法(带有方法体的方法) , 需要使用default进行修饰 , 其实就是默认方法

    • 作用 : 解决接口升级的问题

    • 格式 : public default 返回值类型 方法名(参数) { ... }

    • 注意事项 :

      • 默认方法不是抽象方法 , 可以继承 , 也可以重写 , 重写需要去掉default关键字

      • public 可以省略 , default不能省略

      • 如果实现类实现了多个接口 , 有相同的方法声明 , 那么实现类必须重写该方法

  • 静态方法

    • JDK8可以在接口中定义静态方法 , 也是有方法体的方法

    • 作用 : 方便调用此功能

    • 格式 : public static 返回值类型 方法名(参数){ ... }

    • 注意事项

      • 静态方法只能通过接口名调用 , 不能通过实现类名字和对象调用

      • public可以省略 , static不能省略

• JDK9版本 :

  • 私有方法

    • JDK9中新增私有方法

    • 作用 : 抽取默认方法中共性内容

    • 格式 : private 返回值类型 方法名(参数){ ... }

    • 注意 : 要想抽取静态方法中的共性内容 , 需要对私有方法加上关键字static

4.枚举

• 枚举 : 当一个变量有几种固定可能的取值时，就可以将它定义为枚举类型

• 作用 : 更贴切 , 加见名之意

• 定义 : public enum 枚举名{ ... }

• 使用 : 通过枚举类型名直接引用枚举项即可，例如Sex.BOY、Sex.GIRL 注意 : 每个枚举项都相当于枚举的对象

• 案例代码

package com.itheima.enum_demo;

public enum Sex {
    // 每一个枚举项都是枚举的对象
    GIRL("女孩"), BOY("男孩"), YAO;

    // 成员变量
    private String name;

    // 空参构造方法
    private Sex() {
    }

    // 有参构造方法
    private Sex(String name) {
        this.name = name;
    }

    // 成员方法
    public String getName() {
        return name;
    }
}

class Test {
    public static void main(String[] args) {
        System.out.println(Sex.GIRL.getName());
        System.out.println(Sex.BOY.getName());
        System.out.println(Sex.YAO.getName());
    }
}

• 枚举的本质 :

  • 枚举其实本质上是一个类，每一个枚举项是本枚举类类型的一个对象。我们可以使用JDK提供的反编译命令，将枚举的字节码进行反编译查看

    • 枚举本质上就是最终类

    • 枚举项，就是枚举类的对象，而且是静态的常量。

    • 有私有的构造方法

    • 静态代码块

    • 继承了lang包下的Enum

• 组成部分 :

  • 构造器，成员方法，成员变量等 , 但是定义的成分一定要在枚举项之后，而且最后一个枚举项必须要有分号结束。

5. 随堂小记

继承

//什么是继承？
让一个类继承另一个类就是继承。使用关键字：extends进行继承

    
//继承解决程序中什么问题？（核心）
1. 继承可以建立类与类之间的关系
2. 继承可以提高程序中代码的复用性（子类在继承父类后，就可以直接使用父类中的非私有成员）    

    

//继承怎么使用？（核心）
public class 父类{
    
}
public class 子类 extends 父类{
    
}


//继承在使用中的注意事项
1、继承只能单一继承(不支持多继承)，允许多层次继承
2、不能继承父类中私有的成员
3、继承中成员的访问原则：就近原则（子类有中，就使用子类自己的，子类中没有，去父类中找）
4、子类对象在初始化时，需要先初始化父类对象（只有父类初始化完成，子类才可以访问父类中的成员）
    问题：子类怎么做到在创建对象时，先把父类初始化？
    答案：子类的构造方法中，默认第一行都有隐藏代码super()//调用父类无参构造方法

方法重写

//什么是方法重写？
子类中存在和父类中一模一样的方法，称为：方法重写


//方法重写解决程序中什么问题？
当父类中的方法，不能满足子类的需求，子类可以重写父类中的方法
    

//方法重写怎么使用？
public class 父类{
    public void method(String name){
        
    }
}
public class 子类 extends 父类{
    @Override //和父类一模一样的方法
    public void method(String name){
        
    }
}    


//方法重写在使用中的注意事项
1. 不能对父类中的私有方法进行重写
2. 子类中的方法必须和父类中的方法一模一样    

抽象类

什么是抽象类？


//抽象类解决程序中什么问题？
1. 当某个不希望被创建对象，可以使用abstract修饰为抽象类（仅仅只是做为父类使用）
2. 当某些方法无法书写具体的方法体代码时，把这些方法修饰为抽象方法，书写在抽象类中    


//抽象类怎么使用？
public abstract class 抽象类名{
    
}


//抽象类在使用中的注意事项
1、抽象类不能实例化（不能创建对象）
2、抽象类比普通类多了一个抽象方法（普通类可以书写的内容，都可以书写在抽象类中）
   抽象类中可以书写构造方法（目的：为了保障子类对象创建成功） 
3、抽象类中的所有抽象方法，在子类中都要重写（另一种：子类也做为抽象类） 

模板设计模式

//模板设计模式解决程序中什么问题？
当程序中有固定的执行流程了，但流程中的某个或某些点，在不确定时，就可以使用模板设计模式
    
    
//模板设计模式的使用
public abstract class 模板设计模式的抽象类{
    public void 固定执行流程的方法(){
        //1、固定流程格式
        
        //2、固定流程格式
        
        
        //3、不确定（定义为抽象方法）
        
        //4、不确定（定义为抽象方法）
        
        //5、固定流程格式 
        
        //6、不确定（定义为抽象方法）
    }
    
    public abstract 返回值类型 抽象方法();//3、不确定（定义为抽象方法）
    
    public abstract 返回值类型 抽象方法();//4、不确定（定义为抽象方法）
    
    public abstract 返回值类型 抽象方法();//6、不确定（定义为抽象方法）
}    

static

什么是static？

static是java语言中的修饰符关键字
用来修饰：成员变量、成员方法

static解决程序中的什么问题？

当程序中的某个数据需要共享时使用static修饰

static怎么使用？

public class Student{
    //成员变量
    private String name;
    private static String city;//静态成员变量
    
    //静态成员方法
    public static void method(){
        
    }
}

//通过类名访问静态内容（静态的私有成员变量不能访问）

static在使用中的注意细节

1、静态内容是随着类的加载就存在了（早于对象创建）
2、静态内容通常是使用： 类名.成员变量     类名.成员方法()
3、静态方法中只能访问静态成员（静态变量、静态方法）
4、静态方法中不能使用this关键字
5、非静态方法中可以直接访问：静态成员

JVM内存划分:

1. 栈

2. 堆

3. 方法区

   • 是由N多个不同功能的小区域组成的

     • 静态区域：存放静态内容

     • 非静态区域：存放非静态内容

     • 字符串常量池：存放字符串常量

4. 寄存器

5. 本地方法区

final

final是什么？

final是java语言中的修饰符关键字
用来修饰：类、变量、方法    
    
final关键字的含义：最终的、不可改变的    

 final解决程序中什么问题？

1、当某个变量不允许修改数据值时，可以使用final修饰变量
2、当某个方法不允许被子类重写时，可以使用final修饰方法
3、当某个类不允许被继承时，可以使用final修饰类。  举例：String类

final怎么使用？

public final class 类名{
    
    private final int COUNT=100;
   
    public final void method(){
       
   } 
}

final在使用中的注意细节

final和abstract不能共存使用

权限修饰符

权限修饰符是什么？

权限修饰符是java语言中的关键字，用于修饰：类、变量、方法
权限修饰符：private 、public 、protected、默认(什么都不写)

权限修饰符号解决什么问题？

限制程序中的访问权限（类的访问权限、变量的访问权限、方法的访问权限）

权限修饰符怎么使用？

//类（权限：公开的 [没有限制]）
public class 类{
    //成员变量（私有权限：本类中使用）
    private String name;
    
    //默认权限（权限：当前包下的任意类）
    void show(){
        
    }
    
    //protected（权限：子类）
    protected void method(){
        
    }
}

从小到大排序：
1. private //访问范围： 仅现本类中访问
2. 默认     //访问范围： 只能在同一个包下的类
3. protected  //访问范围： 同一个包下的任意类 或 不同包下的子类 
4. public     //访问范围 ：没有限制

权限修饰符在使用中的注意细节？

//方法重写时：保障子类中重写访问的访问权限必须 >= 父类中方法的权限

在开发中经常会使用或开发：工具类

• 工具类的特点：

  1. 不能被继承

  2. 不能让其他类创建对象

  3. 提供静态方法

//final保障 ：工具类不能被继承
public final class 工具类{
    
    //不能让其他类创建对象
    private 工具类(){}
    
    //给外部提供：静态方法
    public static 返回值 静态方法(...){
        
    }
}

 问题：在一个类中可以书写哪些内容？

public class 类{
    //成员变量：静态、非静态
    
    //成员方法：静态、非静态、抽象
    
    //构造方法
    
    //代码块
    
}

代码块：

{
    
}

代码块划分：

• 静态代码块 //开发中使用最多

  • 书写位置：在类中方法外（和成员变量、成员方法属于同一级）

    • 在构造代码块上添加：static

  • 特点：随着类的加载，执行1次静态代码块（类只会被加载1次）

  • 作用：用于对静态成员数据进行初始化

• 构造代码块

  • 书写位置：在类中方法外（和成员变量、成员方法属于同一级）

  • 特点：在每个构造方法执行前，都会先执行构造代码块

  • 作用：当类中多个构造方法中有共性内容时，可能抽取到构造代码块

• 局部代码块

  • 书写位置：写在方法体中

  • 特点：在方法执行时，才会调用

  • 作用：用于作用域

接口

接口的作用：制定规则

制定规则的两种方案：

1. 定义类，类中书写抽象方法（不建议使用。 类只能单一继承）

2. 定义接口， 接口中书写抽象方法（接口好处：可以多实现）

接口的定义：

public interface  接口名{
     //抽象方法
}

 

接口的特点：

1. 接口不能实例化（不能创建对象）

2. 接口中没有构造方法（接口只能通过子类来实现对象创建）

3. 接口可以多实现（ 一个类可以实现多个接口[解决类只能单一继承的问题] ）

按照接口中定义的规则开发子类： 编写接口实现类

public class 接口实现类 implements 接口{
    //重写接口中所有的抽象方法
} 

 接口的多实现：

public class 接口实现类 implements 接口1 , 接口2 , 接口3 {
    //重写所实现接口中所有的抽象方法
} 

在接口可以书写的内容：

public interface 接口名{
    
    //抽象方法
    
    //静态常量
    public static final int NUMBER = 10;
}

思考：静态常量在程序中做什么呢？

问题：生活中有没有一些数据是固定的，且值比较单一？
示例：性别（固定、且仅有2个值）

public interface Gender{
   public static final String BOY = "男";
   public static final String GIRL = "女";
}

//程序中需要给性别赋值
String sex  = Gender.BOY;
String sex = Gender.GIRL;

接口中的方法的升级：

• 随着JDK版本的升级

  • 在jdk1.8版本中新增：默认方法、静态方法 //有方法体代码

  • 在jdk1.9版本中新增：私有方法 //有方法体代码

类和接口的概念：  

类和类之间的关系： 继承 （只能单一继承）
public 子类 extends 父类{
    
}

类和接口之间的关系：实现
public 子类 implements 接口{
    
} 
    
   
接口和接口之间的关系：继承 （允许多继承）
public 接口1 extends 接口2 {
    //问题：为什么接口可以多继承？
    //答案：接口中仅仅只是定义功能（没有功能的实现，子类要自己实现功能）
}

 

接口和抽象类的相同之处：

1. 接口和抽象类， 都不能实例化（不能创建对象）

2. 接口和抽象类，都具有抽象方法

3. 接口和抽象类，都是做为父类型存在的

抽象类和接口的区别：

1. 抽象类：除了抽象方法外，还具有成员变量、构造方法、非抽象方法

2. 接口：除了抽象方法外，只有常量 （JDK8：默认方法、静态方法）（JDK9：私有方法）

回顾上午内容：  

static关键字

//static是什么？
static是java语言中的修饰符关键字。用来修饰：变量、方法
    
//static解决程序中的什么问题？
static可以让数据进行共享（多个对象可以使用同一个数据）
 
//static的使用
public class 类{
    //静态成员变量
    public static int count;
    //静态成员方法
    public static void method(){
        
    }
} 
通过类名访问：静态成员
类名.count = 100;
类名.method();

//static在使用中的细节
1. static修饰的内容是随着类的加载而存在的（早于对象的创建）
2. static修饰的内容是存储在方法区的静态区别下（仅此一份）
3. static修饰的静态方法中，只能访问静态成员
4. static修饰的静态方法中，不能使用this关键字
5. 非静态方法中可以访问：静态方法、静态变量

final关键字  

//final是什么？
final是java语言中的修饰符关键字。用来修饰：类、方法、变量
    
//final可以解决程序中什么问题？
final修饰的类：不能被继承
final修饰的方法： 不能被重写
final修饰的变量： 初始化值后不能改变其值（常量）
    
//final的使用
public final class 类名{
    //变量
    final String name="初始化值";
    
    //方法
    public final void method(){
        
    }
}

权限修饰符号

//权限修饰符解决什么问题？
限制程序中访问权限

//权限修饰符
private 、默认（什么都不写）、protected 、 public 
    
private  ： 仅限本类中使用  
默认（什么都不写） ： 同一个包下的任意类
protected  ： 同一个包下的任意类 、 不同包下的子类
public    ： 没有限制 

接口

//接口的作用：
制定规则 
    

//接口的定义（语法）
public interface 接口名{
    //抽象方法
    public abstract boolean login(String name, String password);
}    
    
//接口的实现（语法） 
public class 接口实现类 implements 接口名{
    //重写：抽象方法
    public boolean login(String name , String password){
        ......
            
        return boolean类型的值;    
    }
}

//接口的特点：
1、接口不能实例化（不能创建对象）
2、接口中没有构造方法
3、接口可以多实现（解决类只能单一继承的问题）
    实现类 可以在继承一个父类的情况下，还可以实现多个接口
    public class 子类 extends 父类 implements 接口A , 接口B{
        //重写所有抽象方法
    }

代码块

代码块：局部代码块、构造代码块、静态代码块
    
构造代码块作用：当类中构造方法里面有共性内容时，可以抽出到构造代码块中
             每次构造方法执行前，都会先执行构造代码块
    
静态代码块：
static{
    //特点：静态代码块是随着类的加载执行（执行1次）
    //作用：初始化数据（数据必须在创建对象之前就初始化完成）
}   

选择语句：

switch( 常量表达式 ){ //只能使用：byte、short、int、char、String、枚举
    case 常量值1:
        语句1;
        break;
    ...    
}

枚举

//什么是枚举
在java语言中，枚举是一种数据类型。枚举用来表示：固定且仅有几种取值范围的数据
例：性别
    
public interface Gender{
    public static final String BOY="男";
    public static final String GIRL="女";
}    
    
public class Student{
    private String name;
    private String sex;
    public Student(String name , String sex){
        this.name = name;
        this.sex = sex;
    }
}
Student stu = new Student("熊大", Gender.BOY);

Student stu = new Student("熊二", "男女");//不会报错
解决方案： 枚举类型


//枚举解决程序中的什么问题？
当程序中有数据是固定且只有几种取值范围时，使用枚举类型强制设置值的范围（赋值数据有保障）    
    

//枚举怎么使用？
public enum Gender{
    BOY , GIRL;
}
public class Student{
    private String name;
    //使用枚举类型
    private Gender gender;
    
    public Student(String name , Gender gender){
        this.name = name;
        this.gender = gender;
    }
}
Student stu = new Student("熊二", "男女");//报错。原因：性别类型必须是Gender枚举

Student stu = new Student("熊二", Gender.BOY);//正确（保障数据的合法有效性）

    
    

//枚举在使用中的注意细节
1. 枚举本质是一个类
2. 在枚举中除了可以书写：固定选项值外，还可以书写：成员变量、私有构造方法、成员方法