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

公告

View Post

1 关键字

2 代码块

3 接口

4 枚举

1 Java中的关键字

1.1 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关键字

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

1.3 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 代码块

2.1 构造代码块

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

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 接口

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 枚举

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

Notepad++记事本创建枚举A

public enum A{
	X,Y,Z;
}

javac 编译之后 A.class javap 反编译A.class 得到如下结果

public final class A extends java.lang.Enum<A> {
  public static final A X;
  public static final A Y;
  public static final A Z;
  public static A[] values();
  public static A valueOf(java.lang.String);
  static {};
}

posted on 2023-10-23 11:38 周政然阅读(20) 评论(0) 编辑收藏举报

刷新页面返回顶部

奋斗的软件工程师

公告

View Post

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

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

1 Java中的关键字

1.1 static关键字

static关键字 :

static特点 :

static内存图解

static关键字的注意事项

1.2 final关键字

1.3 Java中的权限修饰符

2 代码块

2.1 构造代码块

2.2 静态代码块

3 接口

3.1 接口的介绍

3.2 接口的定义和特点

3.3 接口的成员特点

3.4 接口的案例

3.5 接口中成员方法的特点

4 枚举