今日内容

1 关键字

2 代码块

3 接口

4 枚举

1 Java中的关键字

1.1 static关键字

  • static关键字 :
  • 静态的意思 , 可以修饰变量 , 也可以修饰方法 , 被static修饰的成员 , 我们叫做静态成员
    • static特点 :
  • 静态成员被所类的所有对象共享
  • 随着类的加载而加载 , 优先于对象存在

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

    • ```java 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内存图解


day02-关键字,接口,代码块,枚举 - 图1

  • static关键字的注意事项
  • 静态方法中只能调用静态成员
  • 非静态方法中可以调用任何成员
  • 静态方法中不能存在this关键字

1.2 final关键字

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

  • final关键字修饰的特点

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

    • final修饰的变量

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

      • 注意 :

        • 被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割
        • final修饰成员变量需要注意初始化时机的问题 , 1) 直接赋值 , 2) 在构造方法执行完毕前赋值
  • ```java package com.itheima.final_demo;

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

  1.     注意 :
  2.         1 被final修饰的变量 , 我们叫做自定义常量 , 命名规范 : 每个字母需要大写 , 多个单词之间用下划线分割
  3.         2 final修饰成员变量需要注意初始化时机的问题
  4.           1) 直接赋值
  5.           2) 在构造方法执行完毕前赋值

