关键字,接口,代码块,枚举

关键字

static关键字

什么是static？

static（静态）是java语言中的修饰符关键字用来修饰：成员变量、成员方法（被static修饰的成员变量，一般叫做静态变量；被static修饰的成员方法，一般叫做静态方法）

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

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

static怎么使用？

public class Student{
//成员变量
private String name;
private static String city;//静态成员变量
//静态成员方法
public static void method(){ }
}//通过类名访问静态内容（静态的私有成员变量不能访问）

static在使用中的注意细节？

1、静态内容是随着类的加载就存在了（早于对象创建）

2、静态内容通常是使用： 类名.成员变量 类名.成员方法()，也可以通过对象名调用

3、静态方法中只能访问静态成员（静态变量、静态方法）

4、静态方法中不能使用this关键字

5、非静态方法中可以直接访问：静态成员

pubilc class Static2(){
    //静态成员变量
    public static int number = 10;
    //静态成员方法
    public static void send(){
        System.out.println("好好休息吧");
    }
}
-------------------------------------------------------------------------------
//当程序中的某个数据需要共享时使用static修饰
public class Text1 {
    public static void main(String[] args) {
        //创建对象
        Static2 st1 = new Static2();
        Static2 st2 = new Static2();
        Static2 st3 = new Static2();
       st1.number++;
        st2.number++;
        st3.number++;
        System.out.println(Static2.number);//13
}
}
----------------------------------------------------------
public class Text2 {
    //静态成员变量
   static int  a = 19;
   int b=100;
    private  String name;//非静态成员变量
    //测试：静态内容不需要创建对象，就可以使用（早于对象存在）

    public static void main(String[] args) {
        System.out.println(Static2.number);//10
        Static2.send();//好好休息吧
        show();//show          //静态方法只能访问静态成员（静态变量，静态方法）
        System.out.println(a);//19
       // System.out.println(b);//不是静态的，会报错
        //静态方法什么地方常用：在工具类中，如：Math工具类中
        int a=10;
        int c=90;
        int g=Math.max(a,c);
        System.out.println(g);//90
  }

    //静态方法
    public static void show(){
        System.out.println("show");
        //在静态方法中不能使用this
       // this.name="测试";
    }

    //非静态方法    
    public  void show2(){
        this.name="我不好！";
        System.out.println("show2");
        System.out.println(this.name);
     show();//非静态方法可以访问静态方法，也可以访问非静态方法
          System.out.println(b);
        System.out.println(a);
    }
}

JVM内存划分:

1. 栈

2. 堆

3. 方法区 ：是由N多个不同功能的小区域组成的

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

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

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

4. 寄存器

5. 本地方法区

final关键字

什么是final关键字？

final（最终的，不可改变的）是Java语言中的修饰符关键字，用来修饰：类，变量，方法

final关键字在程序中解决什么问题？

1、当某个变量不允许修改数据值时，可以使用final修饰变量

2、当某个方法不允许被子类重写时，可以使用final修饰方法

3、当某个类不允许被继承时，可以使用final修饰类。 举例：String类

final关键字怎么使用？

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

关键字在使用中要注意什么细节？
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次）

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

import java.util.ArrayList;

/* 静态代码块 :
      1 定义的位置 : 在一对大括号前加上static , 定义在类中方法外
      2 执行时机 ; 随着类的加载而执行, 只加载一次
      3 可以给类中的静态成员进行初始化数据
 */
public class StaticCode {
    //集合
    private static ArrayList<String> list = new ArrayList<String>();


    //静态代码块
    static {
        System.out.println("静态代码块~");

        //初始化数据
        list.add("Java");
        list.add("MySQL");
        list.add("Mybatis");
        list.add("html");
    }

    //获取数据
    public static String getData(int index){
        String str =list.get(index);
        return str;
    }
}
---------------------------
public class StaticCodeTest {
    public static void main(String[] args) {
        //不需要创建对象，使用静态方法获取数据
        String data = StaticCode.getData(2);

        System.out.println(data);
    }
}
运行结果：Mybatis

构造代码块

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

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

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

