java零基础入门学习第九天——final关键字和 static关键字、接口

最新推荐文章于 2025-03-27 11:32:44 发布

h_jQuery

最新推荐文章于 2025-03-27 11:32:44 发布

阅读量198

点赞数

分类专栏：笔记学习 java 文章标签：抽象类 java 接口多态继承

本文链接：https://blog.csdn.net/h_jQuery/article/details/113749004

版权

学习同时被 3 个专栏收录

67 篇文章

订阅专栏

笔记

49 篇文章

订阅专栏

java

21 篇文章

订阅专栏

本文详细介绍了Java中的final关键字，包括它如何修饰类、方法和变量，强调了final变量的不可变性。同时，讲解了static关键字，说明了静态成员的特性，如静态变量的共享性以及静态方法的应用场景。接着，讨论了接口的概念，解释了接口的使用、继承以及接口成员的特点，如默认方法和静态方法的引入。最后，探讨了接口在多态和类继承中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

final关键字

final的概念：最终的，最后的

final的作用：用于修饰类、方法和变量

final的作用：

**1.**修饰类：该类不能被继承，但是可以继承别的类

**2.**修饰方法：该方法不能被重写，不能与abstract共存

**3.**修饰变量：最终变量，即常量，只能赋值一次；不建议修饰引用类型数据，因为仍然存在可以通过引用修改对象的内部数据，意义不大

package study4.demo;
//程序员类
public class Coder2 extends Enployee {
//    @Override
//    public void show() {
//        System.out.println("这个是个玩笑");
//    }
}

package study4.demo;
//员工类
public class Enployee {
    //    成员变量
    String name;
    int age;
    public final void show() {
        System.out.println("这个是个秘密");
    }
}

package study4.demo;
/*

 */
public class Test3 {
    public static void main(String[] args) {
        Enployee e = new Coder2();
        e.show();
        System.out.println("————————");

//        final修饰的变量，基本类型的变量时，值是不能改变的
        final int n = 20;
//        n = 30;     代码报错，因为n被final修饰了，不可以改变该值了
        System.out.println(n);
        System.out.println("————————");

//        final修饰的变量，引用类型的变量时，地址值是不能改变的，但是属性值是可以发生变化的
        final Enployee en = new Enployee();
//        en = new Enployee();          //报错，因为有new存在就会开辟一个新的空间，地址值发生改变
        en.name = "张三";
        en.age = 23;
        System.out.println(en.name);
        System.out.println(en.age);

        en.name = "张无忌";
        en.age = 20;
        System.out.println(en.name);
        System.out.println(en.age);
    }
}

static关键字

static的概念：静态的

static的作用：

用于修饰类的成员（变量和方法）：

成员变量：类（静态）变量；

静态变量被该类下所有的对象所共享（一个对象改了，其余对象也改了）

成员方法：类方法；

静态方法：静态方法中没有对象this，所以不能访问非静态成员

静态方法的使用场景：只需要访问静态成员；不需要访问对象状态，所需参数都由参数列表显示提供

静态成员的调用方式：可以通过 类名. 的形式直接调用

static修饰成员变量：

特点：被本类所有对象共享

需求：定义研发部成员类，让每位成员进行自我介绍

注意事项：随意修改静态变量的值是有风险，为了降低风险，可以同时用final关键字修饰，即共有静态常量（注意命名的变化）

package study4.demo;
//开发者类
public class Developer {
//    成员变量
//    成员变量没有用private修饰，就不用设置setXxx和getXxx
    String name;
    String work;
//    部门名（公共的静态变量）departmentName
    public final static String DEPARTMENT_NAME = "研发部";      //被final修饰了就不可以改变值了
//被static修饰了，该类下的所有对象都可以使用，因此权限修饰符可以用public修饰

//    成员方法
//    自我介绍
    public void selfIntroduction() {
        System.out.println("我是"+DEPARTMENT_NAME+"的"+name+"，我的工作内容是"+work);
    }
}

package study4.demo;

public class Test4 {
    public static void main(String[] args) {
        Developer d = new Developer();
        d.name = "小黑";
//        d.departmentName = "研发部";
//        d.departmentName = "开发部";
        d.work = "写代码";
        d.selfIntroduction();
        System.out.println("——————————");

        Developer de = new Developer();
        de.work = "鼓励师";
        de.name = "小白";
//        de.departmentName = "研发部";
        de.selfIntroduction();
//        部门名改为开发部
//        Developer.departmentName = "开发部";     //报错，该变量用final修饰了不可以改变了，
        d.selfIntroduction();
        de.selfIntroduction();
    }
}

需求：定义静态方法，反转数组中的元素

package study4.demo;
//静态方法中没有对象this,所以不能访问非静态成员
//非静态成员是属于对象的，只要new才可以存在
//静态成员是属于类的，类是优先于对象存在的，所以在静态方法中访问不了非静态成员
public class ReverseArray {
    int num1 = 10;
    static int num2 = 20;
//    show()用static修饰了
    public static void show() {
//        System.out.println(num1);报错，num1是非静态成员
        System.out.println(num2);
    }
    public static void reverse(int[] arr){
//        这里只要完成：交换元素的动作就可以
//        假设数组中的元素值为：int[] arr={11,22,33,44,55}
//        明确谁和谁交换：第int[i]个和第arr[arr.length-1-i]个交换
//        明确循环的数次：叔叔的长度/2
        for (int i =0;i < arr.length / 2;i++) {
//            第int[i]个和第arr[arr.length-1-i]个进行交换
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length-1-i] = temp;
        }
    }
}