*/ public class FinalDemo1 { public static void main(String[] args) { // final修饰的基本数据类型变量 , 值不能被修改 // final int num = 10; // num = 20; // System.out.println(num);

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

}

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

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

  1. }

}

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

  1. public Student() {
  2.     num = 100;
  3. }
  5. //    @Override

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

  4. <a name="56e5e510"></a>
  5. ### 1.3 Java中的权限修饰符
  7. - 
  8. public -- protected -- 默认的 -- private
  9. <br />![](%5Cimg%5Cimage-20210331215542736.png#alt=image-20210331215542736)
  10. ```java
  11. package com.itheima.permissions_demo1;
  13. /*
  14.     public -- protected -- 默认的 -- private
  15.  */
  16. public class Fu {
  17.     public void method1() {
  18.     }
  20.     protected void method2() {
  21.     }
  23.     void method3() {
  24.     }
  26.     private void method4() {
  27.     }
  29.     // 同一个包中同一个类
  30.     public void show(){
  31.         method1();
  32.         method2();
  33.         method3();
  34.         method4();
  35.     }
  37. }
  38. ===================================================
  40. package com.itheima.permissions_demo1;
  42. public class Test {
  43.     // 同一个包中 , 无关类
  44.     public void show(){
  45.         Fu f = new Fu();
  46.         f.method1();
  47.         f.method2();
  48.         f.method3();
  49.         // f.method4();
  50.     }
  51. }
  52. ====================================================
  53. package com.itheima.permissions_demo1;
  55. public class Zi extends Fu {
  56.     // 用一个包中 , 有子类父关系
  57.     public void show(){
  58.         method1();
  59.         method2();
  60.         method3();
  61.         // method4();
  62.     }
  63. }
  1. package com.itheima.permissions_demo2;
  3. import com.itheima.permissions_demo1.Fu;
  5. public class Test {
  6.     // 不同包中 , 无关类
  7.     public void show(){
  8.         Fu f = new Fu();
  9.         f.method1();
  10.         // f.method2();
  11.         // f.method3();
  12.         // f.method4();
  13.     }
  14. }
  16. ======================================
  18. package com.itheima.permissions_demo2;
  20. import com.itheima.permissions_demo1.Fu;
  22. public class Zi extends Fu {
  23.     // 不同包中 , 有子类父关系
  24.     public void show(){
  25.         method1();
  26.         method2();
  27.         // method3();
  28.         // method4();
  29.     }
  30. }

2 代码块

2.1 构造代码块

  • 构造方法块 : 用一对大括号表示, 定义在类中方法外
  • 执行时机 : 每次构造方法执行前, 都会执行构造代码块
  • 作用 : 抽取构造方法中共性内容
  1. package com.itheima.code_block;
  2. /*
  3.     构造代码块
  4.  */
  5. public class Student {
  6.     final int NUM;
  8.     {
  9.         NUM = 10;
  10.         System.out.println("构造代码块...");
  11.     }
  13.     public Student() {
  14.         System.out.println("空参构造...");
  15.     }
  17.     public Student(int a) {
  18.         System.out.println("有参构造...");
  19.     }
  20. }
  22. class StudentTest {
  23.     public static void main(String[] args) {
  24.         Student s = new Student();
  25.         Student s2 = new Student(10);
  28.     }
  29. }

2.2 静态代码块

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

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

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

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

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

  1. public Student() {
  2.     System.out.println("空参构造");
  3. }
  5. public Student(int a) {
  6.     System.out.println("有参构造");
  7. }

}

  2. ### 2.3 局部代码块
  4. - 成员代码块 : 用一对大括号表 , 可以定义在任何的局部位置 , 方法中居多
  5. - 执行时机 : 正常执行(从上往下依次执行)
  6. - 控制变量的局部变量的声明周期
  8. ```java
  9. package com.itheima.code_block.local_demo;
  10. /*
  11.   局部代码块 :
  12.       1 位置 : 可以定义任何的局部的位置 , 方法中居多
  13.       2 执行时机 : 正常执行(从上往下依次执行)
  14.       3 作用 : 控制变量的生命周期 , 变量在使用完毕, 及时释放内存
  15. */
  16. public class Test {
  17.   public static void main(String[] args) {
  18.       int num1 = 10;
  19.       System.out.println(num1);
  21.       // 局部代码块
  22.       {
  23.           int num2 = 20;
  24.           System.out.println(num1);
  25.           System.out.println(num2);
  26.       }
  28.       System.out.println(num1);
  29. //        System.out.println(num2);// 作用域不够 , 报错
  31.   }
  32. }

3 接口

3.1 接口的介绍

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

  • 作用 :

    • 用于定义规则
    • 程序的扩展性

3.2 接口的定义和特点

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

    • public interface 接口名{ … }

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

    • public class 类名 implements 接口名 { … }
  • 接口不能实例化

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

    • 要么重写接口中所有的抽象方法
    • 要么实现类是一个抽象类
  • 注意 : 类与接口的关系是实现关系 , 一个类可以实现多个接口,调用逗号分隔 , 还可以继承一个类的同时 , 实现多个接口
  1. package com.itheima.interface_demo;
  3. public interface Inter {
  4.     public abstract void show();
  5.     public abstract void method();
  6. }
  8. interface Inter2 {
  10. }
  1. package com.itheima.interface_demo;
  3. public class InterImpl extends Object implements Inter ,Inter2{
  4.     @Override
  5.     public void show() {
  6.     }
  8.     @Override
  9.     public void method() {
  10.     }
  11. }
  1. package com.itheima.interface_demo;
  3. /*
  4.     1 定义接口的关键字使用interface
  5.       public interface 接口名{ ... }
  6.     2 类与接口的关系是实现关系 , 使用implements进行连接
  7.       public class 类名 implements 接口名{ ... }
  8.     3 接口不能实例化(不能创建对象)
  9.     4 接口的子类,我们叫做实现类
  10.         要么重写接口中所有的抽象方法
  11.         要么这个实现类是一个抽象类
  13.     注意 : 类与接口的关系是实现关系 , 一个类可以实现多个接口
  14.     还可以继承一个类的同时 , 实现多个接口
  16.  */
  17. public class InterfaceDemo1 {
  18.     public static void main(String[] args) {
  19.         // 接口不能实例化(不能创建对象)
  20.         // Inter inter = new Inter();
  22.     }
  23. }

3.3 接口的成员特点

  • 成员变量 : 都是常量 , 默认修饰符 public static final
  • 构造方法 : 没有构造方法

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

    • 关于JDK8和JDK9版本对接口增加了一些方法新特性
  1. package com.itheima.interface_demo;
  3. public interface Inter {
  4.     // 是一个常量 , 默认修饰符 public static final
  5.     public static final int num = 10;
  7.     // 不存在构造方法
  8.     // public Inter(){}
  10.     public abstract void show();
  11.     public abstract void method();
  12. }
  14. interface Inter2 {
  16. }
  1. public class InterfaceDemo1 {
  2.     public static void main(String[] args) {
  3.         // 接口不能实例化(不能创建对象)
  4.         // Inter inter = new Inter();
  6.         // 成员变量被static修饰
  7.         System.out.println(Inter.num);
  8.         // 是一个常量 , 只能赋值一次
  9.         // Inter.num = 20;
  10.     }
  11. }

3.4 接口的案例

  1. package com.itheima.interface_demo.interface_test;
  3. public interface player {
  4.     public abstract void play();
  5.     public abstract void pause();
  6.     public abstract void stop();
  7. }
  1. package com.itheima.interface_demo.interface_test;
  3. public class MP3 implements player {
  4.     @Override
  5.     public void play() {
  6.         System.out.println("MP3开始播放音乐");
  7.     }
  9.     @Override
  10.     public void pause() {
  11.         System.out.println("MP3开始暂停");
  12.     }
  14.     @Override
  15.     public void stop() {
  16.         System.out.println("MP3开始关闭音乐");
  17.     }
  18. }
  1. package com.itheima.interface_demo.interface_test;
  3. public class MP4 implements player {
  4.     @Override
  5.     public void play() {
  6.         System.out.println("MP4播放音乐");
  7.     }
  9.     @Override
  10.     public void pause() {
  11.         System.out.println("MP4暂停音乐");
  12.     }
  14.     @Override
  15.     public void stop() {
  16.         System.out.println("MP4关闭音乐");
  17.     }
  18. }
  1. package com.itheima.interface_demo.interface_test;
  2. /*
  3.    需求 :
  4.    1  创建一个播放接口 player
  5.    2  定义三个抽象方法 , 播放(play),暂停(pause),停止(stop)
  6.    3  定义MP3类,MAP4类,手机类,实现接口,重写抽象方法
  8.  */
  9. public class PlayerTest {
  10.     public static void main(String[] args) {
  11.         MP3 mp3 = new MP3();
  12.         mp3.play();
  13.         mp3.pause();
  14.         mp3.stop();
  15.         System.out.println("=============");
  16.         MP4 mp4 = new MP4();
  17.         mp4.play();
  18.         mp4.pause();
  19.         mp4.stop();
  20.     }
  21. }

3.5 接口中成员方法的特点

  • 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
    注意 : 每个枚举项都相当于枚举的对象

  • 案例代码 ```java package com.itheima.enum_demo;

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

  1. // 成员变量
  2. private String name;
  4. // 空参构造方法
  5. private Sex() {
  6. }
  8. // 有参构造方法
  9. private Sex(String name) {
  10.     this.name = name;
  11. }
  13. // 成员方法
  14. public String getName() {
  15.     return name;
  16. }

}

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

  • 组成部分 :

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