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

关键字

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. 栈
  1. 方法区 :是由N多个不同功能的小区域组成的

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

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

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

  2. 寄存器

  3. 本地方法区

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. 定义类,类中书写抽象方法(不建议使用。 类只能单一继承)
  1. 定义接口, 接口中书写抽象方法(接口好处:可以多实现)

接口的定义:

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. 接口不能实例化(不能创建对象)
  1. 接口中没有构造方法(接口只能通过子类来实现对象创建)

  2. 接口可以多实现( 一个类可以实现多个接口[解决类只能单一继承的问题] )

按照接口中定义的规则开发子类:

接口的子类(实现类):

要么重写接口中的所有抽象方法

要么是抽象类

编写接口实现类

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. 接口和抽象类, 都不能实例化(不能创建对象)
  1. 接口和抽象类,都具有抽象方法

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

抽象类和接口的区别:

1. 抽象类:除了抽象方法外,还具有成员变量、构造方法、非抽象方法
  1. 接口:除了抽象方法外,只有常量 (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的,不能从外部实例化。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值