//构造代码块
public class ConstructorCode {
    //集合对象
    ArrayList<String> list = new ArrayList<String>();
//构造代码块
    {
        System.out.println("构造代码块~~~");
        //把构造方法中共性内容书写在构造代码块中
        list.add("Java");
        list.add("MySQL");
        list.add("HTML");
    }
    //构造方法
    public ConstructorCode() {
        //初始化集合中的元素
        System.out.println("无参构造方法");
    }

    public ConstructorCode(String str) {
        System.out.println("有参构造方法");
        //初始化集合中的元素
        list.add(str);
    }
}
-------------------------------------
public class ConstructorCodeTest {
    public static void main(String[] args) {
        //创建对象
        ConstructorCode c1 = new ConstructorCode();

        ConstructorCode c2 = new ConstructorCode("测试");
    }
}
运行结果：
构造代码块~~~
无参构造方法
构造代码块~~~
有参构造方法

局部代码块

书写位置：写在方法体中

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

作用：用于作用域

接口

什么是接口？

一个类中的所有方法都是抽象方法的时候，此类就是定义规则的类 , 我们就可以将其定义为**接口**

接口也是一种引用数据类型，它比抽象类还要抽象

接口的作用：

制定规则

制定规则的两种方案：

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

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

接口的定义：

public interface 接口名{
//成员方法：只能是抽象方法，默认修饰符：public abstract

//成员变量：只能是常量，默认修饰符：public static final

}

接口的调用：

interface MyInterface {
void myMethod();
}

class Implementation implements MyInterface {
@Override
public void myMethod() {
System.out.println(“Implementation’s method”);
}
}

// 调用
MyInterface obj = new Implementation();
obj.myMethod();

接口的特点：

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版本中新增：

默认方法（但是需要使用关键字default修饰）、静态方法 //有方法体代码

默认方法的定义格式：
格式：public default 返回值类型 方法名(参数列表) {   }
范例：public default void show() {   }
静态方法的定义格式：
格式：public static 返回值类型 方法名(参数列表) {   }
范例：public static void show() {   }

在jdk1.9版本中新增：

私有方法 //有方法体代码

私有方法的定义格式 ：

格式1：private 返回值类型 方法名(参数列表) {   }
范例1：private void show() {   }

格式2：private static 返回值类型 方法名(参数列表) {   }
范例2：private static void method() {   }
作用 : 接口中的方法出现了重复的代码，还不想被其他类访问 , 可以考虑抽取出一个私有方法

接口中默认方法的注意事项：

默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字

public可以省略，default不能省略

如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

接口中静态方法的**注意事项**：

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

public可以省略，static不能省略

类和接口的概念：

类和类之间的关系： 继承 （只能单一继承）

public 子类 extends 父类{

}

类和接口之间的关系：实现

public 子类 implements 接口{

}

接口和接口之间的关系：继承 （允许多继承）

public 接口1 extends 接口2 {

//问题：为什么接口可以多继承？

//答案：接口中仅仅只是定义功能（没有功能的实现，子类要自己实现功能）}

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

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

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

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

抽象类和接口的区别：

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

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

选择语句：

switch( 常量表达式 )

{ //只能使用：byte、short、int、char、String、枚举

case 常量值1:

 语句1;   

 break;   

… }

枚举

什么是枚举？

在java语言中，枚举是一种数据类型。枚举用来表示：固定且仅有几种取值范围的数据

枚举解决程序中的什么问题？

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

枚举怎么使用？

//枚举类型
public enum Signal {
//取值范围
GREEN, YELLOW, RED;
}

public class Test {
//根据红绿灯变化，执行交通
public static void chang(Signal color) {
switch (color){
case RED:
System.out.println(“红灯停”);
break;
case GREEN:
System.out.println(“绿灯行”);
break;
case YELLOW:
System.out.println(“黄灯等一等”);
break;
}
}
public static void main(String[] args) {
//调用静态方法
chang(Signal.GREEN);
}
}
运行结果：绿灯行

枚举在使用中有哪些注意细节？

1. 枚举本质是一个类

2.在枚举中除了可以书写：固定选项值外，还可以书写：成员变量、私有构造方法、成员方法

3.枚举的构造方法必须是private的，不能从外部实例化。