package study4.demo;
/*
    静态方法：静态方法中没有对象this,所以不能访问非静态成员
    静态方法的使用场景：如果某方法只访问静态成员，并且不需要通过 对象名. 的形式调用，就可以考虑将其定义为：静态方法
    需求：定义静态方法，反转数组中的元素
 */
public class Test5 {
    public static void main(String[] args) {
//        测试show()方法
            ReverseArray.show();

//            小需求
        int a = 10;
        int b = 20;
        int c = a;      //c=10
        a = b;      //a=20
        b = c;          //b=10
        System.out.println(a);
        System.out.println(b);
        System.out.println("————————");

//        调用方法，反转数组
        int[] arr = {1,5,9,3,6,8};
        for (int i = 0; i < arr.length; i++) {
            System.out.println("正序："+arr[i]);
        }
        System.out.println("————————");
        ReverseArray.reverse(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println("倒序："+arr[i]);
        }
    }
}

接口

接口的概念：接口技术用于描述具有什么功能，但并不给出具体实现，类要遵从接口描述的统一规则进行定义，所以，接口是对外提供的一组规则、标准

接口的定义：

1.定义接口使用关键字interface

interface 接口名 {}

2.类和接口是实现关系，用implements表示

class 类名 implements 接口名

接口成员方法中会默认有public abstract修饰符
若你写了，系统就会加上，若你没写，系统会默认给你加上，建议加上

接口比抽象类更抽象的存在，所以不能实例化

package study4.demo;
//接口，表示抽烟
public interface Smoking {
//成员方法
//    接口成员方法中会默认有public abstract修饰符
//    若你写了，系统就会加上，若你没写，系统会默认给你加上，建议加上
    public abstract void smoke();
}

package study4.demo;
//接口smoking的实现类（子类）
public class Teacher implements Smoking {

    @Override
    public void smoke() {
        System.out.println("抽烟有害健康");
    }
}

package study4.demo;

public class Test6 {
    public static void main(String[] args) {
//        Smoking s = new Smoking();报错，因为接口比抽象类更抽象的存在，所以不能实例化
//        通过创建其子类对象
        Smoking s = new Teacher();
        s.smoke();
    }
}

接口创建对象的特点

1.接口不能实例化：通过多态的方法实例化子类对象（接口比抽象类更抽象的存在，所以不能实例化）

2.接口的子类（实现类）：

可以是抽象类（不用重写接口中的抽象方法）

也可以是普通类（必须重写接口中所有的抽象方法）

接口继承关系的特点

类与类之间：继承关系，单继承，可以多层继承

类与接口：实现关系，可以单实现，也可以多实现

接口与接口之间的关系：

继承关系，可以单继承，也可以多继承，

格式：接口 extends 接口1，接口2，接口3……

继承和实现的区别：

继承体现的是“is a”的关系，父类中定义共性内容

实现体现的是“like a”的关系，接口中定义扩展功能

package study4.demo;
//接口
public interface Usb {
//    连接
    public abstract void open();
//    断开
    public abstract void close();

}

package study4.demo;

public interface A extends B,C,Usb {
}

package study4.demo;

public interface B {
}

package study4.demo;

public interface C {
}

package study4.demo;
//鼠标
public class Mouses implements Usb,A,B,C {

    @Override
    public void open() {
        System.out.println("连接鼠标");
    }

    @Override
    public void close() {
        System.out.println("鼠标断开连接");
    }
}

package study4.demo;
//子类，键盘类
//不想重写父类的方法就加上abstract修饰符，就变成了抽象类，抽象类不用重写父接口的方法
public abstract class KeyBoard implements Usb {

}

package study4.demo;
/*
    总结：对于一个类来说，他的父类（继承的关系）中定义的都是：共性内容
        对于一个类来说，他的父接口（实现的关系）中定义的都是：扩展内容
 */
public class Test7 {
    public static void main(String[] args) {
//        测试鼠标类
        Usb u = new Mouses();
        u.open();
        u.close();
    }
}

总结：

对于一个类来说，他的父类（继承的关系）中定义的都是：共性内容
对于一个类来说，他的父接口（实现的关系）中定义的都是：扩展内容

接口成员的特点

接口成员变量的特点：没有成员变量，只有公有的、静态的常量：

public abstract final 常量名 = 常量值;

接口中所有的变量都会有一组默认修饰符public abstract final，如果你写了，系统就不写；如果你没写，系统会默认加上。

接口成员方法的特点：

成员方法：

JDK7以前，公有的、抽象的：

public abstract 返回值类型方法名();

接口中的所有方法都会有一组默认的修饰符public abstract，如果你写了，系统就不写；如果你没写，系统会默认加上。

JDK8以后，可以有默认方法和静态方法：

public default 返回值类型方法名() {}

static 返回值类型方法名() {}

JDK9以后，可以有私有方法：

private 返回值类型方法名() {}

接口构造方法的特点：

构造方法：接口不能够实例化，也没有需要初始化的成员，所以接口没有构造方法

package study4.demo;

public interface CPU {
//    成员常量
//    public static final默认存在，不写系统会默认加上
    public static final int num = 10;
//    成员方法
//    JDK7其及以前的写法
//    public abstract默认存在
    public abstract void open();
    void close();
//    JDK8写法
    public static void method() {
        System.out.println("aaaaaa");
    }
    public default void close2() {
        System.out.println("cdskcjsdlvlk");
    }

}

package study4.demo;

public class Test8 {
    public static void main(String[] args) {
//        测试接口中的变量
        System.out.println(CPU.num);
//        CPU.num = 20; 报错，num是一个常量，不可以改

    }
}