JavaSE进阶——Day02 代码块、接口、枚举

发表于 更新于 分类于 阅读次数： Changyan： 本文字数： 1.1k 阅读时长 ≈ 4 分钟

JavaSE进阶——Day02 该篇主要讲解Java中的代码块、接口、枚举

学习目标

  • 关键字

    • final

    • static

  • 代码块

    • 静态代码块

    • 构造代码块

    • 局部代码快

  • 接口

    • 接口的作用及格式

    • 接口的成员定义

    • 接口在JDK不同版本中方法的改进

  • 枚举

    • 枚举的作用及格式

    • 枚举的使用

    • 枚举的本质

static

什么是static

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

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

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

static怎么使用？

1
2
3
4
5
6
7
8
9
10
11
12
public class Student{
    //成员变量
    private String name;
    private static String city;//静态成员变量
    
    //静态成员方法
    public static void method(){
        
    }
}

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

static在使用中的注意细节

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

JVM内存划分:

  1. 栈
  2. 堆
  3. 方法区
    • 是由N多个不同功能的小区域组成的
      • 静态区域：存放静态内容
      • 非静态区域：存放非静态内容
      • 字符串常量池：存放字符串常量
  4. 寄存器
  5. 本地方法区

final

final是什么

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

final解决程序中什么问题

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

final怎么使用

1
2
3
4
5
6
7
8
public final class 类名{
    
    private final int COUNT=100;
   
    public final void method(){
       
   } 
}

final在使用中的注意细节

1
final和abstract不能共存使用

权限修饰符

权限修饰符是什么

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

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

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

权限修饰符怎么使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//类（权限：公开的 [没有限制]）
public class 类{
    //成员变量（私有权限：本类中使用）
    private String name;
    
    //默认权限（权限：当前包下的任意类）
    void show(){
        
    }
    
    //protected（权限：子类）
    protected void method(){
        
    }
}

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

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

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

工具类

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

  • 工具类的特点：
    1. 不能被继承
    2. 不能让其他类创建对象
    3. 提供静态方法
1
2
3
4
5
6
7
8
9
10
11
//final保障 ：工具类不能被继承
public final class 工具类{
    
    //不能让其他类创建对象
    private 工具类(){}
    
    //给外部提供：静态方法
    public static 返回值 静态方法(...){
        
    }
}

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

1
2
3
4
5
6
7
8
9
10
public class 类{
    //成员变量：静态、非静态
    
    //成员方法：静态、非静态、抽象
    
    //构造方法
    
    //代码块
    
}

代码块：

1
2
3
{
    
}

代码块划分：

  • 静态代码块 //开发中使用最多
    • 书写位置：在类中方法外（和成员变量、成员方法属于同一级）
      • 在构造代码块上添加：static
    • 特点：随着类的加载，执行1次静态代码块（类只会被加载1次）
    • 作用：用于对静态成员数据进行初始化
  • 构造代码块
    • 书写位置：在类中方法外（和成员变量、成员方法属于同一级）
    • 特点：在每个构造方法执行前，都会先执行构造代码块
    • 作用：当类中多个构造方法中有共性内容时，可能抽取到构造代码块
  • 局部代码块
    • 书写位置：写在方法体中
    • 特点：在方法执行时，才会调用
    • 作用：用于作用域

接口

接口的作用：制定规则

制定规则的两种方案：

  1. 定义类，类中书写抽象方法（不建议使用。 类只能单一继承）
  2. 定义接口， 接口中书写抽象方法（接口好处：可以多实现）

接口的定义：

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

接口的特点：

  1. 接口不能实例化（不能创建对象）
  2. 接口中没有构造方法（接口只能通过子类来实现对象创建）
  3. 接口可以多实现（ 一个类可以实现多个接口[解决类只能单一继承的问题] ）

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

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

接口的多实现：

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

在接口可以书写的内容：

1
2
3
4
5
6
7
public interface 接口名{
    
    //抽象方法
    
    //静态常量
    public static final int NUMBER = 10;
}

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    问题：生活中有没有一些数据是固定的，且值比较单一？
    示例：性别（固定、且仅有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版本中新增：私有方法 //有方法体代码

类和接口的概念：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
类和类之间的关系： 继承 （只能单一继承）
public 子类 extends 父类{
    
}

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

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

  1. 接口和抽象类， 都不能实例化（不能创建对象）
  2. 接口和抽象类，都具有抽象方法
  3. 接口和抽象类，都是做为父类型存在的

抽象类和接口的区别：

  1. 抽象类：除了抽象方法外，还具有成员变量、构造方法、非抽象方法
  2. 接口：除了抽象方法外，只有常量 （JDK8：默认方法、静态方法）（JDK9：私有方法）

总结：

  1. static关键字

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    //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. 非静态方法中可以访问：静态方法、静态变量

  2. final关键字

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    //final是什么？
    final是java语言中的修饰符关键字。用来修饰：类、方法、变量
        
    //final可以解决程序中什么问题？
    final修饰的类：不能被继承
    final修饰的方法： 不能被重写
    final修饰的变量： 初始化值后不能改变其值（常量）
        
    //final的使用
    public final class 类名{
        //变量
        final String name="初始化值";
        
        //方法
        public final void method(){
            
        }
    }

  3. 权限修饰符号

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    //权限修饰符解决什么问题？
    限制程序中访问权限

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

  4. 接口

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    //接口的作用：
    制定规则 
        

    //接口的定义（语法）
    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{
            //重写所有抽象方法
        }

  5. 代码块

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

选择语句：

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

枚举

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
//什么是枚举
在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. 在枚举中除了可以书写：固定选项值外，还可以书写：成员变量、私有构造方法、成员方法