【java】关键字、代码块、接口、枚举学习笔记

朱雀 2023-09-29 15:58 49阅读 0赞

### 主要内容 ###

**1 关键字**

**2 代码块**

**3 接口**

**4 枚举**

### 1 Java中的关键字 ###

#### 1.1 static关键字 ####

用一句话说就是：可以直接通过对象.的形式使用，不用new实例化调用  
![在这里插入图片描述][327f4688e4894f95bb59ad38b2d77fd0.png]

*  ###### 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关键字的注意事项 ######
    
     *  静态方法中只能调用静态成员
     *  非静态方法中可以调用任何成员
     *  静态方法中不能存在this关键字

#### 1.2 final关键字 ####

![在这里插入图片描述][da57c834b8d84af99c0cd8f7df91d2f6.png]

*  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();
        //    }
        }

#### 1.3 Java中的权限修饰符 ####

![在这里插入图片描述][27b47740ce134423b3710adb3aa00651.png]

*  public – protected – 默认的 – private
    
    ![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cXHKRPAC-1653405452208)(\\img\\image-20210331215542736.png)\]][img-cXHKRPAC-1653405452208_img_image-20210331215542736.png]
    
        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 代码块 ###

#### 2.1 构造代码块 ####

![在这里插入图片描述][bafa5bf7007d4e248262e361034a6184.png]

*  构造方法块 : 用一对大括号表示, 定义在类中方法外
 *  执行时机 : 每次构造方法执行前, 都会执行构造代码块
 *  作用 : 抽取构造方法中共性内容

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);
    
    
        }
    }

#### 2.2 静态代码块 ####

*  静态代码块 : 在一对大括号前加上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 接口 ###

![在这里插入图片描述][82c1b609e6b6437db54fd5e45ceaba6b.png]  
![在这里插入图片描述][88d677cf8d504090b5bdc8f63b18c4a1.png]

#### 3.1 接口的介绍 ####

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

#### 3.2 接口的定义和特点 ####

*  定义接口的关键字使用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();
    
        }
    }

#### 3.3 接口的成员特点 ####

*  成员变量 : 都是常量 , 默认修饰符 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;
        }
    }

#### 3.4 接口的案例 ####

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();
        }
    }

#### 3.5 接口中成员方法的特点 ####

*  DK8版本之前 : 只能是抽象方法
 *  JDK8版本 :
    
     *  默认方法
        
         *  JDK8可以在接口中定义非抽象方法(带有方法体的方法) , 需要使用default进行修饰 , 其实就是默认方法
         *  作用 : 解决接口升级的问题
         *  格式 : public default 返回值类型 方法名(参数) \{ … \}
         *  注意事项 :
            
             *  默认方法不是抽象方法 , 可以继承 , 也可以重写 , 重写需要去掉default关键字
             *  public 可以省略 , default不能省略
             *  如果实现类实现了多个接口 , 有相同的方法声明 , 那么实现类必须重写该方法
     *  静态方法
        
         *  JDK8可以在接口中定义静态方法 , 也是有方法体的方法
         *  作用 : 方便调用此功能
         *  格式 : public static 返回值类型 方法名(参数)\{ … \}
         *  注意事项
            
             *  静态方法只能通过接口名调用 , 不能通过实现类名字和对象调用
             *  public可以省略 , static不能省略
 *  JDK9版本 :
    
     *  私有方法
        
         *  JDK9中新增私有方法
         *  作用 : 抽取默认方法中共性内容
         *  格式 : private 返回值类型 方法名(参数)\{ … \}
         *  注意 : 要想抽取静态方法中的共性内容 , 需要对私有方法加上关键字static

### 4 枚举 ###

![在这里插入图片描述][7aa21fad04bc46a9867d2a9f551da4b5.png]

*  枚举 : 当一个变量有几种固定可能的取值时，就可以将它定义为枚举类型
 *  作用 : 更贴切 , 加见名之意
 *  定义 : 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
 *  组成部分 :
    
     *  构造器，成员方法，成员变量等 , 但是定义的成分一定要在枚举项之后，而且最后一个枚举项必须要有分号结束。

[327f4688e4894f95bb59ad38b2d77fd0.png]: https://img-blog.csdnimg.cn/327f4688e4894f95bb59ad38b2d77fd0.png
[da57c834b8d84af99c0cd8f7df91d2f6.png]: https://img-blog.csdnimg.cn/da57c834b8d84af99c0cd8f7df91d2f6.png
[27b47740ce134423b3710adb3aa00651.png]: https://img-blog.csdnimg.cn/27b47740ce134423b3710adb3aa00651.png
[img-cXHKRPAC-1653405452208_img_image-20210331215542736.png]: https://img-blog.csdnimg.cn/8779e35628e445dc9fae4089d09e521f.png
[bafa5bf7007d4e248262e361034a6184.png]: https://img-blog.csdnimg.cn/bafa5bf7007d4e248262e361034a6184.png
[82c1b609e6b6437db54fd5e45ceaba6b.png]: https://img-blog.csdnimg.cn/82c1b609e6b6437db54fd5e45ceaba6b.png
[88d677cf8d504090b5bdc8f63b18c4a1.png]: https://img-blog.csdnimg.cn/88d677cf8d504090b5bdc8f63b18c4a1.png
[7aa21fad04bc46a9867d2a9f551da4b5.png]: https://img-blog.csdnimg.cn/7aa21fad04bc46a9867d2a9f551da4b5.png